Question

假设您有此源模型：

public abstract class SourceModelBase {
}

public class SourceContact : SourceModelBase {
  public string FirstName { get; set; }
  public string LastName { get; set; }
  public KeyValuePair Pair { get; set; }
  public SourceAddress Address { get; set; }
}

public class KeyValuePair { // Not derived from SourceModelBase.
  public string Key { get; set; }
  public string Value { get; set; }
}

public class SourceAddress : SourceModelBase {
  public string StreetName { get; set; }
  public string StreetNumber { get; set; }
}

现在默认情况下，目标模型应该以1：1的方式映射（受普通AutoMapper配置限制），但是从SourceModelBase派生的每个东西都应该映射到包装类class Wrap<T> { T Payload { get; set; } string Meta { get; set; } }。

public abstract class DestinationModelBase {
}

public class DestinationContact : DestinationModelBase {
  public string FirstName { get; set; }
  public string LastName { get; set; }
  public KeyValuePair Pair { get; set; } // Not wrapped, base class not `SourceModelBase`.
  public Wrap<DestinationAddress> Address { get; set; }
}

public class DestinationAddress : DestinationModelBase {
  public string StreetName { get; set; }
  public string StreetNumber { get; set; }
}

由于联系类本身是从SourceModelBase派生的，因此它也应该被包装。

结果应具有以下结构：

Wrap<DestinationContact> Contact
  string Meta // Comes from the custom wrapper logic.
  DestinationContact Payload
    string FirstName
    string LastName
    KeyValuePair Pair
      string Key
      string Value
    Wrap<DestinationAddress> Address
      string Meta // Comes from the custom wrapper logic.
      DestinationAddress Payload
        string StreetName
        string StreetNumber

显然，这个包装应该嵌套，由映射对象本身受其约束，因此它的Address属性也是如此。

出于某种原因，我一直在寻找与从目的地到源的映射相关的问题。我知道我必须以某种方式使用ResolveUsing，如果目标类型派生自SourceModelBase，则以某种方式应用自定义逻辑以基于源属性的值提供Wrap<T>值。

但是，我不知道从哪里开始。特别是当源对象本身被指定为包装逻辑的主体时。

如果嵌套对象符合条件并同时包装原始对象（如果它满足相同条件），那么最好的，大多数AutoMapper惯用方法是什么？我已经有了抽象的绘图工具被抽象出来，所以我可以在将原始对象传递给映射器之前自动对其进行塑造，这可能有助于通过执行mapper.Map(new { Root = originalObject })对原始对象进行解析，因此解析器会看到原始对象的实例好像它也是源对象属性的值，而不是源对象本身。

Answer 1

根据AutoMapper GitHub页面上的this issue，没有直接的方法。
但是有一些解决方法。例如 - 反射。
在这种情况下，您需要知道包装器类型并实现所需类型的转换器。在此示例中，它是MapAndWrapConverter从TSource到Wrap<TDestination>的{{1}} CreateWrapMap方法创建两个绑定：
SourceAddress -> Wrap<DestinationAddress>和SourceContact -> Wrap<DestinationContact>允许您将SourceContant映射到已包裹的DestinationContact。

internal class Program
{
    public static void Main()
    {
        var config = new MapperConfiguration(cfg =>
        {
            cfg.CreateMap<SourceAddress, DestinationAddress>();
            cfg.CreateMap<SourceContact, DestinationContact>();

            cfg.CreateWrapMap(
                //func selecting types to wrap
                type => typeof(DestinationModelBase).IsAssignableFrom(type)
                        && !type.IsAbstract,
                typeof(Wrap<>),
                typeof(MapAndWrapConverter<,>));
        });

        var mapper = config.CreateMapper();

        //Using AutoFixture to create complex object
        var fixture = new Fixture();
        var srcObj = fixture.Create<SourceContact>();

        var dstObj = mapper.Map<Wrap<DestinationContact>>(srcObj);
    }
}

public static class AutoMapperEx
{
    public static IMapperConfigurationExpression CreateWrapMap(
        this IMapperConfigurationExpression cfg,
        Func<Type, bool> needWrap, Type wrapperGenericType,
        Type converterGenericType)
    {
        var mapperConfiguration = 
            new MapperConfiguration((MapperConfigurationExpression)cfg);
        var types = Assembly.GetExecutingAssembly().GetTypes();

        foreach (var dstType in types.Where(needWrap))
        {
            var srcType = mapperConfiguration.GetAllTypeMaps()
                .Single(map => map.DestinationType == dstType).SourceType;
            var wrapperDstType = wrapperGenericType.MakeGenericType(dstType);
            var converterType = converterGenericType.MakeGenericType(srcType, dstType);
            cfg.CreateMap(srcType, wrapperDstType)
                .ConvertUsing(converterType);
        }
        return cfg;
    }
}
public class MapAndWrapConverter<TSource, TDestination> 
    : ITypeConverter<TSource, Wrap<TDestination>>
{
    public Wrap<TDestination> Convert(
        TSource source, Wrap<TDestination> destination, ResolutionContext context)
    {
        return new Wrap<TDestination>
        {
            Payload = context.Mapper.Map<TDestination>(source)
        };
    }
}

CreateWrapMap方法有点乱，特别是找到匹配类型的部分。但它可以根据您的需求进行改进。

如何使用AutoMapper将某些源属性映射到包装的目标类型？

1 个答案: