Merging dictionaries in C

Question

What s the best way to merge 2 or more dictionaries  Dictionary lt T1 T2 gt   in C    3 0 features like LINQ are fine    I m thinking of a method signature along the lines of   public static Dictionary lt TKey TValue gt                   Merge lt TKey TValue gt  Dictionary lt TKey TValue gt    dictionaries     or  public static Dictionary lt TKey TValue gt                   Merge lt TKey TValue gt  IEnumerable lt Dictionary lt TKey TValue gt  gt  dictionaries     EDIT  Got a cool solution from JaredPar and Jon Skeet  but I was thinking of something that handles duplicate keys  In case of collision  it doesn t matter which value is saved to the dict as long as it s consistent

User · Answer

public static IDictionary lt K  V gt  AddRange lt K  V gt  this IDictionary lt K  V gt  one  IDictionary lt K  V gt  two                        foreach  var kvp in two                                if  one ContainsKey kvp Key                       one kvp Key    two kvp Key                   else                     one Add kvp Key  kvp Value                             return one

User · Answer

I know this is an old question  but since we now have LINQ you can do it in a single line like this  Dictionary lt T1 T2 gt  merged  Dictionary lt T1 T2 gt  mergee  mergee ToList   ForEach kvp   gt  merged Add kvp Key  kvp Value      or   mergee ToList   ForEach kvp   gt  merged Append kvp

User · Answer

Got scared to see complex answers  being new to C    Here are some simple answers  Merging d1  d2  and so on   dictionaries and handle any overlapping keys   b  in below examples    Example 1           2 dictionaries    b  key is common with different values      var d1   new Dictionary lt string  int gt         a   10       b   21          var d2   new Dictionary lt string  int gt         c   30       b   22           var result1   d1 Concat d2  GroupBy ele   gt  ele Key  ToDictionary ele   gt  ele Key  ele   gt  ele First   Value          result1 is  a 10  b 21  c 30    That is  took the  b  value of the first dictionary      var result2   d1 Concat d2  GroupBy ele   gt  ele Key  ToDictionary ele   gt  ele Key  ele   gt  ele Last   Value          result2 is  a 10  b 22  c 30    That is  took the  b  value of the last dictionary     Example 2           3 dictionaries    b  key is common with different values      var d1   new Dictionary lt string  int gt         a   10       b   21          var d2   new Dictionary lt string  int gt         c   30       b   22          var d3   new Dictionary lt string  int gt         d   40       b   23           var result1   d1 Concat d2  Concat d3  GroupBy ele   gt  ele Key  ToDictionary ele   gt  ele Key  ele   gt  ele First   Value          result1 is  a 10  b 21  c 30  d 40    That is  took the  b  value of the first dictionary      var result2   d1 Concat d2  Concat d3  GroupBy ele   gt  ele Key  ToDictionary ele   gt  ele Key  ele   gt  ele Last   Value          result2 is  a 10  b 23  c 30  d 40    That is  took the  b  value of the last dictionary     For more complex scenarios  see other answers  Hope that helped

User · Answer

How about adding a params overload   Also  you should type them as IDictionary for maximum flexibility   public static IDictionary lt TKey  TValue gt  Merge lt TKey  TValue gt  IEnumerable lt IDictionary lt TKey  TValue gt  gt  dictionaries                  public static IDictionary lt TKey  TValue gt  Merge lt TKey  TValue gt  params IDictionary lt TKey  TValue gt    dictionaries        return Merge  IEnumerable lt TKey  TValue gt   dictionaries

User · Answer

The trivial solution would be   using System Collections Generic      public static Dictionary lt TKey  TValue gt      Merge lt TKey TValue gt  IEnumerable lt Dictionary lt TKey  TValue gt  gt  dictionaries        var result   new Dictionary lt TKey  TValue gt         foreach  var dict in dictionaries          foreach  var x in dict              result x Key    x Value      return result

User · Answer

Here is a helper function I use   using System Collections Generic  namespace HelperMethods       public static class MergeDictionaries               public static void Merge lt TKey  TValue gt  this IDictionary lt TKey  TValue gt  first  IDictionary lt TKey  TValue gt  second                        if  second    null    first    null  return              foreach  var item in second                   if   first ContainsKey item Key                        first Add item Key  item Value

User · Answer

Considering the performance of dictionary key lookups and deletes since they are hash operations  and considering the wording of the question was best way  I think that below is a perfectly valid approach  and the others are a bit over-complicated  IMHO        public static void MergeOverwrite lt T1  T2 gt  this IDictionary lt T1  T2 gt  dictionary  IDictionary lt T1  T2 gt  newElements                if  newElements    null  return           foreach  var e in newElements                        dictionary Remove e Key     or if you don t want to overwrite do  if   Contains               dictionary Add e                     OR if you re working in a multithreaded application and your dictionary needs to be thread safe anyway  you should be doing this       public static void MergeOverwrite lt T1  T2 gt  this ConcurrentDictionary lt T1  T2 gt  dictionary  IDictionary lt T1  T2 gt  newElements                if  newElements    null    newElements Count    0  return           foreach  var ne in newElements                        dictionary AddOrUpdate ne Key  ne Value   key  value    gt  value                     You could then wrap this to make it handle an enumeration of dictionaries  Regardless  you re looking at about  O 3n   all conditions being perfect   since the  Add   will do an additional  unnecessary but practically free  Contains   behind the scenes  I don t think it gets much better   If you wanted to limit extra operations on large collections  you should sum up the Count of each dictionary you re about to merge and set the capacity of the the target dictionary to that  which avoids the later cost of resizing  So  end product is something like this         public static IDictionary lt T1  T2 gt  MergeAllOverwrite lt T1  T2 gt  IList lt IDictionary lt T1  T2 gt  gt  allDictionaries                var initSize   allDictionaries Sum d   gt  d Count           var resultDictionary   new Dictionary lt T1  T2 gt  initSize           allDictionaries ForEach resultDictionary MergeOverwrite           return resultDictionary          Note that I took in an IList lt T gt  to this method    mostly because if you take in an IEnumerable lt T gt   you ve opened yourself up to multiple enumerations of the same set  which can be very costly if you got your collection of dictionaries from a deferred LINQ statement

User · Answer

How about adding a params overload   Also  you should type them as IDictionary for maximum flexibility   public static IDictionary lt TKey  TValue gt  Merge lt TKey  TValue gt  IEnumerable lt IDictionary lt TKey  TValue gt  gt  dictionaries                  public static IDictionary lt TKey  TValue gt  Merge lt TKey  TValue gt  params IDictionary lt TKey  TValue gt    dictionaries        return Merge  IEnumerable lt TKey  TValue gt   dictionaries

User · Answer

Try the following  static Dictionary lt TKey  TValue gt      Merge lt TKey  TValue gt  this IEnumerable lt Dictionary lt TKey  TValue gt  gt  enumerable        return enumerable SelectMany x   gt  x  ToDictionary x   gt  x Key  y   gt  y Value

User · Answer

The trivial solution would be   using System Collections Generic      public static Dictionary lt TKey  TValue gt      Merge lt TKey TValue gt  IEnumerable lt Dictionary lt TKey  TValue gt  gt  dictionaries        var result   new Dictionary lt TKey  TValue gt         foreach  var dict in dictionaries          foreach  var x in dict              result x Key    x Value      return result

User · Answer

Dictionary lt String  String gt  allTables   new Dictionary lt String  String gt     allTables   tables1 Union tables2  ToDictionary pair   gt  pair Key  pair   gt  pair Value

User · Answer

Here is a helper function I use   using System Collections Generic  namespace HelperMethods       public static class MergeDictionaries               public static void Merge lt TKey  TValue gt  this IDictionary lt TKey  TValue gt  first  IDictionary lt TKey  TValue gt  second                        if  second    null    first    null  return              foreach  var item in second                   if   first ContainsKey item Key                        first Add item Key  item Value

User · Answer

The trivial solution would be   using System Collections Generic      public static Dictionary lt TKey  TValue gt      Merge lt TKey TValue gt  IEnumerable lt Dictionary lt TKey  TValue gt  gt  dictionaries        var result   new Dictionary lt TKey  TValue gt         foreach  var dict in dictionaries          foreach  var x in dict              result x Key    x Value      return result

User · Answer

I know this is an old question  but since we now have LINQ you can do it in a single line like this  Dictionary lt T1 T2 gt  merged  Dictionary lt T1 T2 gt  mergee  mergee ToList   ForEach kvp   gt  merged Add kvp Key  kvp Value      or   mergee ToList   ForEach kvp   gt  merged Append kvp

User · Answer

Note that if you use an extension method called  Add   you get to use collection initializers to combine as many dictionaries as needed like this   public static void Add lt K  V gt  this Dictionary lt K  V gt  d  Dictionary lt K  V gt  other      foreach  var kvp in other          if   d ContainsKey kvp Key               d Add kvp Key  kvp Value                 var s0   new Dictionary lt string  string gt         A    X      var s1   new Dictionary lt string  string gt         A    X          B    Y          Combine as many dictionaries and key pairs as needed var a   new Dictionary lt string  string gt      s0  s1  s0  s1  s1     C    Z

User · Answer

This doesn t explode if there are multiple keys   righter  keys replace  lefter  keys   can merge a number of dictionaries  if desired  and preserves the type  with the restriction that it requires a meaningful default public constructor    public static class DictionaryExtensions          Works in C 3 VS2008         Returns a new dictionary of this     others merged leftward         Keeps the type of  this   which must be default-instantiable         Example            result   map MergeLeft other1  other2           public static T MergeLeft lt T K V gt  this T me  params IDictionary lt K V gt    others          where T   IDictionary lt K V gt   new                 T newMap   new T            foreach  IDictionary lt K V gt  src in              new List lt IDictionary lt K V gt  gt    me    Concat others                     -- echk  Not quite there type-system              foreach  KeyValuePair lt K V gt  p in src                    newMap p Key    p Value                                  return newMap

User · Answer

