第九節：基於MVC5+AutoFac+EF+Log4Net的基礎結構搭建

一. 前言

　　從本節開始，將陸續的介紹幾種框架搭建組合形式，分析每種搭建形式的優勢和弊端，剖析搭建過程中涉及到的一些思想和技巧。

(一). 技術選型

　　1. DotNet框架：4.6

　　2. 數據庫訪問：EF 6.2 (CodeFrist模式)

　　3. IOC框架：AutoFac 4.8.1 和 AutoFac.MVC5 4.0.2

　　4. 日志框架：log4net 2.0.8

　　5. 開發工具：VS2017

(二). 框架目標

　　1. 一個項目同時連接多個相同種類的數據庫，在一個方法中可以同時對多個數據進行操作。

　　2. 支持多種數據庫：SqlServer、MySQL、Oracle，靈活的切換數據庫。

　　3. 抽象成支持多種數據庫連接方式：EF、ADO.Net、Dapper。

 

二. 搭建思路

 1. 層次划分

　　將框架分為：Ypf.Data、Ypf.IService、Ypf.Service、Ypf.DTO、Ypf.Utils、Ypf.AdminWeb 六個基本層（后續還會補充 Ypf.Api層），每層的作用分別為：

　　①. Ypf.Data：存放連接數據庫的相關類，包括EF上下文類、映射的實體類、實體類的FluentApi模式的配置類。

　　②. Ypf.IService：業務接口層，用來約束接口規范。

　　③. Ypf.Service：業務層，用來編寫整套項目的業務方法，但需要符合Ypf.IService層的接口約束。

　　④. Ypf.DTO: 存放項目中用到的自定義的實體類。

　　⑤. Ypf.Utils: 工具類

　　⑥. Ypf.AdminWeb: 表現層，系統的展示、接受用戶的交互，傳遞數據，業務對接。

PS：后續會補充Ypf.Api層，用於接受移動端、或其他客戶端接口數據，進行相應的業務對接處理。

2. Ypf.Data層的剖析

　　把EF封裝到Ypf.Data層，通過Nuget引入EF的程序集，利用FluentAPI的模式先進行配置（實際項目多種模式配合使用），該層的結構如下：

PS：EF的關閉默認策略、EF的DataAnnotations、EF的FluentAPI模式， 在關閉數據庫策略的情況下，無論哪種模式都需要顯式的 ToTable來映射表名，否則會提示該類找不到。

EF配置詳情參考：

         第十五節: EF的CodeFirst模式通過DataAnnotations修改默認協定

         第十六節: EF的CodeFirst模式通過Fluent API修改默認協定

3. Service層和IService層簡單的封裝一下

【PS：這個地方是個關鍵點，需要考慮多種不同的寫法，然后進行封裝】

　　①.【Ypf.Service】層只有一個BaseService泛型類封裝，【Ypf.IService】層並沒有設置IBaseService接口，設置了一個IServiceSupport標識接口(沒有任何內容)，需要“AutoFac注入”的所有子類IxxxService都要實現IServiceSupport接口。

　　②.【Ypf.Service】層中有很多自定義的 xxxService，每個xxxService都要實現【Ypf.IService】層的IxxxService層接口，這里的xxxService層划分並不依賴表名划分，自定義根據業務合理起名即可。

　　③. xxxService類中，利用using() 包裹EF的上下文“db”便於釋放，然后把EF上下文傳入到泛型的BaseService<T>類的構造函數中，可以調用其封裝的方法。

　　④.利用AutoFac實現在控制器中屬性的注入，相應的配置均寫在Global文件中。

　　⑤.控制器中的Action僅僅負責傳值和簡單的一些判斷，核心業務全部都寫在Service層中。

4. 利用AutoFac實現Ypf.AdminWeb層與Ypf.Service層解耦

　　利用AutoFac進行整合，使Ypf.AdminWeb層只需要引入YpfIService層即可，但需要改一下Ypf. Service輸出路徑使其程序集輸出到Ypf.AdminWeb層中。

 解析：利用AutoFac把Ypf.Service中的所有類注冊給它的全部實現接口（一個類可能實現了多個接口），並且把實現類中的屬性也進行注冊（實現類中也可能包含屬性的注入）。

AutoFac的配置詳情參考： 

         第二節：框架前期准備篇之AutoFac常見用法總結

5. 將Log4net整合到Ypf.Utils層中

　　解析：主要配置了兩種模式，輸出到“txt文本文檔”和“SQLServer數據庫中”。其中“文本文檔”又分了兩種模式，全部輸入到一個文檔中 和 不同類型的日志輸入到不同文檔下，在調用的時候通過傳入參數來區分存放在哪個文件夾下。

Log4net的配置詳情參考：

　　第一節：框架前期准備篇之Log4Net日志詳解

6. 完善【Ypf.Service】層中BaseService的封裝

 　　封裝EF常用的增刪改查的方法，這里暫時先不擴展EF插件的方法，分享一下代碼。

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.SqlClient;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using Ypf.Data;

namespace Ypf.Service.BaseClass
{
    public class BaseService<T> where T : class
    //public class BaseService
    {
        private DbContext db;

        //子類通過構造函數來傳入EF上下文
        public BaseService(DbContext db)
        {
            this.db = db;
        }

        /****************************************下面進行方法的封裝***********************************************/
        //1. 直接提交數據庫

        #region 01-數據源
        public IQueryable<T> Entities
        {
            get
            {
                return db.Set<T>();
            }
        }
        #endregion

        #region 02-新增
        public int Add(T model)
        {
            DbSet<T> dst = db.Set<T>();
            dst.Add(model);
            return db.SaveChanges();

        }
        #endregion

        #region 03-刪除(適用於先查詢后刪除 單個)
        /// <summary>
        /// 刪除(適用於先查詢后刪除的單個實體)
        /// </summary>
        /// <param name="model">需要刪除的實體</param>
        /// <returns></returns>
        public int Del(T model)
        {
            db.Set<T>().Attach(model);
            db.Set<T>().Remove(model);
            return db.SaveChanges();
        }
        #endregion

        #region 04-根據條件刪除(支持批量刪除)
        /// <summary>
        /// 根據條件刪除(支持批量刪除)
        /// </summary>
        /// <param name="delWhere">傳入Lambda表達式(生成表達式目錄樹)</param>
        /// <returns></returns>
        public int DelBy(Expression<Func<T, bool>> delWhere)
        {
            List<T> listDels = db.Set<T>().Where(delWhere).ToList();
            listDels.ForEach(d =>
            {
                db.Set<T>().Attach(d);
                db.Set<T>().Remove(d);
            });
            return db.SaveChanges();
        }
        #endregion

        #region 05-單實體修改
        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="model">修改后的實體</param>
        /// <returns></returns>
        public int Modify(T model)
        {
            db.Entry(model).State = EntityState.Modified;
            return db.SaveChanges();
        }
        #endregion

        #region 06-批量修改（非lambda）
        /// <summary>
        /// 批量修改（非lambda）
        /// </summary>
        /// <param name="model">要修改實體中 修改后的屬性 </param>
        /// <param name="whereLambda">查詢實體的條件</param>
        /// <param name="proNames">lambda的形式表示要修改的實體屬性名</param>
        /// <returns></returns>
        public int ModifyBy(T model, Expression<Func<T, bool>> whereLambda, params string[] proNames)
        {
            List<T> listModifes = db.Set<T>().Where(whereLambda).ToList();
            Type t = typeof(T);
            List<PropertyInfo> proInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();
            Dictionary<string, PropertyInfo> dicPros = new Dictionary<string, PropertyInfo>();
            proInfos.ForEach(p =>
            {
                if (proNames.Contains(p.Name))
                {
                    dicPros.Add(p.Name, p);
                }
            });
            foreach (string proName in proNames)
            {
                if (dicPros.ContainsKey(proName))
                {
                    PropertyInfo proInfo = dicPros[proName];
                    object newValue = proInfo.GetValue(model, null);
                    foreach (T m in listModifes)
                    {
                        proInfo.SetValue(m, newValue, null);
                    }
                }
            }
            return db.SaveChanges();
        }
        #endregion

        #region 07-根據條件查詢
        /// <summary>
        /// 根據條件查詢
        /// </summary>
        /// <param name="whereLambda">查詢條件(lambda表達式的形式生成表達式目錄樹)</param>
        /// <returns></returns>
        public List<T> GetListBy(Expression<Func<T, bool>> whereLambda)
        {
            return db.Set<T>().Where(whereLambda).ToList();
        }
        #endregion

        #region 08-根據條件排序和查詢
        /// <summary>
        /// 根據條件排序和查詢
        /// </summary>
        /// <typeparam name="Tkey">排序字段類型</typeparam>
        /// <param name="whereLambda">查詢條件</param>
        /// <param name="orderLambda">排序條件</param>
        /// <param name="isAsc">升序or降序</param>
        /// <returns></returns>
        public List<T> GetListBy<Tkey>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, Tkey>> orderLambda, bool isAsc = true)
        {
            List<T> list = null;
            if (isAsc)
            {
                list = db.Set<T>().Where(whereLambda).OrderBy(orderLambda).ToList();
            }
            else
            {
                list = db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda).ToList();
            }
            return list;
        }
        #endregion

        #region 09-分頁查詢
        /// <summary>
        /// 根據條件排序和查詢
        /// </summary>
        /// <typeparam name="Tkey">排序字段類型</typeparam>
        /// <param name="pageIndex">頁碼</param>
        /// <param name="pageSize">頁容量</param>
        /// <param name="whereLambda">查詢條件</param>
        /// <param name="orderLambda">排序條件</param>
        /// <param name="isAsc">升序or降序</param>
        /// <returns></returns>
        public List<T> GetPageList<Tkey>(int pageIndex, int pageSize, Expression<Func<T, bool>> whereLambda, Expression<Func<T, Tkey>> orderLambda, bool isAsc = true)
        {

            List<T> list = null;
            if (isAsc)
            {
                list = db.Set<T>().Where(whereLambda).OrderBy(orderLambda)
               .Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
            }
            else
            {
                list = db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda)
              .Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
            }
            return list;
        }
        #endregion

        #region 10-分頁查詢輸出總行數
        /// <summary>
        /// 根據條件排序和查詢
        /// </summary>
        /// <typeparam name="Tkey">排序字段類型</typeparam>
        /// <param name="pageIndex">頁碼</param>
        /// <param name="pageSize">頁容量</param>
        /// <param name="whereLambda">查詢條件</param>
        /// <param name="orderLambda">排序條件</param>
        /// <param name="isAsc">升序or降序</param>
        /// <returns></returns>
        public List<T> GetPageList<Tkey>(int pageIndex, int pageSize, ref int rowCount, Expression<Func<T, bool>> whereLambda, Expression<Func<T, Tkey>> orderLambda, bool isAsc = true)
        {
            int count = 0;
            List<T> list = null;
            count = db.Set<T>().Where(whereLambda).Count();
            if (isAsc)
            {
                var iQueryList = db.Set<T>().Where(whereLambda).OrderBy(orderLambda)
                   .Skip((pageIndex - 1) * pageSize).Take(pageSize);

                list = iQueryList.ToList();
            }
            else
            {
                var iQueryList = db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda)
                 .Skip((pageIndex - 1) * pageSize).Take(pageSize);
                list = iQueryList.ToList();
            }
            rowCount = count;
            return list;
        }
        #endregion


        //2. SaveChange剝離出來，處理事務

        #region 01-批量處理SaveChange()
        /// <summary>
        /// 事務批量處理
        /// </summary>
        /// <returns></returns>
        public int SaveChange()
        {
            return db.SaveChanges();
        }
        #endregion

        #region 02-新增
        /// <summary>
        /// 新增
        /// </summary>
        /// <param name="model">需要新增的實體</param>
        public void AddNo(T model)
        {
            db.Set<T>().Add(model);
        }
        #endregion

        #region 03-刪除
        /// <summary>
        /// 刪除
        /// </summary>
        /// <param name="model">需要刪除的實體</param>
        public void DelNo(T model)
        {
            db.Entry(model).State = EntityState.Deleted;
        }
        #endregion

        #region 04-根據條件刪除
        /// <summary>
        /// 條件刪除
        /// </summary>
        /// <param name="delWhere">需要刪除的條件</param>
        public void DelByNo(Expression<Func<T, bool>> delWhere)
        {
            List<T> listDels = db.Set<T>().Where(delWhere).ToList();
            listDels.ForEach(d =>
            {
                db.Set<T>().Attach(d);
                db.Set<T>().Remove(d);
            });
        }
        #endregion

        #region 05-修改
        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="model">修改后的實體</param>
        public void ModifyNo(T model)
        {
            db.Entry(model).State = EntityState.Modified;
        }
        #endregion


        //3. EF調用sql語句

        #region 01-執行增加,刪除,修改操作(或調用存儲過程)
        /// <summary>
        /// 執行增加,刪除,修改操作(或調用存儲過程)
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="pars"></param>
        /// <returns></returns>
        public int ExecuteSql(string sql, params SqlParameter[] pars)
        {
            return db.Database.ExecuteSqlCommand(sql, pars);
        }

        #endregion

        #region 02-執行查詢操作
        /// <summary>
        /// 執行查詢操作
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sql"></param>
        /// <param name="pars"></param>
        /// <returns></returns>
        public List<T> ExecuteQuery<T>(string sql, params SqlParameter[] pars)
        {
            return db.Database.SqlQuery<T>(sql, pars).ToList();
        }
        #endregion



    }
}

 

三. 剖析核心

1. 如何實現同時操作多個相同類型的不同結構的數據庫。

　　首先【Ypf.Data】層中新建一個存放的實體的文件夾，如“EntityTest”，用來引入另外一個數據庫的存放實體和DbContext上下文，然后在【Ypf.Service】層中，雙Using，往BaseService類中傳入不同db上下文即可實現訪問不同的數據庫，如果要對多個數據庫開啟事務，手動開啟msdtc服務，然后使用Transactions包裹，進行事務一體操作。

　　詳細的使用步驟見：實戰測試。

2. 體會【Ypf.IService】層 和 引入IOC框架的作用

【PS：依賴倒置原則的核心就是：面向接口編程】

(1). 接口層的作用：

　　a. 便於開發人員分工開發，寫業務的單獨去寫業務，對接的單獨去對接，而且事先把接口協議定好，那么對接的人員就不需要等業務人員全部寫完代碼，就可以對接了，無非最后再測試而已。

　　b. 降低修改代碼造成的成本代價，使以接口為基礎搭建起來的框架更加穩健。

舉例1： 三層架構 數據庫訪問層、業務邏輯層、UI調用層。 （非此套框架的模式，后面考慮這么改進）

①. 數據庫訪問層中有一個 MySqlHelp類，提供鏈接MySQL數據增刪改查的方法。

②. 業務邏輯層有一個登錄業務 CheckLogin(MySqlHelp mysql,string userName,string pwd)。

③. UI調用層要調用CheckLogin方法，這時候實例化一個MySqlHelp對象，傳到CheckLogin方法中即可。

　　有一個天，要求支持oracle數據庫，所以數據庫訪問層中增加了一個oracleHelper類，UI調用層按照常規實例化了一個oracleHelper對象，傳到CheckLogin方法中，發現我的天！！！！CheckLogin竟然不支持oracleHelper對象，同時發現類似的所有業務層的方法都不支持oracleHelper類，這個時候悲劇就發生了，如果全部改業務層的方法，基本上完蛋。

所以根本的解決方案：依賴倒置原則，即面向接口編程。

①. 數據庫訪問層聲明一個接口IHelper,里面有增刪改查方法，MySqlHelp和oracleHelper都實現IHelper接口。

②. 業務邏輯層有一個登錄業務改為依賴接口IHelper， CheckLogin(IHelper iHelper,string userName,string pwd)。

③. UI調用層要調用CheckLogin方法，想連哪個數據，就實例化哪個 eg IHelper iHelper=new MySqlHelp(); 或者 IHelper iHelper=new oracleHelper()，此處考慮和IOC框架結合，連代碼都不用改，直接改配置文件就行了，就可以切換實例，然后調用CheckLogin即可。

舉例2： 類A，類B，類C。

類A中的方法需要傳入類B的實例，通常在類A中實例化一下類B，但如果想讓類A依賴類C，你會發現改動非常大，類A中的方法原先是類B的參數全部需要改。

所以解決方案：類B和類C都實現接口I，類A中方法的參數由原先的類B改為接口I，這樣類A想依賴誰，只需要 I i=new B() 或者 I i=new C(),所有的方法都不用改，也可以再升級一下，這里不直接實例化，利用IOC框架或者手寫反射，只需要改一下配置文件，就能控制 到底是 new B 還是 new C 。

 (2). 引入IOC框架的作用：

　　解決的問題1：現有的框架模式(Service層using引入EF上下文，傳入到BaseService類中)，如何實現快速切換數據庫？

　　a．首先在【Ypf.Data】層引入MySQL數據庫所需要的程序集，配置文件也改成連接MySQL的。(此處需要詳細測試)

　　b. 新建一個【Ypf.Service2】層，同樣實現對應業務，只不過是連接不同類型的數據庫(比如它連接的是MySql數據庫)，生成路徑也輸出到【Ypf.AdminWeb】層中，最后只需要改一下AutoFac讀取的配置文件“DllName”改為“Ypf.Services2”即可，就可以實現切換數據。

　　總結：該模式雖然能實現“相同業務、相同表”的不同類型的數據庫切換（比如SQLServer→MySQL），但是需要重新寫一個整層【Ypf.Service2】,雖然基本上是復制，但是有一定工作量的。但是另外通過手寫IOC也可以實現(反射+簡單工廠+配置文件)，看不到IOC框架的優勢所在。

　　IOC強大之處在於框架本身為我們封裝好了很多便於開發的方法，拿AutoFac來說吧，能靈活的控制創建對象的（每次請求都創建、單例、一個Http請求內單例）

四. 實戰測試

這里准備兩個數據庫，分別是：YpfFrame_DB 和 YpfFrameTest_DB

①：YpfFrame_DB中，用到了表：T_SysUser 和 T_SysLoginLog，表結構如下

②. YpfFrameTest_DB 表中用到了T_SchoolInfor，表結構如下

開始測試

1. 測試增刪改查，包括基本的事務一體。

在【Ypf.IService】層中新建ITestService接口，在【Ypf.Service】層中新建TestService類，實現ITestService接口， 定義TestBasicCRUD方法，進行測試，代碼如下。

        /// <summary>
        /// 1.測試基本的增刪改查,事務一體
        /// </summary>
        /// <returns></returns>
        public int TestBasicCRUD()
        {
            using (DbContext db = new MyDBContext1())
            {
                BaseService<T_SysUser> T_SysUserService = new BaseService<T_SysUser>(db);
                BaseService<T_SysLoginLog> T_SysLoginLogService = new BaseService<T_SysLoginLog>(db);
                //1.增加操作
                T_SysUser t_SysUser = new T_SysUser()
                {
                    id = Guid.NewGuid().ToString("N"),
                    userAccount = "123456",
                    userPwd = "XXX",
                    userRealName = "XXX",
                    appLoginNum = 1,
                    addTime = DateTime.Now
                };
                T_SysUserService.AddNo(t_SysUser);

                //2.修改操作
                T_SysLoginLog t_SysLoginLog = T_SysLoginLogService.Entities.Where(u => u.id == "1").FirstOrDefault();
                if (t_SysLoginLog != null)
                {
                    t_SysLoginLog.userId = "xxx";
                    t_SysLoginLog.userName = "xxx";
                    T_SysLoginLogService.ModifyNo(t_SysLoginLog);
                }
                //3.提交操作
                return db.SaveChanges();
            }
        }

2. 測試一個方法中查詢多個數據庫。

在ITestService接口中定義ConnectManyDB方法，並在TestService中實現該方法，代碼如下：

        /// <summary>
        /// 2. 同時連接多個數據庫進行
        /// </summary>
        /// <param name="userList"></param>
        /// <param name="schoolList"></param>
        public void ConnectManyDB(out List<T_SysUser> userList, out List<T_SchoolInfor> schoolList)
        {
            using (DbContext db = new MyDBContext1())
            using (DbContext db2 = new MyDBContext2())
            {
                BaseService<T_SysUser> T_SysUserService = new BaseService<T_SysUser>(db);
                BaseService<T_SchoolInfor> T_SchoolInforService = new BaseService<T_SchoolInfor>(db2);

                //執行數據庫查詢操作
                userList = T_SysUserService.GetListBy(u => true);
                schoolList = T_SchoolInforService.GetListBy(u => true);
            }
        }

　　分析：想連接幾個數據庫，就需要先在【Ypf.Data】層中新建對應數據庫的實體、實體配置文件、EF上下文，然后在【Ypf.Service】層對應的方法中實例化對應的 EF上下文，然后傳入到BaseService類中即可。

3. 測試一個方法中事務一體處理多個數據庫的crud操作。

 在ITestService接口中定義ManyDBTransaction方法，並在TestService中實現該方法，代碼如下：

        /// <summary>
        /// 3. 同時對多個數據庫進行事務一體的CRUD操作
        /// 注：需要手動開啟msdtc服務(net start msdtc)
        /// </summary>
        public void ManyDBTransaction()
        {
            using (TransactionScope trans = new TransactionScope())
            {
                try
                {
                    DbContext db = new MyDBContext1();
                    DbContext db2 = new MyDBContext2();

                    BaseService<T_SysUser> T_SysUserService = new BaseService<T_SysUser>(db);
                    BaseService<T_SchoolInfor> T_SchoolInforService = new BaseService<T_SchoolInfor>(db2);

                    //執行業務操作
                    T_SysUserService.DelBy(u => u.id == "1");
                    T_SchoolInforService.DelBy(u => u.id == "1");

                    //最終提交事務
                    trans.Complete();
                }
                catch (Exception ex)
                {
                    var msg = ex.Message;
                    //事務回滾
                    Transaction.Current.Rollback();
                    throw;
                }
            }
        }

　　分析：同時連接多個數據庫，並對多個數據庫進行事務性的crud操作，這個時候必須用 【TransactionScope事務】，前提要手動 【net start msdtc 】開啟對應服務，這樣整個事務通過“Complete”方法進行提交，通過Transaction.Current.Rollback()方法進行事務回滾，各自db的SaveChange不起作用，但還是需要SaveChange的。

4. 測試xxxSevice子類中也可以通過AutoFac進行IxxxService的模式進行屬性的注入。

 在【Ypf.IService】層中新建ITestService2接口，在【Ypf.Service】層中新建TestService2類，實現ITestService接口， 定義GetUserInfor方法，進行測試，代碼如下。

 public class TestService2 : ITestService2
    {
        /// <summary>
        /// 獲取用戶信息
        /// </summary>
        /// <returns></returns>
        public List<T_SysUser> GetUserInfor()
        {
            using (DbContext db=new MyDBContext1())
            {
                BaseService<T_SysUser> T_SysUserService = new BaseService<T_SysUser>(db);
                return T_SysUserService.GetListBy(u => true);
            }
        }
    }

在TestService中定義ITestService2屬性，如下：

在TestService中定義如下方法，內部用TestService2進行調用，可以調用成功，從而證明xxxSevice子類中也可以通過AutoFac進行IxxxService的模式進行屬性的注入。

5. 測試Log4net的分文件夾和不分文件的使用。

 先分享配置文件：

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <!-- 一. 添加log4net的自定義配置節點-->
  <configSections>
    <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler,log4net" />
  </configSections>
  <!--二. log4net的核心配置代碼-->
  <log4net>
    <!--1. 輸出途徑(一) 將日志以回滾文件的形式寫到文件中-->
    
    <!--模式一：全部存放到一個文件夾里-->
    <appender name="log0" type="log4net.Appender.RollingFileAppender">
      <!--1.1 文件夾的位置（也可以寫相對路徑）-->
      <param name="File"  value="D:\MyLog\" />
      <!--相對路徑-->
      <!--<param name="File"  value="Logs/" />-->
      <!--1.2 是否追加到文件-->
      <param name="AppendToFile" value="true" />
      <!--1.3 使用最小鎖定模型（minimal locking model），以允許多個進程可以寫入同一個文件 -->
      <lockingModel type="log4net.Appender.FileAppender+MinimalLock" />
      <!--1.4 配置Unicode編碼-->
      <Encoding value="UTF-8" />
      <!--1.5 是否只寫到一個文件里-->
      <param name="StaticLogFileName" value="false" />
      <!--1.6 配置按照何種方式產生多個日志文件 （Date：日期、Size：文件大小、Composite：日期和文件大小的混合方式）-->
      <param name="RollingStyle" value="Composite" />
      <!--1.7 介紹多種日志的的命名和存放在磁盤的形式-->
      <!--1.7.1 在根目錄下直接以日期命名txt文件 注意&quot;的位置,去空格 -->
      <param name="DatePattern" value="yyyy-MM-dd&quot;.log&quot;" />
      <!--1.7.2 在根目錄下按日期產生文件夾，文件名固定 test.log  -->
      <!--<param name="DatePattern" value="yyyy-MM-dd/&quot;test.log&quot;"  />-->
      <!--1.7.3 在根目錄下按日期產生文件夾，這是按日期產生文件夾，並在文件名前也加上日期  -->
      <!--<param name="DatePattern" value="yyyyMMdd/yyyyMMdd&quot;-test.log&quot;"  />-->
      <!--1.7.4 在根目錄下按日期產生文件夾，這再形成下一級固定的文件夾  -->
      <!--<param name="DatePattern" value="yyyyMMdd/&quot;OrderInfor/test.log&quot;"  />-->
      <!--1.8 配置每個日志的大小。【只在1.6 RollingStyle 選擇混合方式與文件大小方式下才起作用！！！】可用的單位:KB|MB|GB。不要使用小數,否則會一直寫入當前日志，
      超出大小后在所有文件名后自動增加正整數重新命名，數字最大的最早寫入。-->
      <param name="maximumFileSize" value="10MB" />
      <!--1.9 最多產生的日志文件個數，超過則保留最新的n個 將value的值設置-1，則不限文件個數 【只在1.6 RollingStyle 選擇混合方式與文件大小方式下才起作用！！！】
        與1.8中maximumFileSize文件大小是配合使用的-->
      <param name="MaxSizeRollBackups" value="5" />
      <!--1.10 配置文件文件的布局格式，使用PatternLayout，自定義布局-->
      <layout type="log4net.Layout.PatternLayout">
        <conversionPattern value="記錄時間：%date %n線程ID:[%thread] %n日志級別：%-5level %n出錯類：%logger property: [%property{NDC}] - %n錯誤描述：%message%newline %n%newline"/>
      </layout>
    </appender>

    <!--模式二：分文件夾存放-->
    <!--文件夾1-->
    <appender name="log1" type="log4net.Appender.RollingFileAppender">
      <param name="File"  value="D:\MyLog\OneLog\" />
      <param name="AppendToFile" value="true" />
      <lockingModel type="log4net.Appender.FileAppender+MinimalLock" />
      <Encoding value="UTF-8" />
      <param name="StaticLogFileName" value="false" />
      <param name="RollingStyle" value="Composite" />
      <param name="DatePattern" value="yyyy-MM-dd&quot;.log&quot;" />
      <param name="maximumFileSize" value="10MB" />
      <param name="MaxSizeRollBackups" value="5" />
      <layout type="log4net.Layout.PatternLayout">
        <conversionPattern value="%message%newline" />
      </layout>
      <!--下面是利用過濾器進行分文件夾存放,兩種過濾器進行配合-->
      <!--與Logger名稱(OneLog)匹配，才記錄,-->
      <filter type="log4net.Filter.LoggerMatchFilter">
        <loggerToMatch value="OneLog" />
      </filter>
      <!--阻止所有的日志事件被記錄-->
      <filter type="log4net.Filter.DenyAllFilter" />
    </appender>
    <!--文件夾2-->
    <appender name="log2" type="log4net.Appender.RollingFileAppender">
      <param name="File"  value="D:\MyLog\TwoLog\" />
      <param name="AppendToFile" value="true" />
      <lockingModel type="log4net.Appender.FileAppender+MinimalLock" />
      <Encoding value="UTF-8" />
      <param name="StaticLogFileName" value="false" />
      <param name="RollingStyle" value="Composite" />
      <param name="DatePattern" value="yyyy-MM-dd&quot;.log&quot;" />
      <param name="maximumFileSize" value="10MB" />
      <param name="MaxSizeRollBackups" value="5" />
      <layout type="log4net.Layout.PatternLayout">
        <conversionPattern value="%message%newline" />
      </layout>
      <!--下面是利用過濾器進行分文件夾存放,兩種過濾器進行配合-->
      <!--與Logger名稱(TwoLog)匹配，才記錄,-->
      <filter type="log4net.Filter.LoggerMatchFilter">
        <loggerToMatch value="TwoLog" />
      </filter>
      <!--阻止所有的日志事件被記錄-->
      <filter type="log4net.Filter.DenyAllFilter" />
    </appender>


    <!--2. 輸出途徑(二) 記錄日志到數據庫-->
    <appender name="AdoNetAppender" type="log4net.Appender.AdoNetAppender">
      <!--2.1 設置緩沖區大小，只有日志記錄超設定值才會一塊寫入到數據庫-->
      <param name="BufferSize" value="1" />
      <!--2.2 引用-->
      <connectionType value="System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
      <!--2.3 數據庫連接字符串-->
      <connectionString value="data source=localhost;initial catalog=LogDB;integrated security=false;persist security info=True;User ID=sa;Password=123456" />
      <!--2.4 SQL語句插入到指定表-->
      <commandText value="INSERT INTO LogInfor ([threadId],[log_level],[log_name],[log_msg],[log_exception],[log_time]) VALUES (@threadId, @log_level, @log_name, @log_msg, @log_exception,@log_time)" />
      <!--2.5 數據庫字段匹配-->
      <!-- 線程號-->
      <parameter>
        <parameterName value="@threadId" />
        <dbType value="String" />
        <size value="100" />
        <layout type="log4net.Layout.PatternLayout">
          <conversionPattern value="%thread" />
        </layout>
      </parameter>
      <!--日志級別-->
      <parameter>
        <parameterName value="@log_level" />
        <dbType value="String" />
        <size value="100" />
        <layout type="log4net.Layout.PatternLayout">
          <conversionPattern value="%level" />
        </layout>
      </parameter>
      <!--日志記錄類名稱-->
      <parameter>
        <parameterName value="@log_name" />
        <dbType value="String" />
        <size value="100" />
        <layout type="log4net.Layout.PatternLayout">
          <conversionPattern value="%logger" />
        </layout>
      </parameter>
      <!--日志信息-->
      <parameter>
        <parameterName value="@log_msg" />
        <dbType value="String" />
        <size value="5000" />
        <layout type="log4net.Layout.PatternLayout">
          <conversionPattern value="%message" />
        </layout>
      </parameter>
      <!--異常信息  指的是如Infor 方法的第二個參數的值-->
      <parameter>
        <parameterName value="@log_exception" />
        <dbType value="String" />
        <size value="2000" />
        <layout type="log4net.Layout.ExceptionLayout" />
      </parameter>
      <!-- 日志記錄時間-->
      <parameter>
        <parameterName value="@log_time" />
        <dbType value="DateTime" />
        <layout type="log4net.Layout.RawTimeStampLayout" />
      </parameter>
    </appender>


    <!--(二). 配置日志的的輸出級別和加載日志的輸出途徑-->
    <root>
      <!--1. level中的value值表示該值及其以上的日志級別才會輸出-->
      <!--OFF > FATAL(致命錯誤) > ERROR（一般錯誤） > WARN（警告） > INFO（一般信息） > DEBUG（調試信息）  > ALL  -->
      <!--OFF表示所有信息都不寫入，ALL表示所有信息都寫入-->
      <level value="ALL"></level>
      <!--2. append-ref標簽表示要加載前面的日志輸出途徑代碼  通過ref和appender標簽的中name屬性相關聯-->
      
      <appender-ref ref="log0"></appender-ref>
      <appender-ref ref="log1"></appender-ref>
      <appender-ref ref="log2"></appender-ref>

      <!--<appender-ref ref="AdoNetAppender"></appender-ref>-->
    </root>
  </log4net>

</configuration>

分享對應的封裝類：

using log4net;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace Ypf.Utils.Log
{
    public class LogUtils
    {
        //聲明文件夾名稱(這里分兩個文件夾)
        static string log1Name = "OneLog";
        static string log2Name = "TwoLog";

        //可以聲明多個日志對象
        //模式一：不分文件夾(所有的log對存放在這一個文件夾下)
        public static ILog log = LogManager.GetLogger(typeof(LogUtils));

        //模式二：分文件夾
        //如果是要分文件夾存儲，這里的名稱需要和配置文件中loggerToMatch節點中的value相配合
        //1. OneLog文件夾
        public static ILog log1 = LogManager.GetLogger(log1Name);
        //2. TwoLog文件夾
        public static ILog log2 = LogManager.GetLogger(log2Name);

        #region 01-初始化Log4net的配置
        /// <summary>
        /// 初始化Log4net的配置
        /// xml文件一定要改為嵌入的資源
        /// </summary>
        public static void InitLog4Net()
        {
            Assembly assembly = Assembly.GetExecutingAssembly();
            var xml = assembly.GetManifestResourceStream("Ypf.Utils.Log.log4net.xml");
            log4net.Config.XmlConfigurator.Configure(xml);
        }
        #endregion

        /************************* 五種不同日志級別 *******************************/
        //FATAL(致命錯誤) > ERROR（一般錯誤） > WARN（警告） > INFO（一般信息） > DEBUG（調試信息）

        #region 00-將調試的信息輸出，可以定位到具體的位置（解決高層封裝帶來的問題）
        /// <summary>
        /// 將調試的信息輸出，可以定位到具體的位置（解決高層封裝帶來的問題）
        /// </summary>
        /// <returns></returns>
        private static string getDebugInfo()
        {
            StackTrace trace = new StackTrace(true);
            return trace.ToString();
        }
        #endregion

        #region 01-DEBUG（調試信息）
        /// <summary>
        /// DEBUG（調試信息）
        /// </summary>
        /// <param name="msg">日志信息</param>
        ///  <param name="logName">文件夾名稱</param>
        public static void Debug(string msg, string logName = "")
        {
            if (logName == "")
            {
                log.Debug(getDebugInfo() + msg);
            }
            else if (logName == log1Name)
            {
                log1.Debug(msg);
            }
            else if (logName == log2Name)
            {
                log2.Debug(msg);
            }
        }
        /// <summary>
        /// Debug
        /// </summary>
        /// <param name="msg">日志信息</param>
        /// <param name="exception">錯誤信息</param>
        public static void Debug(string msg, Exception exception)
        {
            log.Debug(getDebugInfo() + msg, exception);
        }

        #endregion

        #region 02-INFO（一般信息）
        /// <summary>
        /// INFO（一般信息）
        /// </summary>
        /// <param name="msg">日志信息</param>
        /// <param name="logName">文件夾名稱</param>
        public static void Info(string msg, string logName = "")
        {
            if (logName == "")
            {
                log.Info(getDebugInfo() + msg);
            }
            else if (logName == log1Name)
            {
                log1.Info(msg);
            }
            else if (logName == log2Name)
            {
                log2.Info(msg);
            }
        }
        /// <summary>
        /// Info
        /// </summary>
        /// <param name="msg">日志信息</param>
        /// <param name="exception">錯誤信息</param>
        public static void Info(string msg, Exception exception)
        {
            log.Info(getDebugInfo() + msg, exception);
        }
        #endregion

        #region 03-WARN（警告）
        /// <summary>
        ///WARN（警告）
        /// </summary>
        /// <param name="msg">日志信息</param>
        /// <param name="logName">文件夾名稱</param>
        public static void Warn(string msg, string logName = "")
        {
            if (logName == "")
            {
                log.Warn(getDebugInfo() + msg);
            }
            else if (logName == log1Name)
            {
                log1.Warn(msg);
            }
            else if (logName == log2Name)
            {
                log2.Warn(msg);
            }
        }
        /// <summary>
        /// Warn
        /// </summary>
        /// <param name="msg">日志信息</param>
        /// <param name="exception">錯誤信息</param>
        public static void Warn(string msg, Exception exception)
        {
            log.Warn(getDebugInfo() + msg, exception);
        }
        #endregion

        #region 04-ERROR（一般錯誤）
        /// <summary>
        /// ERROR（一般錯誤）
        /// </summary>
        /// <param name="msg">日志信息</param>
        /// <param name="logName">文件夾名稱</param>
        public static void Error(string msg, string logName = "")
        {
            if (logName == "")
            {
                log.Error(getDebugInfo() + msg);
            }
            else if (logName == log1Name)
            {
                log1.Error(msg);
            }
            else if (logName == log2Name)
            {
                log2.Error(msg);
            }
        }
        /// <summary>
        /// Error
        /// </summary>
        /// <param name="msg">日志信息</param>
        /// <param name="exception">錯誤信息</param>
        public static void Error(string msg, Exception exception)
        {
            log.Error(getDebugInfo() + msg, exception);
        }
        #endregion

        #region 05-FATAL(致命錯誤)
        /// <summary>
        /// FATAL(致命錯誤)
        /// </summary>
        /// <param name="msg">日志信息</param>
        /// <param name="logName">文件夾名稱</param>
        public static void Fatal(string msg, string logName = "")
        {
            if (logName == "")
            {
                log.Fatal(getDebugInfo() + msg);
            }
            else if (logName == log1Name)
            {
                log1.Fatal(msg);
            }
            else if (logName == log2Name)
            {
                log2.Fatal(msg);
            }
        }
        /// <summary>
        /// Fatal
        /// </summary>
        /// <param name="msg">日志信息</param>
        /// <param name="exception">錯誤信息</param>
        public static void Fatal(string msg, Exception exception)
        {
            log.Fatal(getDebugInfo() + msg, exception);
        }

        #endregion



    }
}

代碼測試：

 

 

 

 

 

!

• 作       者 : Yaopengfei(姚鵬飛)
• 博客地址 : http://www.cnblogs.com/yaopengfei/
• 聲     明1 : 本人才疏學淺，用郭德綱的話說“我是一個小學生”，如有錯誤，歡迎討論，請勿謾罵^_^。
• 聲     明2 : 原創博客請在轉載時保留原文鏈接或在文章開頭加上本人博客地址，否則保留追究法律責任的權利。