49

我的存储库处理并为富域模型提供持久性。我不想将贫血的实体框架数据实体暴露给我的业务层，因此我需要某种方式在它们之间进行映射。

在大多数情况下，从数据实体构造域模型实例需要使用参数化的构造函数和方法（因为它很丰富）。它不像属性/字段匹配那么简单。AutoMapper 可用于相反的情况（映射到数据实体），但不能用于创建域模型。

下面是我的存储库模式的核心。

该类EntityFrameworkRepository适用于两种通用类型：

  • TDomainModel: 富域模型
  • TEntityModel: Entity Framework 数据实体

定义了两个抽象方法：

  • ToDataEntity(TDomainModel): 转换为数据实体（forAdd()和Update()方法）
  • ToDomainModel(TEntityModel)：构建领域模型（用于Find()方法）。

这些方法的具体实现将定义相关存储库所需的映射。

public interface IRepository<T> where T : DomainModel
{
    T Find(int id);
    void Add(T item);
    void Update(T item);
}

public abstract class EntityFrameworkRepository<TDomainModel, TEntityModel> : IRepository<TDomainModel>
    where TDomainModel : DomainModel
    where TEntityModel : EntityModel
{
    public EntityFrameworkRepository(IUnitOfWork unitOfWork)
    {
        // ...
    }

    public virtual TDomainModel Find(int id)
    {
        var entity = context.Set<TEntityModel>().Find(id);

        return ToDomainModel(entity);
    }

    public virtual void Add(TDomainModel item)
    {
        context.Set<TEntityModel>().Add(ToDataEntity(item));
    }

    public virtual void Update(TDomainModel item)
    {
        var entity = ToDataEntity(item);

        DbEntityEntry dbEntityEntry = context.Entry<TEntityModel>(entity);

        if (dbEntityEntry.State == EntityState.Detached)
        {
            context.Set<TEntityModel>().Attach(entity);

            dbEntityEntry.State = EntityState.Modified;
        }
    }

    protected abstract TEntityModel ToDataEntity(TDomainModel domainModel);
    protected abstract TDomainModel ToDomainModel(TEntityModel dataEntity);
}

这是存储库实现的基本示例：

public interface ICompanyRepository : IRepository<Company>
{
    // Any specific methods could be included here
}

public class CompanyRepository : EntityFrameworkRepository<Company, CompanyTableEntity>, ICompanyRepository
{
    protected CompanyTableEntity ToDataEntity(Company domainModel)
    {
        return new CompanyTable()
        {
            Name = domainModel.Name,
            City = domainModel.City
            IsActive = domainModel.IsActive
        };
    }

    protected Company ToDomainModel(CompanyTableEntity dataEntity) 
    {
        return new Company(dataEntity.Name, dataEntity.IsActive)
        {
            City = dataEntity.City
        }
    }
}

问题：

ACompany可能由许多Departments. 如果我想CompanyRepository在获取 a 时急切地加载这些，Company那么我将在哪里定义 aDepartment和 a之间的映射DepartmentDataEntity？

我可以在 中提供更多映射方法CompanyRepository，但这很快就会变得混乱。很快就会在整个系统中出现重复的映射方法。

解决上述问题的更好方法是什么？

4

6 回答 6

34

我的存储库处理并为富域模型提供持久性。我不想将贫血的实体框架数据实体暴露给我的业务层，因此我需要某种方式在它们之间进行映射。

如果您使用实体框架，它可以映射富域模型本身。

我最近回答了类似的问题“关于将实体映射到域对象的建议”。

我一直在使用 NHibernate，并且知道在 Entity Framework 中，您还可以指定从 DB 表到 POCO 对象的映射规则。在实体框架实体之上开发另一个抽象层是一项额外的工作。让 ORM 负责所有的映射、状态跟踪、工作单元和身份映射实现等。现代 ORM 知道如何处理所有这些问题。

AutoMapper 可用于相反的情况（映射到数据实体），但不能用于创建域模型。

你是完全正确的。

当一个实体可以映射到另一个实体而不需要额外的依赖项（例如存储库、服务......）时，Automapper 很有用。

...我将在哪里定义 aDepartment和 a之间的映射DepartmentDataEntity？

我会将其放入DepartmentRepository并添加方法IList<Department> FindByCompany(int companyId)以检索公司的部门。

我可以在 中提供更多映射方法CompanyRepository，但这很快就会变得混乱。很快就会在整个系统中出现重复的映射方法。

解决上述问题的更好方法是什么？

如果需要获取Department另一个实体的 s 列表，则应添加一个新方法，DepartmentRepository并在需要的地方简单地使用它。

于 2014-01-09T23:26:16.480 回答
5

假设您有以下数据访问对象...

public class AssetDA
{        
    public HistoryLogEntry GetHistoryRecord(int id)
    {
        HistoryLogEntry record = new HistoryLogEntry();

        using (IUnitOfWork uow = new NHUnitOfWork())
        {
            IReadOnlyRepository<HistoryLogEntry> repository = new NHRepository<HistoryLogEntry>(uow);
            record = repository.Get(id);
        }

        return record;
    }
}

它返回一个历史日志条目数据实体。该数据实体定义如下...

public class HistoryLogEntry : IEntity
{
    public virtual int Id
    { get; set; }

    public virtual int AssetID 
    { get; set; }

    public virtual DateTime Date
    { get; set; }

    public virtual string Text
    { get; set; }

    public virtual Guid UserID
    { get; set; }

    public virtual IList<AssetHistoryDetail> Details { get; set; }
}

您可以看到该属性Details引用了另一个数据实体AssetHistoryDetail。现在，在我的项目中，我需要将这些数据实体映射到我的业务逻辑中使用的域模型对象。为了进行映射，我定义了扩展方法……我知道这是一种反模式，因为它是特定于语言的，但好处是它隔离并打破了彼此之间的依赖关系……是的，这就是它的美妙之处。因此，映射器定义如下...

internal static class AssetPOMapper
{
    internal static HistoryEntryPO FromDataObject(this HistoryLogEntry t)
    {
        return t == null ? null :
            new HistoryEntryPO()
            {
                Id = t.Id,
                AssetID = t.AssetID,
                Date = t.Date,
                Text = t.Text,
                UserID = t.UserID,
                Details = t.Details.Select(x=>x.FromDataObject()).ToList()
            };
    }

    internal static AssetHistoryDetailPO FromDataObject(this AssetHistoryDetail t)
    {
        return t == null ? null :
            new AssetHistoryDetailPO()
            {
                Id = t.Id,
                ChangedDetail = t.ChangedDetail,
                OldValue = t.OldValue,
                NewValue = t.NewValue
            };
    }
}

差不多就是这样。所有依赖项都在一个地方。然后，当从业务逻辑层调用数据对象时LINQ，剩下的就交给我了……

var da = new AssetDA();
var entry =  da.GetHistoryRecord(1234);
var domainModelEntry = entry.FromDataObject();

请注意，您可以定义相同的内容以将域模型对象映射到数据实体。

于 2014-01-06T07:43:44.960 回答
4

对于实体框架，恕我直言，从实体模型转换为其他形式的模型（域模型、值对象、视图模型等）通常是一个坏主意，反之亦然，除非仅在应用程序层中，因为您将失去了很多只能通过实体对象实现的 EF 功能，例如丢失更改跟踪和丢失 LINQ 可查询。

最好在存储库层和应用程序层之间进行映射。将实体模型保存在存储库层中。

于 2014-01-10T12:20:15.687 回答
3

我喜欢使用定制的扩展方法来做实体和域对象之间的映射。

  • 当其他实体在包含实体中时，您可以轻松地调用其他实体的扩展方法。
  • 您可以通过创建 IEnumerable<> 扩展来轻松处理集合。

一个简单的例子：

public static class LevelTypeItemMapping
{
    public static LevelTypeModel ToModel(this LevelTypeItem entity)
    {
        if (entity == null) return new LevelTypeModel();

        return new LevelTypeModel
        { 
            Id = entity.Id;
            IsDataCaptureRequired = entity.IsDataCaptureRequired;
            IsSetupRequired = entity.IsSetupRequired;
            IsApprover = entity.IsApprover;
            Name = entity.Name;
        }
    }
    public static IEnumerable<LevelTypeModel> ToModel(this IEnumerable<LevelTypeItem> entities)
    {
        if (entities== null) return new List<LevelTypeModel>();

        return (from e in entities
                select e.ToModel());
    }

}

......你像这样使用它们......

 using (IUnitOfWork uow = new NHUnitOfWork())
        {
        IReadOnlyRepository<LevelTypeItem> repository = new NHRepository<LevelTypeItem>(uow);
        record = repository.Get(id);

        return record.ToModel();

        records = repository.GetAll(); // Return a collection from the DB
        return records.ToModel(); // Convert a collection of entities to a collection of models
        }

不完美，但很容易遵循并且很容易重用。

于 2014-01-09T16:10:28.177 回答
2

就像以前的帖子说的那样。最好等到存储库之后进行实际映射。但我喜欢使用自动映射器。它提供了一种将对象映射到其他对象的非常简单的方法。对于某些关注点分离，您还可以在单​​独的项目中定义映射。这些映射也是通用的/基于类型的：

  1. 您在映射中指定基本类型并定义它如何填充目标类型
  2. 在需要映射的地方，只需调用 Mapper.Map(baseTypeObject, DestinationTypeObject)
  3. Automapper 应该处理其余的

如果我正确理解了您的问题，这可以解决问题。

于 2014-01-10T12:36:30.123 回答
0

我不喜欢手动映射所以映射我使用http://valueinjecter.codeplex.com/

于 2014-01-08T15:38:14.417 回答