Considering the performance of dictionary key lookups and deletes since they are hash operations  and considering the wording of the question was best way  I think that below is a perfectly valid approach  and the others are a bit over-complicated  IMHO        public static void MergeOverwrite lt T1  T2 gt  this IDictionary lt T1  T2 gt  dictionary  IDictionary lt T1  T2 gt  newElements                if  newElements    null  return           foreach  var e in newElements                        dictionary Remove e Key     or if you don t want to overwrite do  if   Contains               dictionary Add e                     OR if you re working in a multithreaded application and your dictionary needs to be thread safe anyway  you should be doing this       public static void MergeOverwrite lt T1  T2 gt  this ConcurrentDictionary lt T1  T2 gt  dictionary  IDictionary lt T1  T2 gt  newElements                if  newElements    null    newElements Count    0  return           foreach  var ne in newElements                        dictionary AddOrUpdate ne Key  ne Value   key  value    gt  value                     You could then wrap this to make it handle an enumeration of dictionaries  Regardless  you re looking at about  O 3n   all conditions being perfect   since the  Add   will do an additional  unnecessary but practically free  Contains   behind the scenes  I don t think it gets much better   If you wanted to limit extra operations on large collections  you should sum up the Count of each dictionary you re about to merge and set the capacity of the the target dictionary to that  which avoids the later cost of resizing  So  end product is something like this         public static IDictionary lt T1  T2 gt  MergeAllOverwrite lt T1  T2 gt  IList lt IDictionary lt T1  T2 gt  gt  allDictionaries                var initSize   allDictionaries Sum d   gt  d Count           var resultDictionary   new Dictionary lt T1  T2 gt  initSize           allDictionaries ForEach resultDictionary MergeOverwrite           return resultDictionary          Note that I took in an IList lt T gt  to this method    mostly because if you take in an IEnumerable lt T gt   you ve opened yourself up to multiple enumerations of the same set  which can be very costly if you got your collection of dictionaries from a deferred LINQ statement

User · Answer

Option 1   This depends on what you want to happen if you are sure that you don t have duplicate key in both dictionaries  than you could do   var result   dictionary1 Union dictionary2  ToDictionary k   gt  k Key  v   gt  v Value    Note   This will throw error if you get any duplicate keys in dictionaries   Option 2   If you can have duplicate key then you ll have to handle duplicate key with the using of where clause   var result   dictionary1 Union dictionary2 Where k   gt   dictionary1 ContainsKey k Key    ToDictionary k   gt  k Key  v   gt  v Value    Note   It will not get duplicate key  if there will be any duplicate key than it will get dictionary1 s key   Option 3   If you want to use ToLookup  then you will get a lookup which can have multiple values per key  You could convert that lookup  to a dictionary   var result   dictionaries SelectMany dict   gt  dict                            ToLookup pair   gt  pair Key  pair   gt  pair Value                            ToDictionary group   gt  group Key  group   gt  group First

User · Answer

using System Collections Generic  using System Linq   public static class DictionaryExtensions       public enum MergeKind   SkipDuplicates  OverwriteDuplicates       public static void Merge lt K  V gt  this IDictionary lt K  V gt  target  IDictionary lt K  V gt  source  MergeKind kind   MergeKind SkipDuplicates    gt          source ToList   ForEach     gt    if  kind    MergeKind OverwriteDuplicates     target ContainsKey   Key   target   Key      Value          You can either skip ignore  default  or overwrite the duplicates  And Bob s your uncle provided you are not overly fussy about Linq performance but prefer instead concise maintainable code as I do  in which case you can remove the default MergeKind SkipDuplicates to enforce a choice for the caller and make the developer cognisant of what the results will be

User · Answer

The party s pretty much dead now  but here s an  improved  version of user166390 that made its way into my extension library  Apart from some details  I added a delegate to calculate the merged value        lt summary gt      Merges a dictionary against an array of other dictionaries       lt  summary gt       lt typeparam name  TResult  gt The type of the resulting dictionary  lt  typeparam gt       lt typeparam name  TKey  gt The type of the key in the resulting dictionary  lt  typeparam gt       lt typeparam name  TValue  gt The type of the value in the resulting dictionary  lt  typeparam gt       lt param name  source  gt The source dictionary  lt  param gt       lt param name  mergeBehavior  gt A delegate returning the merged value   Parameters in order  The current key  The current value  The previous value  lt  param gt       lt param name  mergers  gt Dictionaries to merge against  lt  param gt       lt returns gt The merged dictionary  lt  returns gt  public static TResult MergeLeft lt TResult  TKey  TValue gt       this TResult source      Func lt TKey  TValue  TValue  TValue gt  mergeBehavior      params IDictionary lt TKey  TValue gt    mergers      where TResult   IDictionary lt TKey  TValue gt   new         var result   new TResult        var sources   new List lt IDictionary lt TKey  TValue gt  gt    source            Concat mergers        foreach  var kv in sources SelectMany src   gt  src                 TValue previousValue          result TryGetValue kv Key  out previousValue           result kv Key    mergeBehavior kv Key  kv Value  previousValue              return result

User · Answer

I would do it like this   dictionaryFrom ToList   ForEach x   gt  dictionaryTo Add x Key  x Value      Simple and easy  According to this blog post it s even faster than most loops as its underlying implementation accesses elements by index rather than enumerator  see this answer    It will of course throw an exception if there are duplicates  so you ll have to check before merging

