Question

使用以下示例（LinqPad）：

void Main()
{

    var config = new MapperConfiguration(cfg =>
    {
        cfg.CreateMap<Source, DestinationNested>()
            .ConstructUsing((source, context) => new DestinationNested(source.InnerValue));

        cfg.CreateMap<Source, DestinationOuter>()
            .ForMember(x => x.OuterValue, y => y.MapFrom(z => z.OuterValue))
            .ConstructUsing((source, context) =>
            {
                return new DestinationOuter(source.OuterValue, context.Mapper.Map<DestinationNested>(source));
            });

    });

    var src = new Source { OuterValue = 999, InnerValue = 111 };

    var mapper = config.CreateMapper();
    var mapped = mapper.Map<DestinationOuter>(src);

    mapped.Dump();

    mapper.ConfigurationProvider.AssertConfigurationIsValid();
}

public class Source
{
    public int OuterValue { get; set; }
    public int InnerValue { get; set; }
}

public class DestinationOuter
{
    public int OuterValue { get; private set; }
    public DestinationNested destinationNested { get; private set; }

    public DestinationOuter(int outerValue, DestinationNested destinationNested)
    {
        this.OuterValue = outerValue;
        this.destinationNested = destinationNested;
    }
}

public class DestinationNested
{
    public int NestedValue { get; private set; }

    public DestinationNested(int nestedValue)
    {
        this.NestedValue = nestedValue;
    }
}

AssertConfigurationIsValid（）当前在我使用ContructUsing时引发有关属性的异常。

在实践中，它确实可以正确映射，但是我希望AssertConfigurationIsValid作为我的测试套件的一部分，以查找回归（无需对映射器进行手动测试）。

我想确保我的所有属性都通过构造器从映射到目标。我希望使用构造器，因为它是我的域层，并且构造器强制执行必填项。

我不希望通过IgnoreAllPropertiesWithAnInaccessibleSetter（）功能忽略所有私有设置器，因为我可能会忽略实际上尚未设置的某些东西。

理想情况下，我也不需要对构造函数中出现的每个属性进行手动Ignore（）操作，因为这会导致代码漂移。

我已经尝试过在Automapper中进行各种组合，但到目前为止还没有运气。

我认为这是一个静态分析挑战；我想知道我的构造函数涵盖了目标中的所有属性。我想知道，构造函数正在从源头传递所有内容。

我意识到Automapper在这一点上并没有实现很多自动化，是否有一种很好的方法可以依靠automapper进行此测试，或者这是一个静态分析问题？

Answer 1

这是我的主意。

static void Main(string[] args)
{
    try{
    var mapperCfg = new AutoMapper.MapperConfiguration(cfg =>
    {
        cfg.CreateMap<Source, DestinationOuter>().ForCtorParam("destinationNested", o => o.MapFrom(s => new DestinationNested(s.InnerValue)));
    });
    mapperCfg.AssertConfigurationIsValid();
    var mapper = mapperCfg.CreateMapper();

    var src = new Source { OuterValue = 999, InnerValue = 111 };
    mapper.Map<DestinationOuter>(src).Dump();
    }catch(Exception ex){
        ex.ToString().Dump();
    }
}
public class Source
{
    public int OuterValue { get; set; }
    public int InnerValue { get; set; }
}
public class DestinationOuter
{
    public int OuterValue { get; }
    public DestinationNested DestinationNested { get; }

    public DestinationOuter(int outerValue, DestinationNested destinationNested)
    {
        this.OuterValue = outerValue;
        this.DestinationNested = destinationNested;
    }
}
public class DestinationNested
{
    public int NestedValue { get; private set; }

    public DestinationNested(int nestedValue)
    {
        this.NestedValue = nestedValue;
    }
}

Answer 2

在阅读了大量文档之后，逐步完成调试器的集成测试以及几天的常规测试，这是我最好的：

var config = new MapperConfiguration(cfg =>
    {
        cfg.CreateMap<Source, DestinationNested>()
            .ForCtorParam("nestedValue", x => x.MapFrom(y => y.InnerValue))
            .ForMember(x => x.NestedValue, x => x.MapFrom(y => y.InnerValue));

        cfg.CreateMap<Source, DestinationOuter>()
            .ForPath(x => x.destinationNested.NestedValue, x => x.MapFrom(y => y.InnerValue))
            .ForCtorParam("destinationNested", x => x.MapFrom(y => y));
    });

我对此很满意；它消除了ContructUsing（）的气味，在我更广泛的代码库中，该气味正在构造嵌套对象。如果我的目标对象未填充，这会警告我。理想情况下，构造函数的param字符串将是类型安全的，但我知道为什么不能这样做（也许这是另一天有趣的Roslyn代码分析器项目的事情:-)）

x => x.MapFrom(y => y)与.ForPath(x => x.destinationNested.NestedValue, x => x.MapFrom(y => y.InnerValue))结合在一起（广为媒体关注）是秘密调味品，它似乎为AutoMapper提供了足够的提示，表明destinationNested与InnerValue有关，并且构造函数参数已重命名为“ destinationNested”。神奇的地方在于，看上去无辜的x.MapFrom(y => y)似乎不使用上下文来构造嵌套对象，而是让它使用属性映射*。

*这是我的外行解释，我还没有足够了解AutoMapper源代码，因此无法真正理解属性映射和构造函数映射之间的关系。阅读一些GitHub票证后，我认为它们是分开的概念。

我也没有看到文档中提到的x.MapFrom(y => y)，所以我有兴趣了解更多有关它的信息。

使用嵌套的ConstructUsing时使用AssertConfigurationIsValid（），而不会忽略私有设置器

2 个答案: