c# - 如何将数据访问映射到 Entity Framework 中的业务逻辑对象

Question

我在 ASP.NET C# MVC 应用程序中使用 Entity Framework 。

我在数据访问层中有 EF 生成的对象:

namespace Project1.DataAccess
{
    using System;
    using System.Collections.Generic;

    public partial class User
    {
        public User()
        {
            this.Files = new HashSet<File>();
            this.Folders = new HashSet<Folder>();
        }
        //...

    }
}

现在，我想创建业务逻辑对象，然后将它们映射到数据访问对象:

namespace Project1.Logic
{
    public class User
    {
        public int Id { get; set; }
    }
}

我在数据库中只有很少的表。我需要使用 Automapper 吗？如果不是，如何实现映射？

Answer 1

我一直使用 EF6 从 MSSQL 表生成我的数据访问层，然后我创建一组对象来表示我希望如何与我的代码交互(或显示它)，它们是 POCO。 “映射”是通过存储库模式的实现来处理的。下面是一个通用接口(interface)，可帮助我确保我的所有 repo 类都遵循相同的形状。

    public interface IDataRepository<T>
    {
        IQueryable<T> Get();
        T Get(int id);
        T Add(T obj);
        T Update(T obj);
        void Delete(T obj);
    }

然后，我像这样创建 repo 类。 (使用您的 UserBusiness 和 UserDAL 类)

public class NewRepo : IDataRepository<UserBusiness>
{
    YourContext db = new YourContext();

    public IQueryable<UserBusiness> Get()
    {
        return (from u in db.UserDAL select new UserBusiness()
        {
           Id = u.Id,
           Name = u.Name
        });
    }

    public UserBusiness Get(int id)
    {
        return (from u in db.UserDAL where u.Id == id select new UserBusiness()
        {
           Id = u.Id,
           Name = u.Name
        }).FirstOrDefault();
    }

    public Order Add(UserBusiness obj)
    {
        UserDAL u= new UserDAL();
        u.Name = obj.Name;

        db.UserDAL.Add(u);
        db.SaveChanges();

        //Assuming the database is generating your Id's for you
        obj.Id = u.Id;

        return obj;

    }

    public Order Update(UserBusiness obj)
    {
        UserDAL u= new UserDAL();
        u.Id = obj.Id;
        u.Name = obj.Name;

        db.Entry(u).State = EntityState.Modified;
        db.SaveChanges();

        return obj;
    }

    public void Delete(UserBusiness obj)
    {
        UserDAL u = db.UserDAL
            .Where(o=>o.Id == obj.Id)
            .FirstOrDefault();

        if (u!=Null)  {
          db.Entry(u).State = EntityState.Deleted;
          db.SaveChanges();
        }

    }
}

在您的应用程序中，您现在可以使用 repo 类的方法而不是 DBContext。

最后，我经常最终添加另一层“服务类”，它与我的存储库交互，管理业务类的内部数据……或者您可以通过将存储库方法添加到他们。我的偏好是保持 POCO 的愚蠢并构建服务类来获取、设置和编辑属性。

是的，有一堆左右映射来将一个类“转换”为另一个类，但它是内部业务逻辑类的干净分离，供以后使用。直接从表到 POCO 的转换起初看起来很愚蠢，但只要等到您的 DBA 想要规范化一些字段，或者您决定向这些简单对象添加一个集合。能够在不破坏应用其余部分的情况下管理您的业务对象是无价的。

---

编辑:下面是存储库的通用版本，这使得创建新存储库变得容易得多。

这是所有业务逻辑层类的基类:

public class BaseEntity
{
    public int Id { get; set; }
}

这是所有数据访问层类的基类:

public class BaseEntityDAL
{
    [Key]
    [Column("Id")]
    public int Id { get; set; }
}

这是存储库的通用基类(注意，我们在这里使用 AutoMapper):

public abstract class BaseRepository<TDAL, TBLL> : IRepository<TBLL>
    where TDAL : BaseEntityDAL, new()
    where TBLL : BaseEntity, new()
{
    protected readonly MyDbContext context;
    protected readonly DbSet<TDAL> dbSet;

    protected virtual TDAL Map(TBLL obj)
    {
        Mapper.CreateMap<TBLL, TDAL>();
        return Mapper.Map<TDAL>(obj);
    }

    protected virtual TBLL Map(TDAL obj)
    {
        Mapper.CreateMap<TDAL, TBLL>();
        return Mapper.Map<TBLL>(obj);
    }

    protected abstract IQueryable<TBLL> GetIQueryable();            

    public BaseRepository(MyDbContext context, DbSet<TDAL> dbSet)
    {
        if (context == null)
            throw new ArgumentNullException(nameof(context));
        if (dbSet == null)
            throw new ArgumentNullException(nameof(dbSet));

        this.context = context;
        this.dbSet = dbSet;
    }

    public TBLL Get(int id)
    {
        var entity = dbSet
            .Where(i => i.Id == id)
            .FirstOrDefault();

        var result = Map(entity);

        return result;
    }

    public IQueryable<TBLL> Get()
    {
        return GetIQueryable();
    }

    public TBLL Add(TBLL obj)
    {
        var entity = Map(obj);

        dbSet.Add(entity);
        context.SaveChanges();

        obj.Id = entity.Id;

        return obj;
    }

    public TBLL Update(TBLL obj)
    {
        var entity = Map(obj);

        context.Entry(entity).State = EntityState.Modified;
        context.SaveChanges();

        return obj;
    }

    public void Delete(TBLL obj)
    {
        TDAL entity = dbSet
            .Where(e => e.Id == obj.Id)
            .FirstOrDefault();

        if (entity != null)
        {
            context.Entry(entity).State = EntityState.Deleted;
            context.SaveChanges();
        }
    }
}

最后，当我们得到以上所有内容时，这是存储库的示例实现，非常干净:

public class ContractRepository : BaseRepository<ContractDAL, Contract>
{
    protected override IQueryable<Contract> GetIQueryable()
    {
        return dbSet
            .Select(entity => new Contract()
            {
                // We cannot use AutoMapper here, because Entity Framework
                // won't be able to process the expression. Hence manual
                // mapping.
                Id = entity.Id,
                CompanyId = entity.CompanyId,
                ProjectId = entity.ProjectId,
                IndexNumber = entity.IndexNumber,
                ContractNumber = entity.ContractNumber,
                ConclusionDate = entity.ConclusionDate,
                Notes = entity.Notes
            });
    }

    public ContractRepository(MyDbContext context)
        : base(context, context.Contracts)
    {

    }
}