User · Answer

The following works for me  If there are duplicates  it will use dictA s value   public static IDictionary lt TKey  TValue gt  Merge lt TKey  TValue gt  this IDictionary lt TKey  TValue gt  dictA  IDictionary lt TKey  TValue gt  dictB      where TValue   class       return dictA Keys Union dictB Keys  ToDictionary k   gt  k  k   gt  dictA ContainsKey k    dictA k    dictB k

User · Answer

Tim  Should be a comment  but comments don t allow for code editing   Dictionary lt string  string gt  t1   new Dictionary lt string  string gt     t1 Add  a    aaa    Dictionary lt string  string gt  t2   new Dictionary lt string  string gt     t2 Add  b    bee    Dictionary lt string  string gt  t3   new Dictionary lt string  string gt     t3 Add  c    cee    t3 Add  d    dee    t3 Add  b    bee    Dictionary lt string  string gt  merged   t1 MergeLeft t2  t2  t3     Note  I applied the modification by  ANeves to the solution by  Andrew Orsich  so the MergeLeft looks like this now   public static Dictionary lt K  V gt  MergeLeft lt K  V gt  this Dictionary lt K  V gt  me  params IDictionary lt K  V gt    others                var newMap   new Dictionary lt K  V gt  me  me Comparer           foreach  IDictionary lt K  V gt  src in              new List lt IDictionary lt K  V gt  gt    me    Concat others                             -- echk  Not quite there type-system              foreach  KeyValuePair lt K  V gt  p in src                                newMap p Key    p Value                                  return newMap

User · Answer

Simplified from use compared with my earlier answer with a bool default of non-destructive merge if existing or overwrite entirely if true rather than using an enum  It still suits my own needs without any fancier code ever being required   using System Collections Generic  using System Linq   public static partial class Extensions       public static void Merge lt K  V gt  this IDictionary lt K  V gt  target  IDictionary lt K  V gt  source  bool overwrite   false                source ToList   ForEach     gt                if    target ContainsKey   Key      overwrite                  target   Key      Value

User · Answer

This partly depends on what you want to happen if you run into duplicates  For instance  you could do   var result   dictionaries SelectMany dict   gt  dict                            ToDictionary pair   gt  pair Key  pair   gt  pair Value     That will throw an exception if you get any duplicate keys   EDIT  If you use ToLookup then you ll get a lookup which can have multiple values per key  You could then convert that to a dictionary   var result   dictionaries SelectMany dict   gt  dict                            ToLookup pair   gt  pair Key  pair   gt  pair Value                            ToDictionary group   gt  group Key  group   gt  group First       It s a bit ugly - and inefficient - but it s the quickest way to do it in terms of code   I haven t tested it  admittedly    You could write your own ToDictionary2 extension method of course  with a better name  but I don t have time to think of one now  - it s not terribly hard to do  just overwriting  or ignoring  duplicate keys  The important bit  to my mind  is using SelectMany  and realising that a dictionary supports iteration over its key value pairs

User · Answer

Got scared to see complex answers  being new to C    Here are some simple answers  Merging d1  d2  and so on   dictionaries and handle any overlapping keys   b  in below examples    Example 1           2 dictionaries    b  key is common with different values      var d1   new Dictionary lt string  int gt         a   10       b   21          var d2   new Dictionary lt string  int gt         c   30       b   22           var result1   d1 Concat d2  GroupBy ele   gt  ele Key  ToDictionary ele   gt  ele Key  ele   gt  ele First   Value          result1 is  a 10  b 21  c 30    That is  took the  b  value of the first dictionary      var result2   d1 Concat d2  GroupBy ele   gt  ele Key  ToDictionary ele   gt  ele Key  ele   gt  ele Last   Value          result2 is  a 10  b 22  c 30    That is  took the  b  value of the last dictionary     Example 2           3 dictionaries    b  key is common with different values      var d1   new Dictionary lt string  int gt         a   10       b   21          var d2   new Dictionary lt string  int gt         c   30       b   22          var d3   new Dictionary lt string  int gt         d   40       b   23           var result1   d1 Concat d2  Concat d3  GroupBy ele   gt  ele Key  ToDictionary ele   gt  ele Key  ele   gt  ele First   Value          result1 is  a 10  b 21  c 30  d 40    That is  took the  b  value of the first dictionary      var result2   d1 Concat d2  Concat d3  GroupBy ele   gt  ele Key  ToDictionary ele   gt  ele Key  ele   gt  ele Last   Value          result2 is  a 10  b 23  c 30  d 40    That is  took the  b  value of the last dictionary     For more complex scenarios  see other answers  Hope that helped

User · Answer

Simplified from use compared with my earlier answer with a bool default of non-destructive merge if existing or overwrite entirely if true rather than using an enum  It still suits my own needs without any fancier code ever being required   using System Collections Generic  using System Linq   public static partial class Extensions       public static void Merge lt K  V gt  this IDictionary lt K  V gt  target  IDictionary lt K  V gt  source  bool overwrite   false                source ToList   ForEach     gt                if    target ContainsKey   Key      overwrite                  target   Key      Value

