如何将数据访问映射到实体框架中的业务逻辑对象

我在 ASP.NET C# MVC 应用程序中使用实体框架。

我在数据访问层中有由 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？如果没有，我怎样才能实现映射？

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

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

然后，我创建这样的存储库类。 （使用您的 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();
        }

    }
}

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

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

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

Edit:下面是存储库的通用版本，这使得创建新存储库变得更加容易。

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

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)
    {

    }
}