.Net Core3.1 MVC + EF Core+ AutoFac+LayUI+Sqlserver的框架搭建--------基础架构--1

     从18年毕业到现在干开发转眼都三四年了，当然17年没毕业我就干了差不多一年了，不过做的不是.net 开发，而是Unity3D游戏开发。这几年来一边开发一边自学，一直忙忙碌碌，是该静下心来好好总结一下了。

    我从开始.net 开发到现在，由最开始的MVC4，MVC5，到.net core2.1,.net core2.2 ,到现在我打算用.net core3.1对以前学的东西做个总结。 

    架构还是典型的三层架构，只不过为了低耦合层与层之间依赖接口而已。首先介绍整体结构：

    

 接下来我们就要一点一点的把架构搭建起来了：

在appsettings.json配置数据库连接对象，这里用sqlserver2019数据库，注意：.net core3.1以后选用sqlserver数据库一定要用sqlserver2012以上的版本，不然能连接，但是EF模型映射的时候取数据会异常。数据库我用的是本地数据库

   

{
  "ConnectionStrings": {
    "SmartNetConnStr": "Server=LAPTOP-FOJA6HBQ\SQLEXPRESS;uid=sa;pwd=123;Database=CoreNet;MultipleActiveResultSets=true;"
  },
//rides后面会说
  "RedisCaching": {
    "Enabled": true,
    "RedisConnectionString": "127.0.0.1:6379"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Warning"
    }
  },
  "AllowedHosts": "*"
}

接下来就是数据库的上下文：

using Core.Net.Model;
using Core.Net.Model.System;
using Microsoft.EntityFrameworkCore;

namespace Core.Net.Common.Core.Net.Data
{
  public  class CoreNetDBContext : DbContext
    {
        /// <summary>
        /// 设置EF数据库链接字符串
        /// </summary>
        public static string DbConnStr { get; set; }
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
        }

        /// <summary>
        /// DbContext 初始化时调用
        /// </summary>
        /// <param name="optionsBuilder"></param>
        [System.Obsolete]
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
           
            //optionsBuilder.UseSqlServer(@"Server=(localdb)mssqllocaldb;database=NotifyBird;Trusted_Connection=True;");
            //配置数据链接
            optionsBuilder.UseSqlServer(DbConnStr);

        }

}

然后在startup中注册：

 //1、EF设置字符串初始化模式
  CoreNetDBContext.DbConnStr = Configuration.GetConnectionString("SmartNetConnStr");

   到这里数据库配置就完成了。

接下来我们定义每一层的基类：

IBaseRepository:

using Core.Net.Common.Core.Net.Core;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace Core.Net.IRepository
{
   public  interface IBaseRepository<T> where T : class, new()
    {
     
        int Insert(T entity);
        int Insert(List<T> entitys);
        int Update(T entity);
        int Delete(string propertyName, object propertyValue);
        int DeleteList(string propertyName, object propertyValue);
        int Delete(T entity);
        T FindEntity(string propertyName, object propertyValue);
        IQueryable<T> IQueryable();
        List<T> FindList(PageModel page, string propertyName, bool orderbyDesc);
        List<T> FindList(string propertyName, bool orderbyDesc);
        List<T> FindList(string propertyName, object propertyValue);
        IQueryable<T> IQueryable(string propertyName, object propertyValue, string orderByName, bool orderbyDesc);
        T GetEntityOne(Expression<Func<T, bool>> where);
        IQueryable<T> GetEntityList(Expression<Func<T, bool>> where);
        IQueryable<T> IQueryableDouble(string propertyName, object propertyValue, string propertyNames, object propertyValues, string orderByName, bool orderbyDesc);
        IQueryable<T> IQueryableDouble(string propertyName, object propertyValue, string propertyName1, object propertyValue1, string propertyName2, object propertyValue2, string orderByName, bool orderbyDesc);
        List<T> FindList(PageModel page, string propertyName, object propertyValue, string orderByName, bool orderbyDesc);
        List<T> FindList(PageModel page, Expression<Func<T, bool>> whereLambda, Expression<Func<T, int>> orderbyLambda, bool orderbyDesc);
        List<T> FindList(string propertyName, object propertyValue, string orderByName, bool orderbyDesc);
        List<T> FindList(PageModel page, Expression<Func<T, bool>> whereLambda, Expression<Func<T, object>> orderbyLambda, bool orderbyDesc, Expression<Func<T, object>> thenbyLambda, bool thenbyDesc);
        List<T> GetTEntityList(Expression<Func<T, bool>> where);
        IQueryable<T> GetEntityListOrder<orderkey>(Expression<Func<T, bool>> where, Expression<Func<T, orderkey>> orderbykey, bool asc = true);
        List<T> GetTEntityListOrder<orderkey>(Expression<Func<T, bool>> where, Expression<Func<T, orderkey>> orderbykey, bool asc = true);
        IQueryable<T> GetEntityPaginationListOrder<orderkey>(int pageSize, int pageIndex, Expression<Func<T, orderkey>> orderbykey, out int rowscount, bool asc = true);
        List<T> GetTEntityPaginationListOrder<orderkey>(int pageSize, int pageIndex, Expression<Func<T, orderkey>> orderbykey, out int rowscount, bool asc = true);
        IQueryable<T> GetEntityPaginationListOrder<orderkey>(int pageSize, int pageIndex, Expression<Func<T, bool>> where, Expression<Func<T, orderkey>> orderbykey, out int rowscount, bool asc = true);
        List<T> GetTEntityPaginationListOrder<orderkey>(int pageSize, int pageIndex, Expression<Func<T, bool>> where, Expression<Func<T, orderkey>> orderbykey, out int rowscount, bool asc = true);
        int SaveChanges();
    }
}

BaseRespository：

using Core.Net.Common.Core.Net.Core;
using Core.Net.Common.Core.Net.Data;
using Core.Net.IRepository;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.ChangeTracking;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace Core.Net.Repository
{
     public class BaseRepository<T> : IBaseRepository<T> where T : class, new()
    {
        CoreNetDBContext db = new CoreNetDBContext();

        public int Insert(T entity)
        {
            db.Entry<T>(entity).State = EntityState.Added;
            return db.SaveChanges();
        }
        public int Insert(List<T> entitys)
        {
            foreach (var entity in entitys)
            {
                db.Entry<T>(entity).State = EntityState.Added;
            }
            return db.SaveChanges();
        }
        public int Update(T entity)
        {
            db.Set<T>().Attach(entity);
            PropertyInfo[] props = entity.GetType().GetProperties();
            bool NoPrimaryKey = true; // 未找到主键
            foreach (PropertyInfo prop in props)
            {
                if (prop.GetValue(entity, null) != null)
                {
                    if (prop.GetValue(entity, null).ToString() == "&nbsp;")
                        db.Entry(entity).Property(prop.Name).CurrentValue = null;
                    //主键没找到就一直判断
                    if (NoPrimaryKey)
                    {
                        IList<CustomAttributeData> listAttr = prop.GetCustomAttributesData();
                        if (listAttr.Count > 0 && listAttr[0].AttributeType.Name == "KeyAttribute")
                        {
                            db.Entry(entity).Property(prop.Name).IsModified = false;
                            NoPrimaryKey = false;
                        }
                    }
                    else
                    {
                        db.Entry(entity).Property(prop.Name).IsModified = true;
                    }

                }
            }

            return db.SaveChanges();
        }
       
        public void Update(T entity, params string[] propertyNames)
        {
            EntityEntry entry = db.Entry<T>(entity);
            entry.State = EntityState.Unchanged;
            foreach (var item in propertyNames)
            {
                entry.Property(item).IsModified = true;
            }
            SaveChanges();
        }
        /// <summary>
        /// 删除操作：指定主键和值
        /// </summary>
        /// <param name="propertyName"></param>
        /// <param name="propertyValue"></param>
        /// <returns></returns>
        public int Delete(string propertyName, object propertyValue)
        {
            var TEntity = db.Set<T>().FirstOrDefault(Expression_Equal(propertyName, propertyValue));
            if (TEntity == null)
            {
                return 0;
            }
            else
            {
                return Delete(TEntity);
            }
        }
        /// <summary>
        /// 删除操作：删除所有符合条件的记录
        /// </summary>
        /// <param name="propertyName"></param>
        /// <param name="propertyValue"></param>
        /// <returns></returns>
        public int DeleteList(string propertyName, object propertyValue)
        {
            db.Set<T>().RemoveRange(db.Set<T>().Where(Expression_Equal(propertyName, propertyValue)));
            return db.SaveChanges();
        }
        public int Delete(T entity)
        {
            db.Set<T>().Attach(entity);
            db.Entry<T>(entity).State = EntityState.Deleted;
            return db.SaveChanges();
        }
        #region 单个对象查找
        /// <summary>
        /// 按列名及列值查找单个对象
        /// </summary>
        /// <param name="propertyName"></param>
        /// <param name="propertyValue"></param>
        /// <returns></returns>
        public T FindEntity(string propertyName, object propertyValue)
        {
            return db.Set<T>().FirstOrDefault(Expression_Equal(propertyName, propertyValue));
        }

        #endregion
        /// <summary>
        /// 查询全部记录并返回IQueryable
        /// </summary>
        /// <returns></returns>
        public IQueryable<T> IQueryable()
        {
            return db.Set<T>();
        }
        /// <summary>
        /// 无筛选有排序及分页获取数据列表
        /// </summary>
        /// <param name="page"></param>
        /// <param name="propertyName">单个排序字段</param>
        /// <param name="orderbyDesc">排序方向</param>
        /// <returns></returns>
        public List<T> FindList(PageModel page, string propertyName, bool orderbyDesc)
        {
            Expression<Func<T, int>> orderbyLambda = GetExpression(propertyName);
            //计算总数量
            page.RecordCount = db.Set<T>().Count();
            if (orderbyDesc)
            {
                var query = db.Set<T>()
                             .OrderByDescending<T, int>(orderbyLambda)
                             .Skip(page.PageSize * (page.PageIndex - 1))
                             .Take(page.PageSize);
                return query.ToList<T>();
            }
            else
            {
                var query = db.Set<T>()
                    .OrderBy<T, int>(orderbyLambda)
                    .Skip(page.PageSize * (page.PageIndex - 1))
                    .Take(page.PageSize);
                return query.ToList<T>();
            }
        }
        /// <summary>
        /// 无筛选所有列表,仅排序
        /// </summary>
        /// <param name="propertyName">单个排序字段</param>
        /// <param name="orderbyDesc">排序方向</param>
        /// <returns></returns>
        public List<T> FindList(string propertyName, bool orderbyDesc)
        {
            Expression<Func<T, int>> orderbyLambda = GetExpression(propertyName);
            if (orderbyDesc)
            {
                var query = db.Set<T>().OrderByDescending<T, int>(orderbyLambda);
                return query.ToList<T>();
            }
            else
            {
                var query = db.Set<T>().OrderBy<T, int>(orderbyLambda);
                return query.ToList<T>();
            }
        }
        /// <summary>
        /// 按单条件查询列表 lambda 单个等于查询条件,返回List
        /// <param name="propertyName">条件列名</param>
        /// <param name="propertyValue">条件检索值</param>
        /// <returns></returns>
        public List<T> FindList(string propertyName, object propertyValue)
        {
            return db.Set<T>().Where(Expression_Equal(propertyName, propertyValue)).ToList<T>();
        }

        /// <summary>
        /// 单条件查询所有记录并排序
        /// </summary>
        /// <param name="propertyName">条件列名</param>
        /// <param name="propertyValue">条件检索值</param>
        /// <param name="orderByName">排序列名</param>
        /// <param name="propertyValue">排序对应正序逆序</param>
        /// <returns>返回列表</returns>
        public IQueryable<T> IQueryable(string propertyName, object propertyValue, string orderByName, bool orderbyDesc)
        {
            var query = db.Set<T>().Where(Expression_Equal(propertyName, propertyValue));
            if (orderbyDesc)
            {
                return query.OrderByDescending<T, int>(GetExpression(orderByName));
            }
            else
            {
                return query.OrderBy<T, int>(GetExpression(orderByName));
            }
        }
        /// <summary>
        /// 两个条件查询所有记录并排序
        /// </summary>
        public IQueryable<T> IQueryableDouble(string propertyName, object propertyValue, string propertyNames, object propertyValues, string orderByName, bool orderbyDesc)
        {
            var query = db.Set<T>().Where(Expression_Equal(propertyName, propertyValue));
            query = query.Where(Expression_Equal(propertyNames, propertyValues));
            if (orderbyDesc)
            {
                return query.OrderByDescending<T, int>(GetExpression(orderByName));
            }
            else
            {
                return query.OrderBy<T, int>(GetExpression(orderByName));
            }
        }
        /// <summary>
        /// 三个条件查询所有记录并排序
        /// </summary>
        public IQueryable<T> IQueryableDouble(string propertyName, object propertyValue, string propertyName1, object propertyValue1, string propertyName2, object propertyValue2, string orderByName, bool orderbyDesc)
        {
            var query = db.Set<T>().Where(Expression_Equal(propertyName, propertyValue));
            query = query.Where(Expression_Equal(propertyName1, propertyValue1));
            query = query.Where(Expression_Equal(propertyName2, propertyValue2));
            if (orderbyDesc)
            {
                return query.OrderByDescending<T, int>(GetExpression(orderByName));
            }
            else
            {
                return query.OrderBy<T, int>(GetExpression(orderByName));
            }
        }
        /// <summary>
        /// 单条件查询所有记录并排序分页，propertyValue 为空时自动忽略此查询条件
        /// </summary>
        /// <param name="propertyName">列名/属性</param>
        /// <param name="value">对应值</param>
        /// <returns></returns>
        public List<T> FindList(PageModel page, string propertyName, object propertyValue, string orderByName, bool orderbyDesc)
        {
            if (string.IsNullOrEmpty(propertyValue.ToString()))
            {
                return FindList(page, orderByName, orderbyDesc);
            }
            else
            {
                return FindList(page, Expression_Equal(propertyName, propertyValue), GetExpression(orderByName), orderbyDesc);
            }
        }
        /// <summary>
        /// 通用单字段降序排列分页查询
        /// </summary>
        /// <param name="page">分页对象</param>
        /// <param name="whereLambda">筛选表达式</param>
        /// <param name="orderbyLambda">排序表达式,默认降序排列</param>
        /// <param name="orderbyDesc">true 按降序排列 false 降序</param>
        public List<T> FindList(PageModel page, Expression<Func<T, bool>> whereLambda, Expression<Func<T, int>> orderbyLambda, bool orderbyDesc)
        {
            //计算总数量
            page.RecordCount = db.Set<T>().Where(whereLambda).Count();
            if (orderbyDesc)
            {
                var query = db.Set<T>().Where(whereLambda)
                             .OrderByDescending<T, int>(orderbyLambda)
                             .Skip(page.PageSize * (page.PageIndex - 1))
                             .Take(page.PageSize);
                return query.ToList<T>();
            }
            else
            {
                var query = db.Set<T>().Where(whereLambda)
                    .OrderBy<T, int>(orderbyLambda)
                    .Skip(page.PageSize * (page.PageIndex - 1))
                    .Take(page.PageSize);
                return query.ToList<T>();
            }
        }
        /// <summary>
        /// 单条件查询所有记录并排序不分页
        /// </summary>
        /// <param name="propertyName">列名/属性</param>
        /// <param name="value">对应值</param>
        /// <returns></returns>
        public List<T> FindList(string propertyName, object propertyValue, string orderByName, bool orderbyDesc)
        {
            Expression<Func<T, bool>> whereLambda = Expression_Equal(propertyName, propertyValue);
            Expression<Func<T, int>> orderbyLambda = GetExpression(orderByName);
            if (orderbyDesc)
            {
                var query = db.Set<T>().Where(whereLambda)
                             .OrderByDescending<T, int>(orderbyLambda);
                return query.ToList<T>();
            }
            else
            {
                var query = db.Set<T>().Where(whereLambda)
                    .OrderBy<T, int>(orderbyLambda);
                return query.ToList<T>();
            }
        }
        /// <summary>
        /// 通用两字段降序排列分页查询
        /// </summary>
        /// <param name="page">分页对象</param>
        /// <param name="whereLambda">条件筛选表达式,不能为null</param>
        /// <param name="orderbyLambda">排序表达式,默认降序排列,不能为null</param>
        /// <param name="orderbyDesc">true 按降序排列 false 降序</param>
        /// <param name="thenbyLambda">排序表达式,默认降序排列</param>
        /// <param name="thenbyDesc">true 按降序排列 false 降序</param>
        public List<T> FindList(PageModel page, Expression<Func<T, bool>> whereLambda, Expression<Func<T, object>> orderbyLambda, bool orderbyDesc, Expression<Func<T, object>> thenbyLambda, bool thenbyDesc)
        {
            //计算总数量
            page.RecordCount = db.Set<T>().Where(whereLambda).Count();
            if (orderbyDesc)
            {
                if (thenbyDesc)
                {
                    var query = db.Set<T>().Where(whereLambda)
                                 .OrderByDescending<T, object>(orderbyLambda)
                                 .ThenByDescending<T, object>(thenbyLambda)
                                 .Skip(page.PageSize * (page.PageIndex - 1))
                                 .Take(page.PageSize);
                    return query.ToList<T>();
                }
                else
                {
                    var query = db.Set<T>().Where(whereLambda)
                               .OrderByDescending<T, object>(orderbyLambda)
                               .ThenBy<T, object>(thenbyLambda)
                               .Skip(page.PageSize * (page.PageIndex - 1))
                               .Take(page.PageSize);
                    return query.ToList<T>();

                }
            }
            else
            {
                if (thenbyDesc)
                {
                    var query = db.Set<T>().Where(whereLambda)
                                 .OrderBy<T, object>(orderbyLambda)
                                 .ThenByDescending<T, object>(thenbyLambda)
                                 .Skip(page.PageSize * (page.PageIndex - 1))
                                 .Take(page.PageSize);
                    return query.ToList<T>();
                }
                else
                {
                    var query = db.Set<T>().Where(whereLambda)
                               .OrderBy<T, object>(orderbyLambda)
                               .ThenBy<T, object>(thenbyLambda)
                               .Skip(page.PageSize * (page.PageIndex - 1))
                               .Take(page.PageSize);
                    return query.ToList<T>();

                }
            }
        }

        /// <summary>
        /// 传入值为表达式返回一个实体
        /// </summary>
        /// <param name="where"></param>
        /// <returns></returns>
        public T GetEntityOne(Expression<Func<T, bool>> where)
        {
            return db.Set<T>().Where(where)?.FirstOrDefault();
        }
        /// <summary>
        /// 传入值为表达式，返回一个IQueryable
        /// </summary>
        /// <param name="where"></param>
        /// <returns></returns>
        public IQueryable<T> GetEntityList(Expression<Func<T, bool>> where)
        {
            return db.Set<T>().Where(where);
        }
        /// <summary>
        /// 传入值为表达式，返回一个List数组
        /// </summary>
        /// <param name="where"></param>
        /// <returns></returns>
        public List<T> GetTEntityList(Expression<Func<T, bool>> where)
        {
            return db.Set<T>().Where(where).ToList();
        }
        public IQueryable<T> GetEntityListOrder<orderkey>(Expression<Func<T, bool>> where, Expression<Func<T, orderkey>> orderbykey, bool asc = true)
        {
            IQueryable<T> qlist = db.Set<T>().Where(where);
            if (asc)
            {
                qlist = qlist.OrderBy(orderbykey).AsQueryable<T>();
            }
            else
            {
                qlist = qlist.OrderByDescending(orderbykey).AsQueryable<T>();
            }
            return qlist;
        }
        public List<T> GetTEntityListOrder<orderkey>(Expression<Func<T, bool>> where, Expression<Func<T, orderkey>> orderbykey, bool asc = true)
        {
            IQueryable<T> qlist = db.Set<T>().Where(where);
            if (asc)
            {
                qlist = qlist.OrderBy(orderbykey).AsQueryable<T>();
            }
            else
            {
                qlist = qlist.OrderByDescending(orderbykey).AsQueryable<T>();
            }
            return qlist.ToList();
        }
        public IQueryable<T> GetEntityPaginationListOrder<orderkey>(int pageSize, int pageIndex, Expression<Func<T, orderkey>> orderbykey, out int rowscount, bool asc = true)
        {
            IQueryable<T> qlist = db.Set<T>();
            if (asc)
            {
                qlist = qlist.OrderBy(orderbykey).AsQueryable<T>();
            }
            else
            {
                qlist = qlist.OrderByDescending(orderbykey).AsQueryable<T>();
            }
            rowscount = qlist.ToList().Count;
            int skipcount = (pageIndex - 1) * pageSize;
            return qlist.Skip(skipcount).Take(pageSize);
        }
        public List<T> GetTEntityPaginationListOrder<orderkey>(int pageSize, int pageIndex, Expression<Func<T, orderkey>> orderbykey, out int rowscount, bool asc = true)
        {
            IQueryable<T> qlist = db.Set<T>();
            if (asc)
            {
                qlist = qlist.OrderBy(orderbykey).AsQueryable<T>();
            }
            else
            {
                qlist = qlist.OrderByDescending(orderbykey).AsQueryable<T>();
            }
            rowscount = qlist.ToList().Count;
            int skipcount = (pageIndex - 1) * pageSize;
            return qlist.Skip(skipcount).Take(pageSize).ToList();
        }
        public IQueryable<T> GetEntityPaginationListOrder<orderkey>(int pageSize, int pageIndex, Expression<Func<T, bool>> where, Expression<Func<T, orderkey>> orderbykey, out int rowscount, bool asc = true)
        {
            IQueryable<T> qlist = db.Set<T>().Where(where);
            if (asc)
            {
                qlist = qlist.OrderBy(orderbykey).AsQueryable<T>();
            }
            else
            {
                qlist = qlist.OrderByDescending(orderbykey).AsQueryable<T>();
            }
            rowscount = qlist.ToList().Count;
            int skipcount = (pageIndex - 1) * pageSize;
            return qlist.Skip(skipcount).Take(pageSize);
        }
         public List<T> GetTEntityPaginationListOrder<orderkey>(int pageSize, int pageIndex, Expression<Func<T, bool>> where, Expression<Func<T, orderkey>> orderbykey, out int rowscount, bool asc = true)
        {
            IQueryable<T> qlist = db.Set<T>().Where(where);
            if (asc)
            {
                qlist = qlist.OrderBy(orderbykey).AsQueryable<T>();
            }
            else
            {
                qlist = qlist.OrderByDescending(orderbykey).AsQueryable<T>();
            }
            rowscount = qlist.ToList().Count;
            int skipcount = (pageIndex - 1) * pageSize;
            return qlist.Skip(skipcount).Take(pageSize).ToList();
        }
        public int SaveChanges()
        {
           return db.SaveChanges();
        }
        /// <summary>
        /// 创建等于运算lambda表达式
        /// </summary>
        /// <typeparam name="T">对象类型</typeparam>
        /// <param name="propertyName">属性/列名</param>
        /// <param name="value">筛选值</param>
        public static Expression<Func<T, bool>> Expression_Equal(string propertyName, object propertyValue)
        {
            ParameterExpression paramTable = Expression.Parameter(typeof(T), "t");    //1、表对象
            MemberExpression memName = Expression.Property(paramTable, propertyName); //2、列对象
            ConstantExpression conName = Expression.Constant(propertyValue);                  //3、值对象
            var queryCase = Expression.Equal(memName, conName);                       //4、动作对象

            return Expression.Lambda<Func<T, bool>>(queryCase, paramTable);
        }
        /// <summary>
        /// 封装一个基本的 p ==> p.xx 对象,主要用来构造OrderBy
        /// </summary>
        /// <typeparam name="TSource"></typeparam>
        /// <param name="propertyName"></param>
        /// <returns></returns>
        public static Expression<Func<T, int>> GetExpression(string propertyName)
        {
            var param = Expression.Parameter(typeof(T), "x");
            Expression conversion = Expression.Convert(Expression.Property(param, propertyName), typeof(int));   //important to use the Expression.Convert   
            return Expression.Lambda<Func<T, int>>(conversion, param);
        }

    }
}

 IBaseServervices:

