AutoMapper 和 is*Specified 属性

Question

我有一堆 XSD.exe 生成的数据契约类，对于所有可选元素都有一对 C# 属性，例如

int Amount {get; set;}
bool isAmountSpecified {get; set;}

在映射舞台的另一侧，我有一个可以为 null 的 int，例如

int? Amount {get; set;}

理想情况下，我希望 AutoMapper 能够识别这样的模式，并且知道如何在两个方向映射事物，而无需我为每个单独的属性指定映射。这可能吗？

Answer 1

好的，昨天我和 AutoMapper 的作者 Jimmy Bogard 进行了简短的讨论，基本上我正在寻找的东西目前是不可能的。对此类约定的支持将在未来某个时候实现（如果我理解正确的话:)）。

Answer 2

老实说，我不知道 AutoMapper 是否会这样做（因为我不太使用 AutoMapper），但我知道 protobuf-net 支持这两种模式，因此您可以使用 Serializer.ChangeType<,>(obj) 在它们之间翻转。

然而，当前版本非常依赖于成员上的属性（例如 [XmlElement(Order = n)]） - 我不知道这是否会导致一个问题？ 进行中版本支持普通类型（没有属性），但尚未完成（但很快）。

例子：

[XmlType]
public class Foo
{
    [XmlElement(Order=1)]
    public int? Value { get; set; }
}
[XmlType]
public class Bar
{
    [XmlElement(Order = 1)]
    public int Value { get; set; }
    [XmlIgnore]
    public bool ValueSpecified { get; set; }
}
static class Program
{
    static void Main()
    {
        Foo foo = new Foo { Value = 123 };
        Bar bar = Serializer.ChangeType<Foo, Bar>(foo);
        Console.WriteLine("{0}, {1}", bar.Value, bar.ValueSpecified);

        foo = new Foo { Value = null };
        bar = Serializer.ChangeType<Foo, Bar>(foo);
        Console.WriteLine("{0}, {1}", bar.Value, bar.ValueSpecified);

        bar = new Bar { Value = 123, ValueSpecified = true };
        foo = Serializer.ChangeType<Bar, Foo>(bar);
        Console.WriteLine(foo.Value);

        bar = new Bar { Value = 123, ValueSpecified = false };
        foo = Serializer.ChangeType<Bar, Foo>(bar);
        Console.WriteLine(foo.Value);
    }
}

Answer 3

以下示例展示了如何将具有*指定属性（源）的模型映射到具有可为空属性（目标）的模型。
我已经为所有成员配置了 Condition 方法，它将检查源属性是否具有相应的 *Specified 属性，如果有，则它将检查其值。如果*指定属性返回false，则不满足条件并且将跳过映射。

您可以在其他方向执行相同的操作，但您必须设置它，而不是读取 *Specified 属性值。

public void Configure(IMapperConfigurationExpression cfg)
{
    cfg.CreateMap<Source, Destination>()
        .ForAllOtherMembers(opt => opt.PreCondition((srcObj, context) => IsSpecified(srcObj, context, opt)));
}

public static bool IsSpecified<TSource, TDestination, TMember>(TSource source, ResolutionContext context, IMemberConfigurationExpression<TSource, TDestination, TMember> opt)
{
    var dstMemberPropertyInfo = opt.DestinationMember as PropertyInfo;

    // if destination member not nullable, then assume that source member won't have *Specified property
    if (!IsNullableType(dstMemberPropertyInfo.PropertyType))
        return true;

    var config = context.Mapper.ConfigurationProvider;
    var map = config.FindTypeMapFor<TSource, TDestination>();
    var propertyMap = map.PropertyMaps.FirstOrDefault(x => x.DestinationMember.Name == opt.DestinationMember.Name);
    var sourceMembers = new Queue<MemberInfo>(propertyMap.SourceMembers);
    var srcParentType = typeof(TSource);
    var srcParentObj = source as object;

    // get the source parent instance
    while (sourceMembers.Count > 1) // the last item in queue is the SourceMember itself
    {
        var srcParentPropertyInfo = sourceMembers.Dequeue() as PropertyInfo;
        srcParentType = srcParentPropertyInfo.PropertyType;
        srcParentObj = srcParentPropertyInfo.GetValue(srcParentObj);

        // the source parent is not defined, so we can skip this mapping
        if (srcParentObj == null)
            return false;
    }

    var srcMemberSpecifiedPropName = propertyMap.SourceMember.Name + "Specified";
    var srcMemberSpecifiedProp = srcParentType.GetProperty(srcMemberSpecifiedPropName);

    // if there is no *Specified property, then assume value is specified
    return srcMemberSpecifiedProp == null || (bool)srcMemberSpecifiedProp.GetValue(srcParentObj);
}

private bool IsNullableType(Type type) => IsGenericType(type, typeof(Nullable<>));

private bool IsGenericType(Type type, Type genericType) => IsGenericType(type) && type.GetGenericTypeDefinition() == genericType;

private bool IsGenericType(Type type) => type.GetTypeInfo().IsGenericType;