User · Answer

Merging using an EqualityComparer that maps items for comparison to a different value type  Here we will map from KeyValuePair  item type when enumerating a dictionary  to Key   public class MappedEqualityComparer lt T U gt    EqualityComparer lt T gt        Func lt T U gt   map       public MappedEqualityComparer Func lt T U gt  map                 map   map             public override bool Equals T x  T y                return EqualityComparer lt U gt  Default Equals  map x    map y               public override int GetHashCode T obj                return  map obj  GetHashCode              Usage      if dictA and dictB are of type Dictionary lt int string gt  var dict   dictA Concat dictB                   Distinct new MappedEqualityComparer lt KeyValuePair lt int string gt  int gt  item   gt  item Key                    ToDictionary item   gt  item Key  item  gt  item Value

User · Answer

This partly depends on what you want to happen if you run into duplicates  For instance  you could do   var result   dictionaries SelectMany dict   gt  dict                            ToDictionary pair   gt  pair Key  pair   gt  pair Value     That will throw an exception if you get any duplicate keys   EDIT  If you use ToLookup then you ll get a lookup which can have multiple values per key  You could then convert that to a dictionary   var result   dictionaries SelectMany dict   gt  dict                            ToLookup pair   gt  pair Key  pair   gt  pair Value                            ToDictionary group   gt  group Key  group   gt  group First       It s a bit ugly - and inefficient - but it s the quickest way to do it in terms of code   I haven t tested it  admittedly    You could write your own ToDictionary2 extension method of course  with a better name  but I don t have time to think of one now  - it s not terribly hard to do  just overwriting  or ignoring  duplicate keys  The important bit  to my mind  is using SelectMany  and realising that a dictionary supports iteration over its key value pairs

User · Answer

This doesn t explode if there are multiple keys   righter  keys replace  lefter  keys   can merge a number of dictionaries  if desired  and preserves the type  with the restriction that it requires a meaningful default public constructor    public static class DictionaryExtensions          Works in C 3 VS2008         Returns a new dictionary of this     others merged leftward         Keeps the type of  this   which must be default-instantiable         Example            result   map MergeLeft other1  other2           public static T MergeLeft lt T K V gt  this T me  params IDictionary lt K V gt    others          where T   IDictionary lt K V gt   new                 T newMap   new T            foreach  IDictionary lt K V gt  src in              new List lt IDictionary lt K V gt  gt    me    Concat others                     -- echk  Not quite there type-system              foreach  KeyValuePair lt K V gt  p in src                    newMap p Key    p Value                                  return newMap

User · Answer

or    public static IDictionary lt TKey  TValue gt  Merge lt TKey  TValue gt   IDictionary lt TKey  TValue gt  x  IDictionary lt TKey  TValue gt  y                return x              Except x Join y  z   gt  z Key  z   gt  z Key   a  b    gt  a                Concat y               ToDictionary z   gt  z Key  z   gt  z Value           the result is a union where for duplicate entries  y  wins

User · Answer

Dictionary lt String  String gt  allTables   new Dictionary lt String  String gt     allTables   tables1 Union tables2  ToDictionary pair   gt  pair Key  pair   gt  pair Value

User · Answer

using System Collections Generic  using System Linq   public static class DictionaryExtensions       public enum MergeKind   SkipDuplicates  OverwriteDuplicates       public static void Merge lt K  V gt  this IDictionary lt K  V gt  target  IDictionary lt K  V gt  source  MergeKind kind   MergeKind SkipDuplicates    gt          source ToList   ForEach     gt    if  kind    MergeKind OverwriteDuplicates     target ContainsKey   Key   target   Key      Value          You can either skip ignore  default  or overwrite the duplicates  And Bob s your uncle provided you are not overly fussy about Linq performance but prefer instead concise maintainable code as I do  in which case you can remove the default MergeKind SkipDuplicates to enforce a choice for the caller and make the developer cognisant of what the results will be

User · Answer

Option 1   This depends on what you want to happen if you are sure that you don t have duplicate key in both dictionaries  than you could do   var result   dictionary1 Union dictionary2  ToDictionary k   gt  k Key  v   gt  v Value    Note   This will throw error if you get any duplicate keys in dictionaries   Option 2   If you can have duplicate key then you ll have to handle duplicate key with the using of where clause   var result   dictionary1 Union dictionary2 Where k   gt   dictionary1 ContainsKey k Key    ToDictionary k   gt  k Key  v   gt  v Value    Note   It will not get duplicate key  if there will be any duplicate key than it will get dictionary1 s key   Option 3   If you want to use ToLookup  then you will get a lookup which can have multiple values per key  You could convert that lookup  to a dictionary   var result   dictionaries SelectMany dict   gt  dict                            ToLookup pair   gt  pair Key  pair   gt  pair Value                            ToDictionary group   gt  group Key  group   gt  group First

User · Answer

