车辆派遣系统-重新分层

重新创建了Model层，用来存储EF

 

namespace CarSystem.Model
{
    using System;
    using System.Data.Entity;
    using System.Data.Entity.ModelConfiguration.Conventions;
    using System.Linq;

    public class CarContext : DbContext
    {

        public CarContext()
            : base("name=CarSystem")
        {
            Database.SetInitializer<CarContext>(strategy: null);
        }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>();
            modelBuilder.Conventions.Remove<ManyToManyCascadeDeleteConvention>();
        }

        public DbSet<t_user> Users{get;set;}

        public DbSet<t_role> Roles { get; set; }
        public DbSet<t_review> reviews { get; set; }
        public DbSet<t_order> orders { get; set; }
        public DbSet<t_finance> finances { get; set; }
        public DbSet<t_driver> drivers { get; set; }
        public DbSet<t_customer> customers { get; set; }
        public DbSet<t_car> cars { get; set; }

     
    }

}

 public class BaseEntity
    {
        /// <summary>
        /// 编号
        /// </summary>
        public Guid id { get; set; } = Guid.NewGuid();
        /// <summary>
        /// 创建时间
        /// </summary>
        public DateTime CreateTime { get; set; } = DateTime.Now;
        /// <summary>
        /// 是否删除
        /// </summary>
        public bool IsRemoved { get; set; }
    }

 

重新创建了IDAL和IBLL接口层，方便后续实现方法。

IDAL层中的IBaseService基础类：

public interface IBaseService<T>:IDisposable where T:BaseEntity
    {
       Task  CreateAsync(T model,bool saved=true);
        Task EditAsync(T model, bool saved = true);
        Task RemoveAsync(Guid id, bool saved = true);
        Task RemoveAsync(T model, bool saved = true);
        Task Save();
        Task<T> GetOneByIdAsync(Guid id);
        IQueryable<T> GetAll();
        IQueryable<T> GetAllByPage(int pageSize = 10, int pageIndex = 0);
        IQueryable<T> GetAllOrder(bool asc = true);
        IQueryable<T> GetAllByPageOrder(int pageSize = 10, int pageIndex = 0,bool asc=true);

    }

重新创建了DAL层，实现了基础公共方法：

public class BaseService<T> : IBaseService<T> where T : BaseEntity,new()
    {
        private readonly CarContext _db;
        public BaseService(CarContext db) 
        {
            _db = db;
        }
        public async Task CreateAsync(T model, bool saved = true)
        {
            _db.Set<T>().Add(model);
            if (saved) await _db.SaveChangesAsync();
        }

        public void Dispose()
        {
            _db.Dispose();
        }

        public async Task EditAsync(T model, bool saved = true)
        {
            _db.Configuration.ValidateOnSaveEnabled = false;
            _db.Entry(model).State = EntityState.Modified;
            if (saved) 
            {
                await _db.SaveChangesAsync();
                _db.Configuration.ValidateOnSaveEnabled = true;
            }
        }

        /// <summary>
        /// 返回所有没有被删除的数据
        /// </summary>
        /// <param name="asc"></param>
        /// <returns></returns>

        public IQueryable<T> GetAll()
        {
            return _db.Set<T>().Where(m => !m.IsRemoved).AsNoTracking();
        }

        public  IQueryable<T> GetAllByPage(int pageSize = 10, int pageIndex = 0)
        {
            return GetAll().Skip(pageSize * pageIndex).Take(pageSize);
        }

        public  IQueryable<T> GetAllByPageOrder(int pageSize = 10, int pageIndex = 0, bool asc = true)
        {
            return GetAllOrder(asc).Skip(pageSize * pageIndex).Take(pageSize);
        }

        
        public  IQueryable<T> GetAllOrder(bool asc = true)
        {
            var datas = GetAll();
            if (asc)
            {
                datas = datas.OrderBy(m => m.CreateTime);
            }
            else
            {
                datas = datas.OrderByDescending(m => m.CreateTime);
            }

            return datas;
        }

        public async Task<T> GetOneByIdAsync(Guid id)
        {
            return await GetAll().FirstAsync(predicate:m=>m.id==id);
        }

        public async Task RemoveAsync(Guid id, bool saved = true)
        {
            _db.Configuration.ValidateOnSaveEnabled = false;
            var t = new T() { id=id};
            _db.Entry(t).State = EntityState.Unchanged;
            t.IsRemoved = true;
            if (saved) 
            {
                await _db.SaveChangesAsync();
                _db.Configuration.ValidateOnSaveEnabled = true;
            }
        }

        public async Task RemoveAsync(T model, bool saved = true)
        {
            await RemoveAsync(model.id, saved);
        }

        public async Task Save()
        {
            await _db.SaveChangesAsync();
            _db.Configuration.ValidateOnSaveEnabled = true;
        }
    }

遇到的问题比较多，但是都依次解决了，百度知道我知道~