更新

1、在使用的時候，特別是 update 的時候，如果不知道哪裡有問題，記得檢視資料庫 和 實體類 的欄位，是否大小寫一致，比如 name 和 Name

要學會使用資料庫監控分析器

程式碼已上傳Github+Gitee，文末有地址

　　書接上文：《從壹開始前後端分離【 .NET Core2.0 Api + Vue 2.0 + AOP + 分散式】框架之六 || API專案整體搭建 6.1 倉儲》，我們簡單的對整體專案進行搭建，用到了專案中常見的倉儲模式+面向介面程式設計，核心的一共是六層，當然你也可以根據自己的需求進行擴充套件，比如我在其他的專案中會用到Common層，當然我們這個專案接下來也會有，或者我還會新增Task層，主要是作為定時專案使用，我之前用的是Task Schedule，基本能滿足需求。

緣起

　　在上一節中，我們最後提出了兩個問題，不知道大家是否還記得，這裡還重新說明一下：

1、如果每個倉儲檔案都需要把一個一個寫出來，至少是四遍，會不會太麻煩，而且無法複用，失去了面向介面程式設計的意義；

2、每次介面呼叫的時候，需要引入很多名稱空間，比如Blog.Core.IServices;Blog.Core.Services;Blog.Core.Repository等等

　　對就是這兩個問題，相信聰明的大家也都能看懂，或許還能給出相應的解決辦法，比如泛型倉儲，比如依賴注入，當然，如果你有更好的辦法，歡迎留言，我會把你的想法寫下了，讓大家一起進步。這裡先簡單說下問題1中為什麼要四遍，倉儲模式的基本就是如何將持久化動作和物件獲取方式以及領域模型Domain Model結合起來，進一步：如何更加統一我們的語言(Ubiquitous Language)，一個整合持久化技術的好辦法是倉儲Repositories。明白了這個問題，你就知道，定義倉儲，首先需要定義IRepository介面（1），然後再Repository中實現（2），接著在IService層中引用這些介面，同時也可以自定義擴充套件業務邏輯介面（3），最後在Service層中去實現（4），這就是四層。

　　問題明白了，我們就要動手做起來，思考了下，如果幹巴巴直接寫泛型倉儲，會比較乾澀，所以我考慮今天先把資料持久化做出來，一個輕量級的ORM框架——SqlSugar。

零、今天完成的藍色部分

一、在Blog.Core.IRepository 層中新增CURD介面

　　還記得昨天我們實現的Sum介面麼，今天在倉儲介面 IAdvertisementRepository.cs 新增CURD四個介面，首先需要將Model層新增引用，這個應該都會，以後不再細說，如下：

namespace Blog.Core.IRepository
{
    public interface
 
 IAdvertisementRepository
    {
        int Sum(int i, int j);

        int Add(Advertisement model);
        bool Delete(Advertisement model);
        bool Update(Advertisement model);
        List<Advertisement> Query(Expression<Func<Advertisement, bool>> whereExpression);

    }
}

編譯專案，提示錯誤，別慌！很正常，因為我們現在只是添加了介面，還沒有實現介面。

二、在Blog.Core.Repository 層中實現Blog.Core.IRepository 所定義的CURD介面

當然，我們還是在AdvertisementRepository.cs檔案中操作，這裡我有一個小技巧，不知道大家是否用到過，因為我比較喜歡寫介面，這樣不僅可以不暴露核心程式碼，而且也可以讓使用者呼叫的時候，直接看到簡單的介面方法列表，而不去管具體的實現過程，這樣的設計思路還是比較提倡的，如下圖：

 你先看到了繼承的介面有紅色的波浪線，證明有錯誤，然後右鍵該介面，點選 Quick Actions and Refactorings...，也就是 快速操作和重構 ，你就會看到VS的智慧提示，雙擊左側的Implement interface，也就是實現介面，如下圖：

Visual Studio真是宇宙第一IDE，沒的說 [手動點贊]，然後就建立成功了，你就可以去掉throw處理，自定義程式碼編寫了，當然，如果你不習慣或者害怕出錯，那就手動寫吧，也是很快的。

namespace Blog.Core.Repository
{
    public class AdvertisementRepository : IAdvertisementRepository
    {
        public int Add(Advertisement model)
        {
            throw new NotImplementedException();
        }

        public bool Delete(Advertisement model)
        {
            throw new NotImplementedException();
        }

        public List<Advertisement> Query(Expression<Func<Advertisement, bool>> whereExpression)
        {
            throw new NotImplementedException();
        }

        public int Sum(int i, int j)
        {
            return i + j;
        }

        public bool Update(Advertisement model)
        {
            throw new NotImplementedException();
        }
    }
}

這個時候我們重新編譯專案，嗯！意料之中，沒有錯誤，但是具體的資料持久化如何寫呢？

三、引用輕量級的ORM框架——SqlSugar

首先什麼是ORM， 物件關係對映（Object Relational Mapping，簡稱ORM）模式是一種為了解決面向物件與關係資料庫存在的互不匹配的現象的技術。簡單的說，ORM是通過使用描述物件和資料庫之間對映的元資料，將程式中的物件自動持久化到關係資料庫中。這些概念我就不細說了，自從開發這些年，一直在討論的問題就是用ADO.NET還是用ORM框架，還記得前幾年面試的時候，有一個經理問：

如果一個專案，你是用三層架構ADO，還是用ORM中的EF？

 大家可以自由留言，我表示各有千秋吧，一個產品的存在即有合理性，我平時專案中也有ADO，也有EF，不過本系列教程中基於面向物件思想，面向介面思想，當然還有以後的面向切面程式設計（AOP），還是使用ORM框架，不過是一個輕量級的，EF比較重，我在我其他的專案中用到了.Net MVC 6.0 + EF Code First 的專案，如果大家需要，我也開源出去，方法Github上，請文末留言吧~

　　關於ORM有一些常見的框架，如SqlSugar、Dapper、EF、NHeberneit等等，這些我都或多或少的瞭解過，使用過，至於你要問我為啥用SqlSugar，只要一個原因，作者是中國人，嗯！沒錯，這裡給他打個廣告，本系列中的前端框架Vue，也是我們中國的，Vue作者尤雨溪，這裡也祝福大家都能有自己的成績，為國人爭光！

扯遠了，開始動手引入框架：

開始，我們需要先向 Repository 層中引入SqlSugar，如下：

1）直接在類庫中通過Nuget引入 sqlSugarCore，一定是Core版本的！，我個人採用這個辦法，因為專案已經比較成型

2）Github下載原始碼，然後專案引用(點選跳轉到Github下載頁)

注意：為什麼要單獨在倉儲層來引入ORM持久化介面，是因為，降低耦合，如果以後想要換成EF或者Deper，只需要修改Repository就行了，其他都不需要修改，達到很好的解耦效果。

編譯一切正常，繼續

首先呢，你需要了解下sqlsugar的具體使用方法，http://www.codeisbug.com/Doc/8，你先自己在控制檯可以簡單試一試，這裡就不細說了，如果大家有需要，我可以單開一個文章，重點講解SqlSugar這一塊。

1、在Blog.Core.Repository新建一個sugar資料夾，然後新增兩個配置檔案，BaseDBConfig.cs 和  DbContext.cs ，這個你如果看了上邊的文件，那這兩個應該就不是問題。

namespace Blog.Core.Repository
{
    public class BaseDBConfig
    {
        public static string ConnectionString = File.ReadAllText(@"D:\my-file\dbCountPsw1.txt").Trim();

        //正常格式是

        //public static string ConnectionString = "server=.;uid=sa;pwd=sa;database=BlogDB"; 

        //原諒我用配置檔案的形式，因為我直接呼叫的是我的伺服器賬號和密碼，安全起見

    }
}

 //DbContext.cs，一個詳細的上下文類，看不懂沒關係，以後我會詳細講解

namespace Blog.Core.Repository
{
    public class DbContext
    {

        private static string _connectionString;
        private static DbType _dbType;
        private SqlSugarClient _db;

        /// <summary>
        /// 連線字串 
        /// Blog.Core
        /// </summary>
        public static string ConnectionString
        {
            get { return _connectionString; }
            set { _connectionString = value; }
        }
        /// <summary>
        /// 資料庫型別 
        /// Blog.Core 
        /// </summary>
        public static DbType DbType
        {
            get { return _dbType; }
            set { _dbType = value; }
        }
        /// <summary>
        /// 資料連線物件 
        /// Blog.Core 
        /// </summary>
        public SqlSugarClient Db
        {
            get { return _db; }
            private set { _db = value; }
        }

        /// <summary>
        /// 資料庫上下文例項（自動關閉連線）
        /// Blog.Core 
        /// </summary>
        public static DbContext Context
        {
            get
            {
                return new DbContext();
            }

        }


        /// <summary>
        /// 功能描述:建構函式
        /// 作　　者:Blog.Core
        /// </summary>
        private DbContext()
        {
            if (string.IsNullOrEmpty(_connectionString))
                throw new ArgumentNullException("資料庫連線字串為空");
            _db = new SqlSugarClient(new ConnectionConfig()
            {
                ConnectionString = _connectionString,
                DbType = _dbType,
                IsAutoCloseConnection = true,
                IsShardSameThread = true,
                ConfigureExternalServices = new ConfigureExternalServices()
                {
                    //DataInfoCacheService = new HttpRuntimeCache()
                },
                MoreSettings = new ConnMoreSettings()
                {
                    //IsWithNoLockQuery = true,
                    IsAutoRemoveDataCache = true
                }
            });
        }

        /// <summary>
        /// 功能描述:建構函式
        /// 作　　者:Blog.Core
        /// </summary>
        /// <param name="blnIsAutoCloseConnection">是否自動關閉連線</param>
        private DbContext(bool blnIsAutoCloseConnection)
        {
            if (string.IsNullOrEmpty(_connectionString))
                throw new ArgumentNullException("資料庫連線字串為空");
            _db = new SqlSugarClient(new ConnectionConfig()
            {
                ConnectionString = _connectionString,
                DbType = _dbType,
                IsAutoCloseConnection = blnIsAutoCloseConnection,
                IsShardSameThread = true,
                ConfigureExternalServices = new ConfigureExternalServices()
                {
                    //DataInfoCacheService = new HttpRuntimeCache()
                },
                MoreSettings = new ConnMoreSettings()
                {
                    //IsWithNoLockQuery = true,
                    IsAutoRemoveDataCache = true
                }
            });
        }

        #region 例項方法
        /// <summary>
        /// 功能描述:獲取資料庫處理物件
        /// 作　　者:Blog.Core
        /// </summary>
        /// <returns>返回值</returns>
        public SimpleClient<T> GetEntityDB<T>() where T : class, new()
        {
            return new SimpleClient<T>(_db);
        }
        /// <summary>
        /// 功能描述:獲取資料庫處理物件
        /// 作　　者:Blog.Core
        /// </summary>
        /// <param name="db">db</param>
        /// <returns>返回值</returns>
        public SimpleClient<T> GetEntityDB<T>(SqlSugarClient db) where T : class, new()
        {
            return new SimpleClient<T>(db);
        }

        #region 根據資料庫表生產實體類
        /// <summary>
        /// 功能描述:根據資料庫表生產實體類
        /// 作　　者:Blog.Core
        /// </summary>       
        /// <param name="strPath">實體類存放路徑</param>
        public void CreateClassFileByDBTalbe(string strPath)
        {
            CreateClassFileByDBTalbe(strPath, "Km.PosZC");
        }
        /// <summary>
        /// 功能描述:根據資料庫表生產實體類
        /// 作　　者:Blog.Core
        /// </summary>
        /// <param name="strPath">實體類存放路徑</param>
        /// <param name="strNameSpace">名稱空間</param>
        public void CreateClassFileByDBTalbe(string strPath, string strNameSpace)
        {
            CreateClassFileByDBTalbe(strPath, strNameSpace, null);
        }

        /// <summary>
        /// 功能描述:根據資料庫表生產實體類
        /// 作　　者:Blog.Core
        /// </summary>
        /// <param name="strPath">實體類存放路徑</param>
        /// <param name="strNameSpace">名稱空間</param>
        /// <param name="lstTableNames">生產指定的表</param>
        public void CreateClassFileByDBTalbe(
            string strPath,
            string strNameSpace,
            string[] lstTableNames)
        {
            CreateClassFileByDBTalbe(strPath, strNameSpace, lstTableNames, string.Empty);
        }

