C# 将项目添加到新集合，而不是替换整个集合

我正在使用Automapper，我想知道是否可以将源上集合中的所有项添加到目标

考虑以下几点：

public class A { public IDictionary<int, string> myDictionary = new Dictionary<int, string>(); }

public class B { public IDictionary<int, string> myDictionary = new Dictionary<int, string>(); }

但是有没有可能告诉Automapper这样做（可能是使用某个自定义转换器…）：

---

这似乎对我有用

Mapper.CreateMap<A, B>()
     .ForMember(d => d.myDictionary, opt => opt.ResolveUsing(
                s => s.myDictionary.ToDictionary(pair => pair.Key, pair => pair.Value)));

Mapper.CreateMap（）
.ForMember（d=>d.myDictionary，opt=>opt.ResolveUsing(
s=>s.myDictionary.ToDictionary（pair=>pair.Key，pair=>pair.Value））；

这是完整的样品

public class A { public IDictionary<int, string> myDictionary = new Dictionary<int, string>(); }
public class B { public IDictionary<int, string> myDictionary = new Dictionary<int, string>(); }

class Program
{
    static void Main(string[] args)
    {
        var instanceOfA = new A
                              {
                                  myDictionary = new Dictionary<int, string>
                                                     {
                                                         {1, "a"},
                                                         {2, "b"}
                                                     }
                              };
        Mapper.CreateMap<A, B>()
            .ForMember(d => d.myDictionary, opt => opt.ResolveUsing(
              s => s.myDictionary.ToDictionary(pair => pair.Key, pair => pair.Value)));
        var instanceOfB = Mapper.Map<A, B>(instanceOfA);
        instanceOfA.myDictionary[1] = "c";

        if (instanceOfB.myDictionary[1] == "c")
            Console.WriteLine("Failed");
        else
            Console.WriteLine("Succeeded");
        Console.ReadLine();
    }
}

public class A{public IDictionary myDictionary=new Dictionary（）；}
公共类B{public IDictionary myDictionary=new Dictionary（）；}
班级计划
{
静态void Main（字符串[]参数）
{
var instanceOfA=新的
{
myDictionary=新字典
{
{1，“a”}，
{2，“b”}
}
};
Mapper.CreateMap（）
.ForMember（d=>d.myDictionary，opt=>opt.ResolveUsing(
s=>s.myDictionary.ToDictionary（pair=>pair.Key，pair=>pair.Value））；
var instanceOfB=Mapper.Map（instanceOfA）；
instanceOfA.myDictionary[1]=“c”；
如果（instanceOfB.myDictionary[1]=“c”）
控制台写入线（“失败”）；
其他的
控制台。写入线（“成功”）；
Console.ReadLine（）；
}
}

评论后编辑： *重新编辑*

Mapper.CreateMap（）
.ForMember（d=>d.myDictionary，opt=>opt.Ignore（））
.AfterMap（（s，d）=>
{
d、 myDictionary.Clear（）；
s、 myDictionary.ToList（）.ForEach（p=>d.myDictionary.Add（p））；
});

这似乎对我有用

Mapper.CreateMap<A, B>()
     .ForMember(d => d.myDictionary, opt => opt.ResolveUsing(
                s => s.myDictionary.ToDictionary(pair => pair.Key, pair => pair.Value)));

Mapper.CreateMap（）
.ForMember（d=>d.myDictionary，opt=>opt.ResolveUsing(
s=>s.myDictionary.ToDictionary（pair=>pair.Key，pair=>pair.Value））；

这是完整的样品

public class A { public IDictionary<int, string> myDictionary = new Dictionary<int, string>(); }
public class B { public IDictionary<int, string> myDictionary = new Dictionary<int, string>(); }

class Program
{
    static void Main(string[] args)
    {
        var instanceOfA = new A
                              {
                                  myDictionary = new Dictionary<int, string>
                                                     {
                                                         {1, "a"},
                                                         {2, "b"}
                                                     }
                              };
        Mapper.CreateMap<A, B>()
            .ForMember(d => d.myDictionary, opt => opt.ResolveUsing(
              s => s.myDictionary.ToDictionary(pair => pair.Key, pair => pair.Value)));
        var instanceOfB = Mapper.Map<A, B>(instanceOfA);
        instanceOfA.myDictionary[1] = "c";

        if (instanceOfB.myDictionary[1] == "c")
            Console.WriteLine("Failed");
        else
            Console.WriteLine("Succeeded");
        Console.ReadLine();
    }
}

public class A{public IDictionary myDictionary=new Dictionary（）；}
公共类B{public IDictionary myDictionary=new Dictionary（）；}
班级计划
{
静态void Main（字符串[]参数）
{
var instanceOfA=新的
{
myDictionary=新字典
{
{1，“a”}，
{2，“b”}
}
};
Mapper.CreateMap（）
.ForMember（d=>d.myDictionary，opt=>opt.ResolveUsing(
s=>s.myDictionary.ToDictionary（pair=>pair.Key，pair=>pair.Value））；
var instanceOfB=Mapper.Map（instanceOfA）；
instanceOfA.myDictionary[1]=“c”；
如果（instanceOfB.myDictionary[1]=“c”）
控制台写入线（“失败”）；
其他的
控制台。写入线（“成功”）；
Console.ReadLine（）；
}
}

评论后编辑： *重新编辑*

Mapper.CreateMap（）
.ForMember（d=>d.myDictionary，opt=>opt.Ignore（））
.AfterMap（（s，d）=>
{
d、 myDictionary.Clear（）；
s、 myDictionary.ToList（）.ForEach（p=>d.myDictionary.Add（p））；
});

Hi boca，谢谢你的回复，但这并没有起到作用。我正在将DTO对象映射到NHibernate中的域对象。AutoMapper不仅更改集合中的项，还更改集合本身。如果我忽略映射中的集合，并手动（使用foreach I.e.）将项从一个对象添加/删除到另一个对象，则效果很好。我只是想知道你是否能在Automapper内做到这一点，但我猜这是不可能做到的：-（我不确定我是否遵循了。在我的回答中，我能够映射创建新项的集合。我不明白为什么这对DTO和Nhibernate实体不起作用。您可以像上面一样使用ResolveUsing进行映射，也可以像您所说的那样忽略它，并使用AfterMap子句进行映射更正，但在示例中是我的cla字典的哈希代码。）SSB已经被Automapper更改，因为它总是返回一个新字典（我已经检查了源代码；-））。因此，NHibernate不会保存域对象，因为它会看到原始词典已更改。我已通过创建一个助手方法来解决此问题，该方法以自动映射开始，然后通过反射复制项。我现在看到了此问题。我知道您已经解决了此问题，但这是我的最终建议（我还将其添加到了答案中）Mapper.CreateMap（）.FormMember（d=>d.myDictionary，opt=>opt.Ignore（））.AfterMap（（s，d）=>s.myDictionary.ToList（）.ForEach（p=>d.myDictionary.Add（p）））；你好，博卡，谢谢你的帮助！你必须在之前清除目标词典，但你给了我我需要的想法！Mapper.CreateMap（）.ForMember（d=>d.myDictionary，opt=>opt.Ignore（））.AfterMap（（s，d）=>d.myDictionary.clear（））.AfterMap（（s，d=>s.myDictionary.ToList（）.ForEach（p=>d.myDictionary.Add（p）））；你好，博卡，谢谢你的回复，但这并没有起到作用。我正在从NHibernate将DTO对象映射到域对象。自动映射器不仅会更改集合中的项，还会更改集合本身。如果我在映射中忽略集合，并手动将项从一个对象添加/删除到另一个对象（使用foreach I.e.）它工作得很好。我只是想知道你是否可以在Automapper内完成这项工作，但我猜这是不可能的：-（我不确定我是否遵循。在我的

Mapper.CreateMap<A, B>()
     .ForMember(d => d.myDictionary, opt => opt.ResolveUsing(
                s => s.myDictionary.ToDictionary(pair => pair.Key, pair => pair.Value)));

public class A { public IDictionary<int, string> myDictionary = new Dictionary<int, string>(); }
public class B { public IDictionary<int, string> myDictionary = new Dictionary<int, string>(); }

class Program
{
    static void Main(string[] args)
    {
        var instanceOfA = new A
                              {
                                  myDictionary = new Dictionary<int, string>
                                                     {
                                                         {1, "a"},
                                                         {2, "b"}
                                                     }
                              };
        Mapper.CreateMap<A, B>()
            .ForMember(d => d.myDictionary, opt => opt.ResolveUsing(
              s => s.myDictionary.ToDictionary(pair => pair.Key, pair => pair.Value)));
        var instanceOfB = Mapper.Map<A, B>(instanceOfA);
        instanceOfA.myDictionary[1] = "c";

        if (instanceOfB.myDictionary[1] == "c")
            Console.WriteLine("Failed");
        else
            Console.WriteLine("Succeeded");
        Console.ReadLine();
    }
}

Mapper.CreateMap<A, B>()
   .ForMember(d => d.myDictionary, opt => opt.Ignore())
   .AfterMap((s, d) =>
                      {
                       d.myDictionary.Clear();
                       s.myDictionary.ToList().ForEach(p => d.myDictionary.Add(p));
                   });