The following works for me  If there are duplicates  it will use dictA s value   public static IDictionary lt TKey  TValue gt  Merge lt TKey  TValue gt  this IDictionary lt TKey  TValue gt  dictA  IDictionary lt TKey  TValue gt  dictB      where TValue   class       return dictA Keys Union dictB Keys  ToDictionary k   gt  k  k   gt  dictA ContainsKey k    dictA k    dictB k

User · Answer

Try the following  static Dictionary lt TKey  TValue gt      Merge lt TKey  TValue gt  this IEnumerable lt Dictionary lt TKey  TValue gt  gt  enumerable        return enumerable SelectMany x   gt  x  ToDictionary x   gt  x Key  y   gt  y Value

User · Answer

Try the following  static Dictionary lt TKey  TValue gt      Merge lt TKey  TValue gt  this IEnumerable lt Dictionary lt TKey  TValue gt  gt  enumerable        return enumerable SelectMany x   gt  x  ToDictionary x   gt  x Key  y   gt  y Value

User · Answer

fromDic ToList   ForEach x   gt                        if  toDic ContainsKey x Key                   toDic Remove x Key               toDic Add x

User · Answer

fromDic ToList   ForEach x   gt                        if  toDic ContainsKey x Key                   toDic Remove x Key               toDic Add x

User · Answer

Merging using an extension method  It does not throw exception when there are duplicate keys  but replaces those keys with keys from the second dictionary   internal static class DictionaryExtensions       public static Dictionary lt T1  T2 gt  Merge lt T1  T2 gt  this Dictionary lt T1  T2 gt  first  Dictionary lt T1  T2 gt  second                if  first    null  throw new ArgumentNullException  first            if  second    null  throw new ArgumentNullException  second             var merged   new Dictionary lt T1  T2 gt             first ToList   ForEach kv   gt  merged kv Key    kv Value           second ToList   ForEach kv   gt  merged kv Key    kv Value            return merged            Usage   Dictionary lt string  string gt  merged   first Merge second

User · Answer

The trivial solution would be   using System Collections Generic      public static Dictionary lt TKey  TValue gt      Merge lt TKey TValue gt  IEnumerable lt Dictionary lt TKey  TValue gt  gt  dictionaries        var result   new Dictionary lt TKey  TValue gt         foreach  var dict in dictionaries          foreach  var x in dict              result x Key    x Value      return result

User · Answer

A version from  user166390 answer with an added IEqualityComparer parameter to allow for case insensitive key comparison        public static T MergeLeft lt T  K  V gt  this T me  params Dictionary lt K  V gt    others          where T   Dictionary lt K  V gt   new                 return me MergeLeft me Comparer  others              public static T MergeLeft lt T  K  V gt  this T me  IEqualityComparer lt K gt  comparer  params Dictionary lt K  V gt    others          where T   Dictionary lt K  V gt   new                 T newMap   Activator CreateInstance typeof T   new object     comparer    as T           foreach  Dictionary lt K  V gt  src in               new List lt Dictionary lt K  V gt  gt    me    Concat others                             -- echk  Not quite there type-system              foreach  KeyValuePair lt K  V gt  p in src                                newMap p Key    p Value                                  return newMap

User · Answer

Merging using an EqualityComparer that maps items for comparison to a different value type  Here we will map from KeyValuePair  item type when enumerating a dictionary  to Key   public class MappedEqualityComparer lt T U gt    EqualityComparer lt T gt        Func lt T U gt   map       public MappedEqualityComparer Func lt T U gt  map                 map   map             public override bool Equals T x  T y                return EqualityComparer lt U gt  Default Equals  map x    map y               public override int GetHashCode T obj                return  map obj  GetHashCode              Usage      if dictA and dictB are of type Dictionary lt int string gt  var dict   dictA Concat dictB                   Distinct new MappedEqualityComparer lt KeyValuePair lt int string gt  int gt  item   gt  item Key                    ToDictionary item   gt  item Key  item  gt  item Value

User · Answer

Note that if you use an extension method called  Add   you get to use collection initializers to combine as many dictionaries as needed like this   public static void Add lt K  V gt  this Dictionary lt K  V gt  d  Dictionary lt K  V gt  other      foreach  var kvp in other          if   d ContainsKey kvp Key               d Add kvp Key  kvp Value                 var s0   new Dictionary lt string  string gt         A    X      var s1   new Dictionary lt string  string gt         A    X          B    Y          Combine as many dictionaries and key pairs as needed var a   new Dictionary lt string  string gt      s0  s1  s0  s1  s1     C    Z

User · Answer

Based on the answers above  but adding a Func-parameter to let the caller handle the duplicates   public static Dictionary lt TKey  TValue gt  Merge lt TKey  TValue gt  this IEnumerable lt Dictionary lt TKey  TValue gt  gt  dicts                                                              Func lt IGrouping lt TKey  TValue gt   TValue gt  resolveDuplicates        if  resolveDuplicates    null          resolveDuplicates   new Func lt IGrouping lt TKey  TValue gt   TValue gt  group   gt  group First          return dicts SelectMany lt Dictionary lt TKey  TValue gt   KeyValuePair lt TKey  TValue gt  gt  dict   gt  dict                   ToLookup pair   gt  pair Key  pair   gt  pair Value                   ToDictionary group   gt  group Key  group   gt  resolveDuplicates group

User · Answer

Merging using an extension method  It does not throw exception when there are duplicate keys  but replaces those keys with keys from the second dictionary   internal static class DictionaryExtensions       public static Dictionary lt T1  T2 gt  Merge lt T1  T2 gt  this Dictionary lt T1  T2 gt  first  Dictionary lt T1  T2 gt  second                if  first    null  throw new ArgumentNullException  first            if  second    null  throw new ArgumentNullException  second             var merged   new Dictionary lt T1  T2 gt             first ToList   ForEach kv   gt  merged kv Key    kv Value           second ToList   ForEach kv   gt  merged kv Key    kv Value            return merged            Usage   Dictionary lt string  string gt  merged   first Merge second

User · Answer

I would do it like this   dictionaryFrom ToList   ForEach x   gt  dictionaryTo Add x Key  x Value      Simple and easy  According to this blog post it s even faster than most loops as its underlying implementation accesses elements by index rather than enumerator  see this answer    It will of course throw an exception if there are duplicates  so you ll have to check before merging

User · Answer

A version from  user166390 answer with an added IEqualityComparer parameter to allow for case insensitive key comparison        public static T MergeLeft lt T  K  V gt  this T me  params Dictionary lt K  V gt    others          where T   Dictionary lt K  V gt   new                 return me MergeLeft me Comparer  others              public static T MergeLeft lt T  K  V gt  this T me  IEqualityComparer lt K gt  comparer  params Dictionary lt K  V gt    others          where T   Dictionary lt K  V gt   new                 T newMap   Activator CreateInstance typeof T   new object     comparer    as T           foreach  Dictionary lt K  V gt  src in               new List lt Dictionary lt K  V gt  gt    me    Concat others                             -- echk  Not quite there type-system              foreach  KeyValuePair lt K  V gt  p in src                                newMap p Key    p Value                                  return newMap

User · Answer

I m very late to the party and perhaps missing something  but if either there are no duplicate keys or  as the OP says   In case of collision  it doesn t matter which value is saved to the dict as long as it s consistent   what s wrong with this one  merging D2 into D1      foreach  KeyValuePair lt string int gt  item in D2                                 D1 item Key    item Value                  It seems simple enough  maybe too simple  I wonder if I m missing something   This is what I m using in some code where I know there are no duplicate keys   I m still in testing  though  so I d love to know now if I m overlooking something  instead of finding out later

User · Answer

Try the following  static Dictionary lt TKey  TValue gt      Merge lt TKey  TValue gt  this IEnumerable lt Dictionary lt TKey  TValue gt  gt  enumerable        return enumerable SelectMany x   gt  x  ToDictionary x   gt  x Key  y   gt  y Value

User · Answer

The party s pretty much dead now  but here s an  improved  version of user166390 that made its way into my extension library  Apart from some details  I added a delegate to calculate the merged value        lt summary gt      Merges a dictionary against an array of other dictionaries       lt  summary gt       lt typeparam name  TResult  gt The type of the resulting dictionary  lt  typeparam gt       lt typeparam name  TKey  gt The type of the key in the resulting dictionary  lt  typeparam gt       lt typeparam name  TValue  gt The type of the value in the resulting dictionary  lt  typeparam gt       lt param name  source  gt The source dictionary  lt  param gt       lt param name  mergeBehavior  gt A delegate returning the merged value   Parameters in order  The current key  The current value  The previous value  lt  param gt       lt param name  mergers  gt Dictionaries to merge against  lt  param gt       lt returns gt The merged dictionary  lt  returns gt  public static TResult MergeLeft lt TResult  TKey  TValue gt       this TResult source      Func lt TKey  TValue  TValue  TValue gt  mergeBehavior      params IDictionary lt TKey  TValue gt    mergers      where TResult   IDictionary lt TKey  TValue gt   new         var result   new TResult        var sources   new List lt IDictionary lt TKey  TValue gt  gt    source            Concat mergers        foreach  var kv in sources SelectMany src   gt  src                 TValue previousValue          result TryGetValue kv Key  out previousValue           result kv Key    mergeBehavior kv Key  kv Value  previousValue              return result

User · Answer

Based on the answers above  but adding a Func-parameter to let the caller handle the duplicates   public static Dictionary lt TKey  TValue gt  Merge lt TKey  TValue gt  this IEnumerable lt Dictionary lt TKey  TValue gt  gt  dicts                                                              Func lt IGrouping lt TKey  TValue gt   TValue gt  resolveDuplicates        if  resolveDuplicates    null          resolveDuplicates   new Func lt IGrouping lt TKey  TValue gt   TValue gt  group   gt  group First          return dicts SelectMany lt Dictionary lt TKey  TValue gt   KeyValuePair lt TKey  TValue gt  gt  dict   gt  dict                   ToLookup pair   gt  pair Key  pair   gt  pair Value                   ToDictionary group   gt  group Key  group   gt  resolveDuplicates group

User · Answer

