如何使用泛型类型配置 AutoMapper

Question

我正在尝试在我的实体中实现属性版本跟踪。使用TrackedProperty 的架构作为我的可跟踪属性；

public class PropertyVersion<TValue, TVersion>
{
    public TVersion Version { get; set; }
    public TValue Value { get; set; }
}


public class TrackedProperty<TValue, TVersion> : List<PropertyVersion<TValue, TVersion>>
{

}

例如，在我的存储库中，我将保留TrackedFoo 对象，并且我将能够从Foo 中检索特定版本的数据（在这种情况下，该版本被描述为时间对象）。

public class TrackedFoo
{
    public string Id { get; set; }
    public TrackedProperty<string, DateTime> Name { get; set; }
}

public class Foo
{
    public string Id { get; set; }
    public string Name { get; set; }
}

我希望尽可能保持通用性。所以我尝试使用 AutoMapper，但我无法以通用方式配置它，我不需要配置每个 TrackedTypeX 到 TypeX 的映射。

我需要获取 TrackedProperty 中的最后一个 PropertyVersion 项并将其 Value 属性映射到 TValue 类型

你能帮我找到解决这个问题的方法吗？

我可以使用

减少变量类型的数量（这就是你所说的 之间的东西吗？，无论如何）

DateTrackedProperty<TValue> : TrackedProperty<TValue,DateTime>
IntegerTrackedProperty<TValue> : TrackedProperty<TValue, int>
StringTrackedProperty<TValue> : TrackedProperty<TValue, string>

我可以为这三种类型编写 AutoMapper 配置。

Answer 1

最后我设法创建了一个通用映射配置文件（只有一种方式） 通过将以下内容放在我的 MappingProfile 中

CreateMap(typeof(PropertyVersion<,>), typeof(object)).ConvertUsing(typeof(PropertyVersionToValueConverter<,>));
CreateMap(typeof(TrackedProperty<,>), typeof(PropertyVersion<,>)).ConvertUsing(typeof(TrackedPropertyToPropertyVersionConverter<,>));
CreateMap(typeof(TrackedProperty<,>), typeof(object)).ConvertUsing(typeof(TrackedPropertyToValueConverter<,>));

在哪里

public class PropertyVersionToValueConverter<TValue, TVersion> : ITypeConverter<PropertyVersion<TValue, TVersion>, TValue>
{
    public TValue Convert(PropertyVersion<TValue, TVersion> source, TValue destination, ResolutionContext context)
    {
        if (source != null)
            return source.Value;
        return default(TValue);
    }
}

public class TrackedPropertyToPropertyVersionConverter<TValue, TVersion> : ITypeConverter<TrackedProperty<TValue, TVersion>, PropertyVersion<TValue, TVersion>>
{
    public PropertyVersion<TValue, TVersion> Convert(TrackedProperty<TValue, TVersion> source, PropertyVersion<TValue, TVersion> destination, ResolutionContext context)
    {
        if (source != null && source.Count > 0)
            return source.Last();

        else return default(PropertyVersion<TValue, TVersion>);
    }
}

public class TrackedPropertyToValueConverter<TValue, TVersion> : ITypeConverter<TrackedProperty<TValue, TVersion>, TValue>
{
    public TValue Convert(TrackedProperty<TValue, TVersion> source, TValue destination, ResolutionContext context)
    {
        var vers = context.Mapper.Map(source, typeof(TrackedProperty<TValue, TVersion>), typeof(PropertyVersion<TValue,TVersion>));
        return (TValue)context.Mapper.Map(vers, typeof(PropertyVersion<TValue, TVersion>), typeof(TValue));
    }
}

第一行映射提取 PropertyVersion.Value。

第二个映射行假定我只需要 TrackedProperty 中的最后一个版本并提取该版本。

第三行将所有内容组合在一起。

我可能可以将所有内容合二为一，并拥有一个 CreateMap 线和一个 Converter，但这很简单。

Answer 2

当您尝试将Foo 映射到TrackedFoo 时，由于它们具有相同的属性名称，起初一切都会好起来的。当 AutoMapper 尝试将您的 Foo 的属性 Name (string) 转换为您的 TrackedFoo 的属性 Name (TrackedProperty<string,DateTime>) 时，就会出现问题。

由于 AutoMapper 不知道如何在 string 和 TrackedProperty<,> 之间进行自然转换，所以它会失败。

不过，您可以教 AutoMapper 如何在这些类型之间进行转换。为此，您需要一个Custom Type Converter：

public class TrackedPropertyConverter<TValue, TVersion> : ITypeConverter<TrackedProperty<TValue, TVersion>, TValue>
{
    public TValue Convert(TrackedProperty<TValue, TVersion> source, TValue destination, ResolutionContext context)
    {
        return source.First().Value;
    }
}

然后你像这样配置它：

  Mapper.Initialize(
            cfg =>
            {
                cfg.CreateMap<TrackedFoo, Foo>();

                cfg.CreateMap<TrackedProperty<string, DateTime>, string>().ConvertUsing<TrackedPropertyConverter<string,DateTime>>();
                cfg.CreateMap<TrackedProperty<int, DateTime>, int>().ConvertUsing<TrackedPropertyConverter<int, DateTime>>();
                cfg.CreateMap<TrackedProperty<double, DateTime>, double>().ConvertUsing<TrackedPropertyConverter<double, DateTime>>();
            }
        );

Mapper.AssertConfigurationIsValid();

这是一个示例用法：

var tracked = new TrackedFoo
{
    Id = "SomeGuid",
    Name = new TrackedProperty<string, DateTime> {
        new PropertyVersion<string, DateTime> { Value = "FooBar", Version = new DateTime(2017, 2, 28) }
    },
    Value = new TrackedProperty<int, DateTime> {
        new PropertyVersion<int, DateTime> { Value = 456, Version = new DateTime(2017, 2, 28) }
    }
};

var foo = Mapper.Map<Foo>(tracked);

Console.WriteLine("Id: {0} | Name: {1} | Value: {2}", foo.Id, foo.Name, foo.Value);
Console.ReadLine();

这是一种教 AutoMapper 如何在类型之间进行转换的通用方法，无论这些类型的对象被转换（例如 Foo 到 TrackedFoo / Bar 到 TrackedBar / Person 到 TrackedPerson）。

您必须明确配置每种类型（字符串、整数、双精度），就像他们页面中的示例一样，但您只需执行一次，您不必为所有可能的类都执行此操作使用跟踪属性。

此外，您的存储库负责将版本值作为参数（如 DateTime），并使用您要求该版本的单个值获取 TrackedProperty，因为您不能为同一个版本。

Answer 3

自动映射器的整个想法是在彼此之间映射特定对象。 当我们使用泛型时，我们创建了一个辅助函数：

public static class AutoMaps
{
    public static void Initialize()
    {
        Mapper.Initialize(cfg =>
        {
            CreateGenericMapping<CatModel>(cfg);
        });
    }
    public static void CreateCatMapping<TCatType>(IMapperConfigurationExpression cfg)
    {
        cfg.CreateMap<TCatType, Cat>();
        cfg.CreateMap<Cat, TCatType>();
    }
}