using Core.Net.Common.Core.Net.Core;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace Core.Net.IServices
{
   public   interface IBaseServices<T> where T : class, new()
    {
       
        int Insert(T entity);
        int Insert(List<T> entitys);
        int Update(T entity);

        int Delete(string propertyName, object propertyValue);
        int DeleteList(string propertyName, object propertyValue);
        int Delete(T entity);
        T FindEntity(string propertyName, object propertyValue);
        IQueryable<T> IQueryable();
        List<T> FindList(PageModel page, string propertyName, bool orderbyDesc);
        List<T> FindList(string propertyName, bool orderbyDesc);
        List<T> FindList(string propertyName, object propertyValue);
        IQueryable<T> IQueryable(string propertyName, object propertyValue, string orderByName, bool orderbyDesc);
        IQueryable<T> IQueryableDouble(string propertyName, object propertyValue, string propertyNames, object propertyValues, string orderByName, bool orderbyDesc);
        IQueryable<T> IQueryableDouble(string propertyName, object propertyValue, string propertyName1, object propertyValue1, string propertyName2, object propertyValue2, string orderByName, bool orderbyDesc);
        List<T> FindList(PageModel page, string propertyName, object propertyValue, string orderByName, bool orderbyDesc);
        List<T> FindList(PageModel page, Expression<Func<T, bool>> whereLambda, Expression<Func<T, int>> orderbyLambda, bool orderbyDesc);
        List<T> FindList(string propertyName, object propertyValue, string orderByName, bool orderbyDesc);
        List<T> FindList(PageModel page, Expression<Func<T, bool>> whereLambda, Expression<Func<T, object>> orderbyLambda, bool orderbyDesc, Expression<Func<T, object>> thenbyLambda, bool thenbyDesc);
     
        T GetEntityOne(Expression<Func<T, bool>> where);
     
        IQueryable<T> GetEntityList(Expression<Func<T, bool>> where);
        List<T> GetTEntityList(Expression<Func<T, bool>> where);
        IQueryable<T> GetEntityListOrder<orderkey>(Expression<Func<T, bool>> where, Expression<Func<T, orderkey>> orderbykey, bool asc = true);
        List<T> GetTEntityListOrder<orderkey>(Expression<Func<T, bool>> where, Expression<Func<T, orderkey>> orderbykey, bool asc = true);
        IQueryable<T> GetEntityPaginationListOrder<orderkey>(int pageSize, int pageIndex, Expression<Func<T, orderkey>> orderbykey, out int rowscount, bool asc = true);
        List<T> GetTEntityPaginationListOrder<orderkey>(int pageSize, int pageIndex, Expression<Func<T, orderkey>> orderbykey, out int rowscount, bool asc = true);
        IQueryable<T> GetEntityPaginationListOrder<orderkey>(int pageSize, int pageIndex, Expression<Func<T, bool>> where, Expression<Func<T, orderkey>> orderbykey, out int rowscount, bool asc = true);
        List<T> GetTEntityPaginationListOrder<orderkey>(int pageSize, int pageIndex, Expression<Func<T, bool>> where, Expression<Func<T, orderkey>> orderbykey, out int rowscount, bool asc = true);
        int SaveChanges();
    }
}

 BaseServervices:

using Core.Net.Common.Core.Net.Core;
using Core.Net.IRepository;
using Core.Net.IServices;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace Core.Net.Services
{
     public class BaseServices<T> : IBaseServices<T> where T : class, new()
    {
       public IBaseRepository<T> dal; 
       public int Insert(T entity)
        {
            return dal.Insert(entity);
        }
        public int Insert(List<T> entitys)
        {
            return dal.Insert(entitys);
        }
        public int Update(T entity)
        {
          return  dal.Update(entity);
        }
        public int Delete(string propertyName, object propertyValue)
        {
            return dal.Delete(propertyName, propertyValue);
        }

        public int DeleteList(string propertyName, object propertyValue)
        {
            return dal.Delete(propertyName, propertyValue);
        }

        public int Delete(T entity)
        {
            return dal.Delete(entity);
        }
        public T FindEntity(string propertyName, object propertyValue)
        {
            return dal.FindEntity(propertyName, propertyValue);
        }
        public IQueryable<T> IQueryable()
        {
            return IQueryable();
        }
        public  List<T> FindList(PageModel page, string propertyName, bool orderbyDesc)
        {
            return dal.FindList(page, propertyName, true);
        }
       public  List<T> FindList(string propertyName, bool orderbyDesc)
        {
            return dal.FindList(propertyName, orderbyDesc);
        }
        public List<T> FindList(string propertyName, object propertyValue)
        {
            return dal.FindList(propertyName, propertyValue);
        }
       public  IQueryable<T> IQueryable(string propertyName, object propertyValue, string orderByName, bool orderbyDesc)
        {
            return dal.IQueryable(propertyName, propertyValue, orderByName, orderbyDesc);
        }
        public IQueryable<T> IQueryableDouble(string propertyName, object propertyValue, string propertyNames, object propertyValues, string orderByName, bool orderbyDesc)
        {
            return dal.IQueryableDouble(propertyName, propertyValue, propertyNames, propertyValues, orderByName, orderbyDesc);
        }
        public IQueryable<T> IQueryableDouble(string propertyName, object propertyValue, string propertyName1, object propertyValue1, string propertyName2, object propertyValue2, string orderByName, bool orderbyDesc)
        {
            return dal.IQueryableDouble(propertyName, propertyValue, propertyName1, propertyValue1, propertyName2, propertyValue2, orderByName, orderbyDesc);
        }
        public List<T> FindList(PageModel page, string propertyName, object propertyValue, string orderByName, bool orderbyDesc)
        {
            return dal.FindList(page, propertyName, propertyValue, orderByName, orderbyDesc);
        }
        public List<T> FindList(PageModel page, Expression<Func<T, bool>> whereLambda, Expression<Func<T, int>> orderbyLambda, bool orderbyDesc)
        {
            return dal.FindList(page, whereLambda, orderbyLambda, orderbyDesc);
        }
        public List<T> FindList(string propertyName, object propertyValue, string orderByName, bool orderbyDesc)
        {
            return dal.FindList(propertyName, propertyValue, orderByName, orderbyDesc);
        }
        public List<T> FindList(PageModel page, Expression<Func<T, bool>> whereLambda, Expression<Func<T, object>> orderbyLambda, bool orderbyDesc, Expression<Func<T, object>> thenbyLambda, bool thenbyDesc)
        {
            return dal.FindList(page, whereLambda, orderbyLambda, orderbyDesc, thenbyLambda, thenbyDesc);
        }


        public IQueryable<T> GetEntityList(Expression<Func<T, bool>> where)
        {
            return dal.GetEntityList(where);
        }
        public List<T> GetTEntityList(Expression<Func<T, bool>> where)
        {
            return dal.GetTEntityList(where);
        }
        public IQueryable<T> GetEntityPaginationListOrder<orderkey>(int pageSize, int pageIndex, Expression<Func<T, orderkey>> orderbykey, out int rowscount, bool asc = true)
        {
            return dal.GetEntityPaginationListOrder(pageSize, pageIndex, orderbykey, out rowscount, true);
        }
        public List<T> GetTEntityListOrder<orderkey>(Expression<Func<T, bool>> where, Expression<Func<T, orderkey>> orderbykey, bool asc = true)
        {
            return dal.GetTEntityListOrder<orderkey>(where, orderbykey, asc);
        }
        public IQueryable<T> GetEntityListOrder<orderkey>(Expression<Func<T, bool>> where, Expression<Func<T, orderkey>> orderbykey, bool asc = true)
        {
            return dal.GetEntityListOrder<orderkey>(where, orderbykey, asc);
        }
        public List<T> GetTEntityPaginationListOrder<orderkey>(int pageSize, int pageIndex, Expression<Func<T, orderkey>> orderbykey, out int rowscount, bool asc = true)
        {
            return dal.GetTEntityPaginationListOrder<orderkey>(pageSize, pageIndex, orderbykey, out rowscount, asc);
        }
        public T GetEntityOne(Expression<Func<T, bool>> where)
        {
            return dal.GetEntityOne(where);
        }

        public IQueryable<T> GetEntityPaginationListOrder<orderkey>(int pageSize, int pageIndex, Expression<Func<T, bool>> where, Expression<Func<T, orderkey>> orderbykey, out int rowscount, bool asc = true)
        {
            return dal.GetEntityPaginationListOrder<orderkey>(pageSize, pageIndex, where, orderbykey, out rowscount, asc);
        }
        public List<T> GetTEntityPaginationListOrder<orderkey>(int pageSize, int pageIndex, Expression<Func<T, bool>> where, Expression<Func<T, orderkey>> orderbykey, out int rowscount, bool asc = true)
        {
            return GetTEntityPaginationListOrder<orderkey>(pageSize, pageIndex, where, orderbykey, out rowscount, asc);
        }
        public int SaveChanges()
        {
            return dal.SaveChanges();
        }

      
    }
}

 Model:这里先放一个用户实体：

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Text;

namespace Core.Net.Model.System
{
    [Table("CoreNetSystemUser")]
    public class CoreNetSystemUser
    {
        [Key]
        public int UserId { get; set; }
        public string UserName { get; set; }
        public string Passward { get; set; }    
        public string RealName { get; set; }
        public int RoleId { get; set; }
        public int DepartId { get; set; }
        public string PushId { get; set; }
        public int Sex { get; set; }
        public string Email { get; set; }
        public string Phone { get; set; }
        public int IsUse { get; set; }
        public DateTime? AddTime { get; set; }
        public DateTime? UpdateTime { get; set; }
        public string UpdateIP { get; set; }
    
    }
}

具体使用，以用户类为例：

ICoreNetSystemUserRespository：

using Core.Net.Model.System;
using System;
using System.Collections.Generic;
using System.Text;

namespace Core.Net.IRepository
{
    public interface ICoreNetSystemUserRespository : IBaseRepository<CoreNetSystemUser>
    {
    }
}

 CoreNetSystemUserRespository：

using Core.Net.IRepository;
using Core.Net.Model.System;
using System;
using System.Collections.Generic;
using System.Text;

namespace Core.Net.Repository
{
   public class CoreNetSystemUserRespository : BaseRepository<CoreNetSystemUser>, ICoreNetSystemUserRespository
    {
    }
}

ICoreNetSystemUserServices：

using Core.Net.Model.System;
using System;
using System.Collections.Generic;
using System.Text;

namespace Core.Net.IServices
{
  public  interface ICoreNetSystemUserServices : IBaseServices<CoreNetSystemUser>
    {
    }
}

 CoreNetSystemUserServices：

using Core.Net.IRepository;
using Core.Net.IServices;
using Core.Net.Model.System;
namespace Core.Net.Services
{
   public class CoreNetSystemUserServices : BaseServices<CoreNetSystemUser>, ICoreNetSystemUserServices
    {
        public CoreNetSystemUserServices(ICoreNetSystemUserRespository dal)
        {
            base.dal = dal;
        }
    }
}

 对了，这里要加上一个分页类，不然上面Base基类会用到，不加报错的。

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

namespace Core.Net.Common.Core.Net.Core
{
    /// <summary>
    /// 通用分页对象
    /// </summary>
    public class PageModel
    {
        /// <summary>
        /// 每页记录数
        /// </summary>
        public int PageSize { get; set; }
        /// <summary>
        /// 当前页
        /// </summary>

        private int _pageIndex = 1;
        /// <summary>
        /// 当前页索引，即第几页，从1开始
        /// </summary>
        public int PageIndex
        {
            get
            {
                if (_pageIndex <= 0)
                    _pageIndex = 1;
                return _pageIndex;
            }
            set { _pageIndex = value; }
        }