Tim  Should be a comment  but comments don t allow for code editing   Dictionary lt string  string gt  t1   new Dictionary lt string  string gt     t1 Add  a    aaa    Dictionary lt string  string gt  t2   new Dictionary lt string  string gt     t2 Add  b    bee    Dictionary lt string  string gt  t3   new Dictionary lt string  string gt     t3 Add  c    cee    t3 Add  d    dee    t3 Add  b    bee    Dictionary lt string  string gt  merged   t1 MergeLeft t2  t2  t3     Note  I applied the modification by  ANeves to the solution by  Andrew Orsich  so the MergeLeft looks like this now   public static Dictionary lt K  V gt  MergeLeft lt K  V gt  this Dictionary lt K  V gt  me  params IDictionary lt K  V gt    others                var newMap   new Dictionary lt K  V gt  me  me Comparer           foreach  IDictionary lt K  V gt  src in              new List lt IDictionary lt K  V gt  gt    me    Concat others                             -- echk  Not quite there type-system              foreach  KeyValuePair lt K  V gt  p in src                                newMap p Key    p Value                                  return newMap

User · Answer

This partly depends on what you want to happen if you run into duplicates  For instance  you could do   var result   dictionaries SelectMany dict   gt  dict                            ToDictionary pair   gt  pair Key  pair   gt  pair Value     That will throw an exception if you get any duplicate keys   EDIT  If you use ToLookup then you ll get a lookup which can have multiple values per key  You could then convert that to a dictionary   var result   dictionaries SelectMany dict   gt  dict                            ToLookup pair   gt  pair Key  pair   gt  pair Value                            ToDictionary group   gt  group Key  group   gt  group First       It s a bit ugly - and inefficient - but it s the quickest way to do it in terms of code   I haven t tested it  admittedly    You could write your own ToDictionary2 extension method of course  with a better name  but I don t have time to think of one now  - it s not terribly hard to do  just overwriting  or ignoring  duplicate keys  The important bit  to my mind  is using SelectMany  and realising that a dictionary supports iteration over its key value pairs

User · Answer

This partly depends on what you want to happen if you run into duplicates  For instance  you could do   var result   dictionaries SelectMany dict   gt  dict                            ToDictionary pair   gt  pair Key  pair   gt  pair Value     That will throw an exception if you get any duplicate keys   EDIT  If you use ToLookup then you ll get a lookup which can have multiple values per key  You could then convert that to a dictionary   var result   dictionaries SelectMany dict   gt  dict                            ToLookup pair   gt  pair Key  pair   gt  pair Value                            ToDictionary group   gt  group Key  group   gt  group First       It s a bit ugly - and inefficient - but it s the quickest way to do it in terms of code   I haven t tested it  admittedly    You could write your own ToDictionary2 extension method of course  with a better name  but I don t have time to think of one now  - it s not terribly hard to do  just overwriting  or ignoring  duplicate keys  The important bit  to my mind  is using SelectMany  and realising that a dictionary supports iteration over its key value pairs

User · Answer

public static IDictionary lt K  V gt  AddRange lt K  V gt  this IDictionary lt K  V gt  one  IDictionary lt K  V gt  two                        foreach  var kvp in two                                if  one ContainsKey kvp Key                       one kvp Key    two kvp Key                   else                     one Add kvp Key  kvp Value                             return one

User · Answer

How about adding a params overload   Also  you should type them as IDictionary for maximum flexibility   public static IDictionary lt TKey  TValue gt  Merge lt TKey  TValue gt  IEnumerable lt IDictionary lt TKey  TValue gt  gt  dictionaries                  public static IDictionary lt TKey  TValue gt  Merge lt TKey  TValue gt  params IDictionary lt TKey  TValue gt    dictionaries        return Merge  IEnumerable lt TKey  TValue gt   dictionaries

User · Answer

or    public static IDictionary lt TKey  TValue gt  Merge lt TKey  TValue gt   IDictionary lt TKey  TValue gt  x  IDictionary lt TKey  TValue gt  y                return x              Except x Join y  z   gt  z Key  z   gt  z Key   a  b    gt  a                Concat y               ToDictionary z   gt  z Key  z   gt  z Value           the result is a union where for duplicate entries  y  wins

User · Answer

How about adding a params overload   Also  you should type them as IDictionary for maximum flexibility   public static IDictionary lt TKey  TValue gt  Merge lt TKey  TValue gt  IEnumerable lt IDictionary lt TKey  TValue gt  gt  dictionaries                  public static IDictionary lt TKey  TValue gt  Merge lt TKey  TValue gt  params IDictionary lt TKey  TValue gt    dictionaries        return Merge  IEnumerable lt TKey  TValue gt   dictionaries

User · Answer

I m very late to the party and perhaps missing something  but if either there are no duplicate keys or  as the OP says   In case of collision  it doesn t matter which value is saved to the dict as long as it s consistent   what s wrong with this one  merging D2 into D1      foreach  KeyValuePair lt string int gt  item in D2                                 D1 item Key    item Value                  It seems simple enough  maybe too simple  I wonder if I m missing something   This is what I m using in some code where I know there are no duplicate keys   I m still in testing  though  so I d love to know now if I m overlooking something  instead of finding out later

[c#] Merging dictionaries in C#

Examples related to c#

Examples related to dictionary

Examples related to merge