.netCore+Vue 搭建的簡捷開發框架 （2）--倉儲層實現和EFCore 的使用

書接上文，繼續搭建我們基於.netCore 的開發框架。首先是我們的項目分層結構。

 

這個分層結構，是參考張老師的分層結構，但是實際項目中，我沒有去實現倉儲模型。因為我使用的是EFCore ,最近也一直在想，EFCore 在我們的架構體系中到底扮演着什么樣的角色？？

當然，實現倉儲層，也有他的好處，如果真的以后要更換ORM框架的時候，不用去更改服務層邏輯，不用直接在倉儲里面做更改就可以了。但是對於小項目，可能運行個十年都不會換數據庫，不會換ORM的項目，倉儲層的意義在哪？

希望對此有自己想法的朋友一起討論。在本系列里，我將保留倉儲層。

上面的分層結構，很容易就搭建好了，但是基於.NetCore 的項目，可能最主要的一點就是如何利用好DI，怎么來實現依賴注入。

依照上圖中的依賴關系，我們以此構建自己相應層級中的內容。

分別在IRepository和Repository項目下，新建Base文件夾，並分別建立IBaseRepository和BaseRepository

具體代碼如下：

IBaseRepository.cs：

using Sincere.Core.Model;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace Sincere.Core.IRepository.Base
{
    public interface IBaseRepository<TEntity> where TEntity : class
    {
        Task<int> Execute(string sql, List<SqlParameter> parms, CommandType cmdType = CommandType.Text);
        Task<List<TEntity>> Query(string sql, List<SqlParameter> parms, CommandType cmdType = CommandType.Text);
        Task<bool> Insert(TEntity model);
        Task<bool> InsertRange(List<TEntity> datas);

        Task<int> Del(TEntity model);

        Task<int> DelBy(Expression<Func<TEntity, bool>> delWhere);

        Task<int> Modify(TEntity model);

        Task<int> Modify(TEntity model, params string[] propertyNames);

        Task<int> ModifyBy(TEntity model, Expression<Func<TEntity, bool>> whereLambda, params string[] modifiedPropertyNames);

        Task<List<TEntity>> GetList();

        Task<List<TEntity>> GetListBy(Expression<Func<TEntity, bool>> whereLambda);

        Task<TEntity> GetModelById(Expression<Func<TEntity, bool>> whereLambda);

        Task<List<TEntity>> GetListBy<TKey>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderLambda, bool isAsc = true);

        Task<List<TEntity>> GetListBy<TKey>(int top, Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderLambda, bool isAsc = true);

        Task<List<TEntity>> GetListBy<TKey1, TKey2>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey1>> orderLambda1, Expression<Func<TEntity, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true);

        Task<List<TEntity>> GetListBy<TKey1, TKey2>(int top, Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey1>> orderLambda1, Expression<Func<TEntity, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true);

        Task<List<TEntity>> GetPagedList<TKey>(int pageIndex, int pageSize, Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderByLambda, bool isAsc = true);

        Task<PageModel<TEntity>> GetPagedList<TKey>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderByLambda, bool isAsc = true, int pageIndex = 1, int pageSize = 20);

        void RollBackChanges();

    }
}

BaseRepository.cs：

using Microsoft.EntityFrameworkCore;
using Sincere.Core.IRepository.Base;
using Sincere.Core.Model;
using Sincere.Core.Model.Models;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace Sincere.Core.Repository.Base
{
    public class BaseRepository<TEntity> : IBaseRepository<TEntity> where TEntity : class, new()
    {
        private BaseCoreContext _db;
        private readonly DbSet<TEntity> _dbSet;

        internal BaseCoreContext Db
        {
            get { return _db; }
            private set { _db = value; }
        }
        public BaseRepository(IBaseContext mydbcontext)
        {
            this._db = mydbcontext as BaseCoreContext;
            this._dbSet = _db.Set<TEntity>();
        }

        #region INSERT

        /// <summary>
        /// 新增 實體
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        //public async Task<bool> Insert(TEntity model, bool isSaveChanges = false)
        public async Task<bool> Insert(TEntity model)
        {
            _db.Set<TEntity>().Add(model);
            //if (isSaveChanges)
            //{
            return await _db.SaveChangesAsync() > 0;
            //}
            //else
            //{
            //    return false;
            //}

        }

        /// <summary>
        /// 普通批量插入
        /// </summary>
        /// <param name="datas"></param>
        public async Task<bool> InsertRange(List<TEntity> datas)
        {
            await _db.Set<TEntity>().AddRangeAsync(datas);
            return await _db.SaveChangesAsync() == datas.Count;
        }

        #endregion INSERT

        #region Delete

        #region 2.0 根據id刪除 +  int Del(T model)
        /// <summary>
        /// 2.0 根據id刪除
        /// </summary>
        /// <param name="model">必須包含要刪除id的對象</param>
        /// <returns></returns>
        public async Task<int> Del(TEntity model)
        {
            _db.Set<TEntity>().Attach(model);
            _db.Set<TEntity>().Remove(model);
            return await _db.SaveChangesAsync();
        }
        #endregion

        #region 2.1 根據條件刪除 + int DelBy(Expression<Func<T, bool>> delWhere)
        /// <summary>
        /// 2.1 根據條件刪除
        /// </summary>
        /// <param name="delWhere"></param>
        /// <returns>返回受影響的行數</returns>
        public async Task<int> DelBy(Expression<Func<TEntity, bool>> delWhere)
        {
            //2.1.1 查詢要刪除的數據
            List<TEntity> listDeleting = _db.Set<TEntity>().Where(delWhere).ToList();
            //2.1.2 將要刪除的數據 用刪除方法添加到 EF 容器中
            listDeleting.ForEach(u =>
            {
                _db.Set<TEntity>().Attach(u);  //先附加到EF 容器
                _db.Set<TEntity>().Remove(u); //標識為刪除狀態
            });
            //2.1.3 一次性生成sql語句 到數據庫執行刪除
            return await _db.SaveChangesAsync();
        }
        #endregion


        #endregion

        #region UPDATE

        #region 3.0 修改實體 +  int Modify(T model)
        /// <summary>
        /// 修改實體
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public async Task<int> Modify(TEntity model)
        {
            //EntityEntry entry = _db.Entry<TEntity>(model);
            _db.Set<TEntity>().Update(model);
            return await _db.SaveChangesAsync();
        }
        #endregion

        #region 3.1 修改實體，可修改指定屬性 + int Modify(T model, params string[] propertyNames)
        /// <summary>
        /// 3.1 修改實體，可修改指定屬性
        /// </summary>
        /// <param name="model"></param>
        /// <param name="propertyName"></param>
        /// <returns></returns>
        public async Task<int> Modify(TEntity model, params string[] propertyNames)
        {
            //3.1.1 將對象添加到EF中
            EntityEntry entry = _db.Entry<TEntity>(model);
            //3.1.2 先設置對象的包裝狀態為 Unchanged
            entry.State = EntityState.Unchanged;
            //3.1.3 循環被修改的屬性名數組
            foreach (string propertyName in propertyNames)
            {
                //將每個被修改的屬性的狀態設置為已修改狀態；這樣在后面生成的修改語句時，就只為標識為已修改的屬性更新
                entry.Property(propertyName).IsModified = true;
            }
            return await _db.SaveChangesAsync();
        }
        #endregion

        #region 3.2 批量修改 + int ModifyBy(T model, Expression<Func<T, bool>> whereLambda, params string[] modifiedPropertyNames)
        /// <summary>
        /// 3.2 批量修改
        /// </summary>
        /// <param name="model"></param>
        /// <param name="whereLambda"></param>
        /// <param name="modifiedPropertyNames"></param>
        /// <returns></returns>
        public async Task<int> ModifyBy(TEntity model, Expression<Func<TEntity, bool>> whereLambda, params string[] modifiedPropertyNames)
        {
            //3.2.1 查詢要修改的數據
            List<TEntity> listModifing = _db.Set<TEntity>().Where(whereLambda).ToList();
            //3.2.2 獲取實體類類型對象
            Type t = typeof(TEntity);
            //3.2.3 獲取實體類所有的公共屬性
            List<PropertyInfo> propertyInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();
            //3.2.4 創建實體屬性字典集合
            Dictionary<string, PropertyInfo> dicPropertys = new Dictionary<string, PropertyInfo>();
            //3.2.5 將實體屬性中要修改的屬性名 添加到字典集合中  鍵：屬性名  值：屬性對象
            propertyInfos.ForEach(p =>
            {
                if (modifiedPropertyNames.Contains(p.Name))
                {
                    dicPropertys.Add(p.Name, p);
                }
            });
            //3.2.6 循環要修改的屬性名
            foreach (string propertyName in modifiedPropertyNames)
            {
                //判斷要修改的屬性名是否在實體類的屬性集合中存在
                if (dicPropertys.ContainsKey(propertyName))
                {
                    //如果存在，則取出要修改的屬性對象
                    PropertyInfo proInfo = dicPropertys[propertyName];
                    //取出要修改的值
                    object newValue = proInfo.GetValue(model, null);
                    //批量設置要修改對象的屬性
                    foreach (TEntity item in listModifing)
                    {
                        //為要修改的對象的要修改的屬性設置新的值
                        proInfo.SetValue(item, newValue, null);
                    }
                }
            }
            //一次性生成sql語句 到數據庫執行
            return await _db.SaveChangesAsync();
        }
        #endregion


        #endregion UPDATE

        #region SELECT

        #region  5.0 根據條件查詢 + List<TEntity> GetListBy(Expression<Func<T, bool>> whereLambda)
        /// <summary>
        /// 5.0 根據條件查詢
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        public async Task<List<TEntity>> GetListBy(Expression<Func<TEntity, bool>> whereLambda)
        {
            return await _db.Set<TEntity>().Where(whereLambda).AsNoTracking().ToListAsync();
        }

        public async Task<TEntity> GetModelById(Expression<Func<TEntity, bool>> whereLambda)
        {
            return await _db.Set<TEntity>().Where(whereLambda).AsNoTracking().FirstOrDefaultAsync();
        }
        public async Task<List<TEntity>> GetList()
        {
            return await _db.Set<TEntity>().AsNoTracking().ToListAsync();
        }
        #endregion

        #region 5.1 根據條件查詢，並排序 +  List<TEntity> GetListBy<TKey>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
        /// <summary>
        /// 5.1 根據條件查詢，並排序
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="whereLambda"></param>
        /// <param name="orderLambda"></param>
        /// <param name="isAsc"></param>
        /// <returns></returns>
        public async Task<List<TEntity>> GetListBy<TKey>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderLambda, bool isAsc = true)
        {
            if (isAsc)
            {
                return await _db.Set<TEntity>().Where(whereLambda).OrderBy(orderLambda).AsNoTracking().ToListAsync();
            }
            else
            {
                return await _db.Set<TEntity>().Where(whereLambda).OrderByDescending(orderLambda).AsNoTracking().ToListAsync();
            }
        }
        #endregion

        #region 5.2 根據條件查詢Top多少個，並排序 + List<TEntity> GetListBy<TKey>(int top, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
        /// <summary>
        /// 5.2 根據條件查詢Top多少個，並排序
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="top"></param>
        /// <param name="whereLambda"></param>
        /// <param name="orderLambda"></param>
        /// <param name="isAsc"></param>
        /// <returns></returns>
        public async Task<List<TEntity>> GetListBy<TKey>(int top, Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderLambda, bool isAsc = true)
        {
            if (isAsc)
            {
                return await _db.Set<TEntity>().Where(whereLambda).OrderBy(orderLambda).Take(top).AsNoTracking().ToListAsync();
            }
            else
            {
                return await _db.Set<TEntity>().Where(whereLambda).OrderByDescending(orderLambda).Take(top).AsNoTracking().ToListAsync();
            }
        }
        #endregion

        #region  5.3 根據條件排序查詢  雙排序 + List<TEntity> GetListBy<TKey1, TKey2>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey1>> orderLambda1, Expression<Func<T, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
        /// <summary>
        /// 5.3 根據條件排序查詢  雙排序
        /// </summary>
        /// <typeparam name="TKey1"></typeparam>
        /// <typeparam name="TKey2"></typeparam>
        /// <param name="whereLambda"></param>
        /// <param name="orderLambda1"></param>
        /// <param name="orderLambda2"></param>
        /// <param name="isAsc1"></param>
        /// <param name="isAsc2"></param>
        /// <returns></returns>
        public async Task<List<TEntity>> GetListBy<TKey1, TKey2>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey1>> orderLambda1, Expression<Func<TEntity, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
        {
            if (isAsc1)
            {
                if (isAsc2)
                {
                    return await _db.Set<TEntity>().Where(whereLambda).OrderBy(orderLambda1).ThenBy(orderLambda2).AsNoTracking().ToListAsync();
                }
                else
                {
                    return await _db.Set<TEntity>().Where(whereLambda).OrderBy(orderLambda1).ThenByDescending(orderLambda2).AsNoTracking().ToListAsync();
                }
            }
            else
            {
                if (isAsc2)
                {
                    return await _db.Set<TEntity>().Where(whereLambda).OrderByDescending(orderLambda1).ThenBy(orderLambda2).AsNoTracking().ToListAsync();
                }
                else
                {
                    return await _db.Set<TEntity>().Where(whereLambda).OrderByDescending(orderLambda1).ThenByDescending(orderLambda2).AsNoTracking().ToListAsync();
                }
            }
        }
        #endregion

        #region 5.3 根據條件排序查詢Top個數  雙排序 + List<TEntity> GetListBy<TKey1, TKey2>(int top, Expression<Func<T, bool>> whereLambda, System.Linq.Expressions.Expression<Func<T, TKey1>> orderLambda1, Expression<Func<T, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
        /// <summary>
        ///  5.3 根據條件排序查詢Top個數  雙排序
        /// </summary>
        /// <typeparam name="TKey1"></typeparam>
        /// <typeparam name="TKey2"></typeparam>
        /// <param name="top"></param>
        /// <param name="whereLambda"></param>
        /// <param name="orderLambda1"></param>
        /// <param name="orderLambda2"></param>
        /// <param name="isAsc1"></param>
        /// <param name="isAsc2"></param>
        /// <returns></returns>
        public async Task<List<TEntity>> GetListBy<TKey1, TKey2>(int top, Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey1>> orderLambda1, Expression<Func<TEntity, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
        {
            if (isAsc1)
            {
                if (isAsc2)
                {
                    return await _db.Set<TEntity>().Where(whereLambda).OrderBy(orderLambda1).ThenBy(orderLambda2).Take(top).AsNoTracking().ToListAsync();
                }
                else
                {
                    return await _db.Set<TEntity>().Where(whereLambda).OrderBy(orderLambda1).ThenByDescending(orderLambda2).Take(top).AsNoTracking().ToListAsync();
                }
            }
            else
            {
                if (isAsc2)
                {
                    return await _db.Set<TEntity>().Where(whereLambda).OrderByDescending(orderLambda1).ThenBy(orderLambda2).Take(top).AsNoTracking().ToListAsync();
                }
                else
                {
                    return await _db.Set<TEntity>().Where(whereLambda).OrderByDescending(orderLambda1).ThenByDescending(orderLambda2).Take(top).AsNoTracking().ToListAsync();
                }
            }
        }
        #endregion

        #endregion SELECT

        #region 分頁

        #region 6.0 分頁查詢 + List<T> GetPagedList<TKey>
        /// <summary>
        /// 分頁查詢 + List<TEntity> GetPagedList
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="pageIndex">頁碼</param>
        /// <param name="pageSize">頁容量</param>
        /// <param name="whereLambda">條件 lambda表達式</param>
        /// <param name="orderBy">排序 lambda表達式</param>
        /// <returns></returns>
        public async Task<List<TEntity>> GetPagedList<TKey>(int pageIndex, int pageSize, Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderByLambda, bool isAsc = true)
        {
            // 分頁 一定注意： Skip 之前一定要 OrderBy
            if (isAsc)
            {
                return await _db.Set<TEntity>().Where(whereLambda).OrderBy(orderByLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToListAsync();
            }
            else
            {
                return await _db.Set<TEntity>().Where(whereLambda).OrderByDescending(orderByLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToListAsync();
            }
        }
        #endregion

        #region 6.1分頁查詢 帶輸出 +List<TEntity> GetPagedList<TKey>
        /// <summary>
        /// 分頁查詢 帶輸出
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="rowCount"></param>
        /// <param name="whereLambda"></param>
        /// <param name="orderBy"></param>
        /// <param name="isAsc"></param>
        /// <returns></returns>
        public async Task<PageModel<TEntity>> GetPagedList<TKey>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderByLambda, bool isAsc = true, int pageIndex = 1, int pageSize = 20)
        {
            var rowCount = await _db.Set<TEntity>().Where(whereLambda).CountAsync();

            int pageCount = (Math.Ceiling(rowCount.ObjToDecimal() / pageSize.ObjToDecimal())).ObjToInt();

            List<TEntity> list = null;

            if (isAsc)
            {
                list = await _db.Set<TEntity>().OrderBy(orderByLambda).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToListAsync();
            }
            else
            {
                list = await _db.Set<TEntity>().OrderByDescending(orderByLambda).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToListAsync();
            }

            return new PageModel<TEntity>() { dataCount = rowCount, pageCount = pageCount, page = pageIndex, PageSize = pageSize, data = list };
        }
        #endregion

        #endregion

        #region ORTHER

        /// <summary>
        /// 執行存儲過程或自定義sql語句--返回集合
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="parms"></param>
        /// <param name="cmdType"></param>
        /// <returns></returns>
        public async Task<List<TEntity>> Query(string sql, List<SqlParameter> parms, CommandType cmdType = CommandType.Text)
        {
            //存儲過程（exec getActionUrlId @name,@ID）
            if (cmdType == CommandType.StoredProcedure)
            {
                StringBuilder paraNames = new StringBuilder();
                foreach (var sqlPara in parms)
                {
                    paraNames.Append($" @{sqlPara},");
                }
                sql = paraNames.Length > 0 ? $"exec {sql} {paraNames.ToString().Trim(',')}" : $"exec {sql} ";
            }

            return await _db.Set<TEntity>().FromSql(sql).ToListAsync();

        }


        /// <summary>
        /// 回滾
        /// </summary>
        public void RollBackChanges()
        {
            var items = _db.ChangeTracker.Entries().ToList();
            items.ForEach(o => o.State = EntityState.Unchanged);
        }

        /// <summary>
        /// 自定義語句和存儲過程的增刪改--返回影響的行數
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="parms"></param>
        /// <param name="cmdType"></param>
        /// <returns></returns>
        public async Task<int> Execute(string sql, List<SqlParameter> parms, CommandType cmdType = CommandType.Text)
        {
            //存儲過程（exec getActionUrlId @name,@ID）
            if (cmdType == CommandType.StoredProcedure)
            {
                StringBuilder paraNames = new StringBuilder();
                foreach (var sqlPara in parms)
                {
                    paraNames.Append($" @{sqlPara},");
                }
                sql = paraNames.Length > 0 ?
                    $"exec {sql} {paraNames.ToString().Trim(',')}" :
                    $"exec {sql} ";
            }

            int ret = await _db.Database.ExecuteSqlCommandAsync(sql, parms.ToArray());
            return 0;
        }


        #endregion ORTHER
    }
}

BaseRepository中主要是實現了一些基礎的CURD操作，並且封裝了一些常用的數據庫操作。比如分頁、執行sql語句等等

如果直接復制以上代碼，會報錯，因為你的項目中還沒有數據上下文：

 下面就引入我們將要使用的ORM框架--EFCore

首先，在model層總引入：

Install-Package Microsoft.EntityFrameworkCore -version 2.2.4

Install-Package Microsoft.EntityFrameworkCore.SqlServer -version 2.2.4

Install-Package Microsoft.EntityFrameworkCore.Tools -version 2.2.4

 

 此系類中我們采用databaseFrist的方式來生成Model文件和上下文。在數據庫中先建用於測試的表--Advertisement

語句如下：

USE [BaseCore]
GO

/****** Object:  Table [dbo].[Advertisement]    Script Date: 08/28/2019 10:43:34 ******/
SET ANSI_NULLS ON
GO

SET QUOTED_IDENTIFIER ON
GO

CREATE TABLE [dbo].[Advertisement](
    [Id] [int] IDENTITY(1,1) NOT NULL,
    [Createdate] [datetime] NOT NULL,
    [ImgUrl] [nvarchar](512) NULL,
    [Title] [nvarchar](64) NULL,
    [Url] [nvarchar](256) NULL,
    [Remark] [nvarchar](max) NULL,
 CONSTRAINT [PK_dbo.Advertisement] PRIMARY KEY CLUSTERED 
(
    [Id] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]

GO

 

然后使用工具Scaffold-DbContext（數據庫上下文腳手架）來生成model類文件和DbContext。

命令如下：

Scaffold-DbContext "server=.;database=XXX;uid=sa;pwd=密碼;" Microsoft.EntityFrameworkCore.SqlServer -O Models -F  -Context BaseCoreContext 

在執行這個命令之前，需要將Model層設置為啟動項目。否則會報錯。

 

另外當你的項目Buid沒有通過的話，會出現如下錯誤。

我一般的解決方案就是將其他項目全部先卸載，只留下一個Model，然后再執行以上語句。

這時，在你的Model項目下的Models文件夾下，就會出現如下文件：

打開BaseCoreContext.cs 文件，刪除OnConfiguring 方法，至於為什么，我會在后面說明。

為了讓數據庫上下文也能用DI的方式進行使用，我新建了一個, IBaseContext接口，並且讓BaseCoreContext 實現這個接口。

BaseCoreContext.cs

這個時候，倉儲的基礎父類應該是不會報錯。但是我在BaseCoreContext里實現了一個分頁操作，用到了一個PageModel 。需要添加到你的Model層里面

代碼如下：

using System;
using System.Collections.Generic;
using System.Text;

namespace Sincere.Core.Model
{
    /// <summary>
    /// 通用分頁信息類
    /// </summary>
    public class PageModel<T>
    {
        /// <summary>
        /// 當前頁標
        /// </summary>
        public int page { get; set; } = 1;
        /// <summary>
        /// 總頁數
        /// </summary>
        public int pageCount { get; set; } = 6;
        /// <summary>
        /// 數據總數
        /// </summary>
        public int dataCount { get; set; } = 0;
        /// <summary>
        /// 每頁大小
        /// </summary>
        public int PageSize { set; get; }
        /// <summary>
        /// 返回數據
        /// </summary>
        public List<T> data { get; set; }

    }
}

另外里面還有一些 轉換函數，請參考源碼：https://github.com/xzhencheng/Sincere.Core.git

至此，項目的倉儲層的基礎代碼就構建完了，今天的作業就先寫到這！