        /// <summary>
        /// 总记录数
        /// </summary>
        public int RecordCount { get; set; }
        /// <summary>
        /// 总页数
        /// </summary>
        public int TotalPage
        {
            get
            {
                if (RecordCount > 0)
                {
                    return RecordCount % this.PageSize == 0 ? RecordCount / this.PageSize : RecordCount / this.PageSize + 1;
                }
                else
                {
                    return 0;
                }
            }
        }
    }

    /// <summary>
    /// 通用分页对象单例,初始化参数配置计划存放在config中
    /// </summary>
    public class PageModelInstance
    {
        /// <summary>
        /// 分页按实例生成默认值
        /// </summary>
        private static PageModel pageInstance;
        /// <summary>
        /// 获取一个初始化的分页对象实例
        /// </summary>
        /// <returns></returns>
        public static PageModel GetInstance()
        {
            if (pageInstance == null)
            {
                pageInstance = new PageModel();
                pageInstance.PageSize = 20;
                pageInstance.PageIndex = 1;
                pageInstance.RecordCount = 0;
            }

            return pageInstance;
        }
        /// <summary>
        /// 获取一个初始化的分页对象实例
        /// </summary>
        /// <returns></returns>
        public static PageModel GetInstance(int pageSize, int pageIndex)
        {
            if (pageInstance == null)
            {
                pageInstance = new PageModel();
                pageInstance.RecordCount = 0;
            }
            pageInstance.PageSize = pageSize;
            pageInstance.PageIndex = pageIndex;
            return pageInstance;
        }
        public static int GetPageTotal(int PageSize, int RecordCount)
        {
            if (RecordCount > 0)
            {
                return RecordCount % PageSize == 0 ? RecordCount / PageSize : RecordCount / PageSize + 1;
            }
            else
            {
                return 0;
            }
        }
    }

}

 到这里一个简单的架构已经成型了，至于怎末使用后续在加入Layui前端框架的时候会详细说明。