使用Automapper测绘大领域模型数据库对象

Question

我想用Automapper到地图了我的模型对象的数据库对象。让我们说，数据库的目的是30多领域我想地图10的20性从我的模型。为了使它更复杂的，我需要地图不同的性质时更新记录的时候比我插入新的记录数据库。

该解决方案，我使用的是创建2个一般类插入以及更新和绘图档案，指定两映射。

例如下：

public abstract class SyncMappingWrapper<TFrom> where TFrom : class
{
    protected SyncMappingWrapper(TFrom model)
    {
        Model = model;
    }

    public TFrom Model { get; private set; }
}

public class Update<TFrom> : SyncMappingWrapper<TFrom> where TFrom : class
{
    public Update(TFrom model)
        : base(model)
    {
    }
}

public class Insert<TFrom> : SyncMappingWrapper<TFrom> where TFrom : class
{
    public Insert(TFrom model)
        : base(model)
    {
    }
}

的映射，然而，越来越讨厌作为的循环的复杂性在天空中的(超过50)作为我需要定义忽略()对所有属性，我不在地图：

CreateMap<Update<OracleModel>, LiveModel>()
            .ForMember(des => des.ApprovedBy, opt => opt.Ignore())
            .ForMember(des => des.ApprovedDate, opt => opt.Ignore())
            ...
            .ForMember(des => des.UNSPSC, opt => opt.Ignore())
            .ForMember(des => des.BaseUnit, opt => opt.MapFrom(src => src.Model.UOM.BaseUOM.PerSalesUnit))
            .ForMember(des => des.BaseUOM, opt => opt.MapFrom(src => src.Model.UOM.BaseUOM.UnitOfMeasure.Code))
            .ForMember(des => des.SalesUnit, opt => opt.MapFrom(src => src.Model.UOM.SalesUOM.PerSalesUnit))
            .ForMember(des => des.SalesUOM, opt => opt.MapFrom(src => src.Model.UOM.SalesUOM.UnitOfMeasure.Code))
            .ForMember(des => des.OrderUnit, opt => opt.MapFrom(src => src.Model.UOM.OrderUOM.PerSalesUnit))
            .ForMember(des => des.OrderUOM, opt => opt.MapFrom(src => src.Model.UOM.OrderUOM.UnitOfMeasure.Code))
            .ForMember(des => des.SalesPrice, opt => opt.MapFrom(src => src.Model.Price.Value))
            .ForMember(des => des.Alternate, opt => opt.Ignore())
            .ForMember(des => des.ManufacturerID, opt => opt.Ignore())
            .ForMember(des => des.ProductCode, opt => opt.MapFrom(src => src.Model.ProductCode))
            .ForMember(des => des.ProductName, opt => opt.MapFrom(src => src.Model.ProductName))
            .ForMember(des => des.ProductHTML, opt => opt.Ignore())
            .ForMember(des => des.Version, opt => opt.Ignore())
            ...
            .ForMember(des => des.UnitsOfMeasure2, opt => opt.Ignore())
            .ForMember(des => des.Manufacturer, opt => opt.Ignore());

我已经解决了这个问题插入新的记录通过建立新的对象：

CreateMap<Insert<OracleModel>, LiveModel>()
            .ConstructUsing(x => new LiveModel
                {
                    BaseUnit = x.Model.UOM.BaseUOM.PerSalesUnit,
                    BaseUOM = x.Model.UOM.BaseUOM.UnitOfMeasure.Code,
                    SalesUnit = x.Model.UOM.SalesUOM.PerSalesUnit,
                    SalesUOM = x.Model.UOM.SalesUOM.UnitOfMeasure.Code,
                    OrderUnit = x.Model.UOM.OrderUOM.PerSalesUnit,
                    OrderUOM = x.Model.UOM.OrderUOM.UnitOfMeasure.Code,
                    SalesPrice = x.Model.Price.Value,
                    LeadTime = x.Model.LeadTime,
                    ProductCode = x.Model.ProductCode,
                    ProductName = x.Model.ProductName,
                    SupplierCode = x.Model.SupplierCode,
                    Weight = x.Model.Weight
                })
            .ForAllMembers(xc => xc.Ignore());

但是它不工作的更新，我想地图的特性，现有的对象并不是新的实例：

        Mapper.Map(update, existingRecord);

我宁愿避免DynamicMap()保持完全控制映射(所以我不会的地图的一个随机性的错误).我的目标是整理出来的循环的复杂性问题。请不要建议ValueInjecter或任何其他方法。我在寻找解决方案内AutoMapper.

Answer 1

这是五年以后，但这里有一个建议，以减少这映复杂的问题。你可以创建一个扩展，将帮助你忽略你所有成员在第一:

public static class AutoMapperExtension {
    public static IMappingExpression<TSource, TDest> IgnoreAllMembers<TSource, TDest>(this IMappingExpression<TSource, TDest> expression) {
        expression.ForAllMembers(opt => opt.Ignore());
        return expression;
    }
}

然后你用它来限定只能的映射你想要的执行：

Mapper.CreateMap<Insert<OracleModel>, LiveModel>()
      .IgnoreAllMembers()
      .ForMember(d => d.BaseUnit, o => o.MapFrom(s => s.Model.UOM.BaseUOM.PerSalesUnit))
      /* Mapping for other members here. */;