C# 如果遇到多次，则使automapper缓存对象

有没有办法让automapper在层次结构中多次遇到同一个对象时，不要克隆同一个对象，而是使用单个对象

基本上，我有一个不同对象的大数组，它们都引用同一个对象。当我用AutoMapper映射这个集合时，它会生成一个对象数组，其中每个对象引用一个新的克隆对象。所有这些克隆对象在引用方面不再相等。这对我来说是一个内存不足的问题

有没有办法为AutoMapper配置某种缓存

我在AutoMapper配置中尝试了

.PreserveReferences（）

，但没有达到我的目的。我认为这只适用于循环引用

更新。

代码示例I使用测试.preserverences（）

        [TestMethod]
        public void TestMethod1()
        {
            Mapper.Initialize(cfg =>
            {
                cfg.CreateMap<A, MA>().PreserveReferences();
                cfg.CreateMap<B, MB>();
            });

            var b = new B();
            var a1 = new A() { Ref = b };
            var a2 = new A() { Ref = b };
            Assert.AreNotSame(a1, a2);
            Assert.AreSame(a1.Ref, a2.Ref);

            var ma1 = Mapper.Map<MA>(a1);
            var ma2 = Mapper.Map<MA>(a2);
            Assert.AreNotSame(ma1, ma2);
            Assert.AreSame(ma1.Ref, ma2.Ref); // This fails.
        }

        class A { public B Ref { get; set; } }
        class B { }

        class MA { public MB Ref { get; set; } }
        class MB { }

[TestMethod]
公共void TestMethod1（）
{
Mapper.Initialize（cfg=>
{
CreateMap（）.PreserveReferences（）；
CreateMap（）；
});
var b=新的b（）；
var a1=新的A（）{Ref=b}；
var a2=新的A（）{Ref=b}；
断言不相同（a1，a2）；
Assert.AreName（a1.Ref，a2.Ref）；
var ma1=Mapper.Map（a1）；
var ma2=映射器映射（a2）；
arest.AreNotSame（ma1，ma2）；
Assert.arame（ma1.Ref，ma2.Ref）；//此操作失败。
}
类A{public B Ref{get；set；}}
B类{}
类MA{public MB Ref{get；set；}
类MB{}

每次地图调用都会保留标识

void Main()
{
    Mapper.Initialize(cfg =>
    {
        cfg.CreateMap<A, MA>().PreserveReferences();
        cfg.CreateMap<B, MB>().PreserveReferences();
    });

    var b = new B();
    var a1 = new A() { Ref = b };
    var a2 = new A() { Ref = b };

    var ma = Mapper.Map<MA[]>(new[]{a1, a2});
    (ma[0] == ma[1]).Dump();
    (ma[0].Ref == ma[1].Ref).Dump();
}

class A { public B Ref { get; set; } }
class B { }

class MA { public MB Ref { get; set; } }
class MB { }

void Main（）
{
Mapper.Initialize（cfg=>
{
CreateMap（）.PreserveReferences（）；
CreateMap（）.PreserveReferences（）；
});
var b=新的b（）；
var a1=新的A（）{Ref=b}；
var a2=新的A（）{Ref=b}；
var ma=Mapper.Map（新[]{a1，a2}）；
（ma[0]==ma[1]）.Dump（）；
（ma[0].Ref==ma[1].Ref）.Dump（）；
}
类A{public B Ref{get；set；}}
B类{}
类MA{public MB Ref{get；set；}
类MB{}

关于保留引用，即循环引用，您是对的。关于你的问题，在你开始映射之前，对你的集合执行一个不同的操作不是更容易（也更有效）吗？@hbulens这不会有帮助。在开始之前，我有一个对象数组

[A、B、C、D..

]，它们都引用同一个对象

X

。当我用AutoMapper映射这个集合时，我收到一个对象数组

[MA，MB，MC，MD..]

，但现在它们将每个对象指向相应的

[XA，XB，XC，XD…]

。我也不想在这里做太多的手工工作——使用AutoMapper背后的想法是简化事情。否则我根本不需要AutoMapper。保留引用应该有效。@LucianBargaoanu请查看updateWow！我完全没注意到这一点。谢谢，很好用