        /// <summary>
        /// 功能描述:根據資料庫表生產實體類
        /// 作　　者:Blog.Core
        /// </summary>
        /// <param name="strPath">實體類存放路徑</param>
        /// <param name="strNameSpace">名稱空間</param>
        /// <param name="lstTableNames">生產指定的表</param>
        /// <param name="strInterface">實現介面</param>
        public void CreateClassFileByDBTalbe(
          string strPath,
          string strNameSpace,
          string[] lstTableNames,
          string strInterface,
          bool blnSerializable = false)
        {
            if (lstTableNames != null && lstTableNames.Length > 0)
            {
                _db.DbFirst.Where(lstTableNames).IsCreateDefaultValue().IsCreateAttribute()
                    .SettingClassTemplate(p => p = @"
{using}

namespace {Namespace}
{
    {ClassDescription}{SugarTable}" + (blnSerializable ? "[Serializable]" : "") + @"
    public partial class {ClassName}" + (string.IsNullOrEmpty(strInterface) ? "" : (" : " + strInterface)) + @"
    {
        public {ClassName}()
        {
{Constructor}
        }
{PropertyName}
    }
}
")
                    .SettingPropertyTemplate(p => p = @"
            {SugarColumn}
            public {PropertyType} {PropertyName}
            {
                get
                {
                    return _{PropertyName};
                }
                set
                {
                    if(_{PropertyName}!=value)
                    {
                        base.SetValueCall(" + "\"{PropertyName}\",_{PropertyName}" + @");
                    }
                    _{PropertyName}=value;
                }
            }")
                    .SettingPropertyDescriptionTemplate(p => p = "          private {PropertyType} _{PropertyName};\r\n" + p)
                    .SettingConstructorTemplate(p => p = "              this._{PropertyName} ={DefaultValue};")
                    .CreateClassFile(strPath, strNameSpace);
            }
            else
            {
                _db.DbFirst.IsCreateAttribute().IsCreateDefaultValue()
                    .SettingClassTemplate(p => p = @"
{using}

namespace {Namespace}
{
    {ClassDescription}{SugarTable}" + (blnSerializable ? "[Serializable]" : "") + @"
    public partial class {ClassName}" + (string.IsNullOrEmpty(strInterface) ? "" : (" : " + strInterface)) + @"
    {
        public {ClassName}()
        {
{Constructor}
        }
{PropertyName}
    }
}
")
                    .SettingPropertyTemplate(p => p = @"
            {SugarColumn}
            public {PropertyType} {PropertyName}
            {
                get
                {
                    return _{PropertyName};
                }
                set
                {
                    if(_{PropertyName}!=value)
                    {
                        base.SetValueCall(" + "\"{PropertyName}\",_{PropertyName}" + @");
                    }
                    _{PropertyName}=value;
                }
            }")
                    .SettingPropertyDescriptionTemplate(p => p = "          private {PropertyType} _{PropertyName};\r\n" + p)
                    .SettingConstructorTemplate(p => p = "              this._{PropertyName} ={DefaultValue};")
                    .CreateClassFile(strPath, strNameSpace);
            }
        }
        #endregion

        #region 根據實體類生成資料庫表
        /// <summary>
        /// 功能描述:根據實體類生成資料庫表
        /// 作　　者:Blog.Core
        /// </summary>
        /// <param name="blnBackupTable">是否備份表</param>
        /// <param name="lstEntitys">指定的實體</param>
        public void CreateTableByEntity<T>(bool blnBackupTable, params T[] lstEntitys) where T : class, new()
        {
            Type[] lstTypes = null;
            if (lstEntitys != null)
            {
                lstTypes = new Type[lstEntitys.Length];
                for (int i = 0; i < lstEntitys.Length; i++)
                {
                    T t = lstEntitys[i];
                    lstTypes[i] = typeof(T);
                }
            }
            CreateTableByEntity(blnBackupTable, lstTypes);
        }

        /// <summary>
        /// 功能描述:根據實體類生成資料庫表
        /// 作　　者:Blog.Core
        /// </summary>
        /// <param name="blnBackupTable">是否備份表</param>
        /// <param name="lstEntitys">指定的實體</param>
        public void CreateTableByEntity(bool blnBackupTable, params Type[] lstEntitys)
        {
            if (blnBackupTable)
            {
                _db.CodeFirst.BackupTable().InitTables(lstEntitys); //change entity backupTable            
            }
            else
            {
                _db.CodeFirst.InitTables(lstEntitys);
            }
        }
        #endregion

        #endregion

        #region 靜態方法

        /// <summary>
        /// 功能描述:獲得一個DbContext
        /// 作　　者:Blog.Core
        /// </summary>
        /// <param name="blnIsAutoCloseConnection">是否自動關閉連線（如果為false，則使用接受時需要手動關閉Db）</param>
        /// <returns>返回值</returns>
        public static DbContext GetDbContext(bool blnIsAutoCloseConnection = true)
        {
            return new DbContext(blnIsAutoCloseConnection);
        }

        /// <summary>
        /// 功能描述:設定初始化引數
        /// 作　　者:Blog.Core
        /// </summary>
        /// <param name="strConnectionString">連線字串</param>
        /// <param name="enmDbType">資料庫型別</param>
        public static void Init(string strConnectionString, DbType enmDbType = SqlSugar.DbType.SqlServer)
        {
            _connectionString = strConnectionString;
            _dbType = enmDbType;
        }

        /// <summary>
        /// 功能描述:建立一個連結配置
        /// 作　　者:Blog.Core
        /// </summary>
        /// <param name="blnIsAutoCloseConnection">是否自動關閉連線</param>
        /// <param name="blnIsShardSameThread">是否誇類事務</param>
        /// <returns>ConnectionConfig</returns>
        public static ConnectionConfig GetConnectionConfig(bool blnIsAutoCloseConnection = true, bool blnIsShardSameThread = false)
        {
            ConnectionConfig config = new ConnectionConfig()
            {
                ConnectionString = _connectionString,
                DbType = _dbType,
                IsAutoCloseConnection = blnIsAutoCloseConnection,
                ConfigureExternalServices = new ConfigureExternalServices()
                {
                    //DataInfoCacheService = new HttpRuntimeCache()
                },
                IsShardSameThread = blnIsShardSameThread
            };
            return config;
        }

        /// <summary>
        /// 功能描述:獲取一個自定義的DB
        /// 作　　者:Blog.Core
        /// </summary>
        /// <param name="config">config</param>
        /// <returns>返回值</returns>
        public static SqlSugarClient GetCustomDB(ConnectionConfig config)
        {
            return new SqlSugarClient(config);
        }
        /// <summary>
        /// 功能描述:獲取一個自定義的資料庫處理物件
        /// 作　　者:Blog.Core
        /// </summary>
        /// <param name="sugarClient">sugarClient</param>
        /// <returns>返回值</returns>
        public static SimpleClient<T> GetCustomEntityDB<T>(SqlSugarClient sugarClient) where T : class, new()
        {
            return new SimpleClient<T>(sugarClient);
        }
        /// <summary>
        /// 功能描述:獲取一個自定義的資料庫處理物件
        /// 作　　者:Blog.Core
        /// </summary>
        /// <param name="config">config</param>
        /// <returns>返回值</returns>
        public static SimpleClient<T> GetCustomEntityDB<T>(ConnectionConfig config) where T : class, new()
        {
            SqlSugarClient sugarClient = GetCustomDB(config);
            return GetCustomEntityDB<T>(sugarClient);
        }
        #endregion
    }
}

2、然後在剛剛我們實現那四個方法的AdvertisementRepository.cs中，重寫建構函式，編輯統一Sqlsugar例項方法，用到了私有屬性，為以後的單列模式做準備。

 　　　　private DbContext context;
        private SqlSugarClient db;
        private SimpleClient<Advertisement> entityDB;

        internal SqlSugarClient Db
        {
            get { return db; }
            private set { db = value; }
        }
        public DbContext Context
        {
            get { return context; }
            set { context = value; }
        }
        public AdvertisementRepository() {
            DbContext.Init(BaseDBConfig.ConnectionString);
            context = DbContext.GetDbContext();
　　　　　　　db = context.Db;
            entityDB = context.GetEntityDB<Advertisement>(db);
        }

3、正式開始寫持久化邏輯程式碼（注意：我在Model層中，添加了全域性的資料型別轉換方法，UtilConvert，這樣就不用每次都Convert，而且也解決了為空轉換異常的bug）

    public static class UtilConvert
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="thisValue"></param>
        /// <returns></returns>
        public static int ObjToInt(this object thisValue)
        {
            int reval = 0;
            if (thisValue == null) return 0;
            if (thisValue != null && thisValue != DBNull.Value && int.TryParse(thisValue.ToString(), out reval))
            {
                return reval;
            }
            return reval;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="thisValue"></param>
        /// <param name="errorValue"></param>
        /// <returns></returns>
        public static int ObjToInt(this object thisValue, int errorValue)
        {
            int reval = 0;
            if (thisValue != null && thisValue != DBNull.Value && int.TryParse(thisValue.ToString(), out reval))
            {
                return reval;
            }
            return errorValue;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="thisValue"></param>
        /// <returns></returns>
        public static double ObjToMoney(this object thisValue)
        {
            double reval = 0;
            if (thisValue != null && thisValue != DBNull.Value && double.TryParse(thisValue.ToString(), out reval))
            {
                return reval;
            }
            return 0;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="thisValue"></param>
        /// <param name="errorValue"></param>
        /// <returns></returns>
        public static double ObjToMoney(this object thisValue, double errorValue)
        {
            double reval = 0;
            if (thisValue != null && thisValue != DBNull.Value && double.TryParse(thisValue.ToString(), out reval))
            {
                return reval;
            }
            return errorValue;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="thisValue"></param>
        /// <returns></returns>
        public static string ObjToString(this object thisValue)
        {
            if (thisValue != null) return thisValue.ToString().Trim();
            return "";
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="thisValue"></param>
        /// <param name="errorValue"></param>
        /// <returns></returns>
        public static string ObjToString(this object thisValue, string errorValue)
        {
            if (thisValue != null) return thisValue.ToString().Trim();
            return errorValue;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="thisValue"></param>
        /// <returns></returns>
        public static Decimal ObjToDecimal(this object thisValue)
        {
            Decimal reva