为什么每次引用源集合时 Automapper 都会将具体集合映射到新实例？

Question

我有一个源对象，其中包含对同一集合的 2 个引用。如果我将源类型映射到结构等效的目标类型，AutoMapper 将在目标实例中创建集合的两个实例。

class SourceThing
{
    public string Name { get; set; }
    public List<int> Numbers { get; set; }
    public List<int> MoreNumbers { get; set; }
}

class TargetThing
{
    public string Name { get; set; }
    public List<int> Numbers { get; set; }
    public List<int> MoreNumbers { get; set; }
}

如果我创建一个SourceThing，它有两个对同一个列表的引用，将它映射到一个TargetThing，结果是一个TargetThing，它有两个单独的集合实例。

public void MapObjectWithTwoReferencesToSameList()
{
    Mapper.CreateMap<SourceThing, TargetThing>();
    //Mapper.CreateMap<List<int>, List<int>>(); // passes when mapping here

    var source = new SourceThing() { Name = "source" };
    source.Numbers = new List<int>() { 1, 2, 3 };
    source.MoreNumbers = source.Numbers;
    Assert.AreSame(source.Numbers, source.MoreNumbers);

    var target = Mapper.Map<TargetThing>(source);
    Assert.IsNotNull(target.Numbers);
    Assert.AreSame(target.Numbers, target.MoreNumbers); // fails
}

这是否意味着 AutoMapper 中具体集合的默认映射行为？通过测试，我意识到如果我将List<int>映射到List<int>，我实现了我想要的行为，但我不明白为什么。如果 AutoMapper 跟踪引用并且不重新映射映射对象，它不会看到 source.MoreNumbers 指向与 source.Numbers 相同的列表，并相应地设置目标吗？

Answer 1

我做了更多的研究和修补。在内部，当映射引擎遍历对象图时，它会为每个源类型/目标类型选择最佳映射器。除非存在非标准映射（过于简化），否则引擎接下来将为源和目标类型查找已注册的映射器。如果找到一个，它会创建目标对象，然后遍历并映射所有属性。它还将目标对象放入ResolutionContext.InstanceCache，即Dictionary<ResolutionContext, object>。如果在同一个根映射调用中再次遇到相同的源对象，它将从缓存中拉取对象，而不是浪费时间重新映射。

但是，如果没有注册的映射器，引擎会选择下一个适用的映射器，在这种情况下是AutoMapper.Mappers.CollectionMapper。集合映射器创建一个目标集合，枚举源集合并映射每个元素。它不将目标对象添加到缓存中。这显然是设计。

解析上下文

我发现真正有趣的是对象是如何缓存在 InstanceCache 中的。键是当前的 ResolutionContext，它包含源和目标类型以及源值。 ResolutionContext 覆盖 GetHashCode() 和 Equals()，它们使用底层源值的相同方法。我可以在自定义类上定义相等性，以便具有该类的多个相等但不同的实例的源集合映射到具有对同一实例的多个引用的集合。

这个类：

class EquatableThing 
{
    public string Name { get; set; }

    public override bool Equals(object other)
    {
        if (ReferenceEquals(this, other)) return true;
        if (ReferenceEquals(null, other)) return false;

        return this.Name == ((EquatableThing)other).Name;
    }

    public override int GetHashCode()
    {
        return Name.GetHashCode();
    }
}

用 2 个相等（但分开）的东西映射一个集合，结果是一个包含 2 个指向同一东西的指针的集合！

    public void MapCollectionWithTwoEqualItems()
    {
        Mapper.CreateMap<EquatableThing, EquatableThing>();

        var thing1 = new EquatableThing() { Name = "foo"};
        var thing2 = new EquatableThing() { Name = "foo"};

        Assert.AreEqual(thing1, thing2);
        Assert.AreEqual(thing1.GetHashCode(), thing2.GetHashCode());
        Assert.AreNotSame(thing1, thing2);

        // create list and map this thing across
        var list = new List<EquatableThing>() { thing1, thing2};
        var result = Mapper.Map<List<EquatableThing>, List<EquatableThing>>(list);
        Assert.AreSame(result[0], result[1]);
    }

保留引用

一方面，我想知道为什么 AutoMapper 的默认行为不会尽可能地将对象图映射到目标结构。 N 个源对象产生 N 个目标对象。但既然它没有，我很想看到 Map 方法上的一个选项来 PreserveReferences 就像序列化程序一样。如果选择了该选项，则映射的每个引用都使用引用相等比较器和源对象作为键并将目标作为值放置在字典中。本质上，如果某些东西已经被映射，则使用该映射的结果对象。

Answer 2

这种行为没有任何问题，这只是 automapper 映射的方式。

在顶部，您创建了一个数字列表，然后将其应用于第二个数字列表。然后您可以比较它们是相同的，因为该对象有 2 个指向同一个列表的指针。它没有复制数字，它只是做了一个新的参考，就像你问的那样。

现在，转到自动映射器。它贯穿并从一个对象映射到等效对象。它分别映射每个属性，复制信息。因此，即使源有更多数字作为指向同一个列表的指针，自动映射器也会单独映射每个。为什么？它是映射属性，而不是检查属性指针。而且，在大多数情况下，您不希望它这样做。

这有意义吗？

如果最终目标是通过测试，那么问题不是“做数字和更多数字指向同一个对象”，而是“做数字和更多数字包含完全相同的列表”。在第一种情况下，两者的答案都是肯定的，因为数字和更多数字都有一个对象（列表）。在第二种情况下，答案是假的，然后是真的，因为列表是等价的，但它并不指向同一个确切的对象。

如果您真的希望它是同一个对象，您将不得不以不同的方式玩游戏。如果您只是想知道列表是否具有相同的元素，请更改断言。