Menggabungkan kamus dalam C #

Apa cara terbaik untuk menggabungkan 2 kamus atau lebih (Dictionary<T1,T2> ) dalam C #? (3.0 fitur seperti LINQ baik-baik saja).

Saya sedang memikirkan tanda tangan metode di sepanjang baris:

public static Dictionary<TKey,TValue>
                 Merge<TKey,TValue>(Dictionary<TKey,TValue>[] dictionaries);

atau

public static Dictionary<TKey,TValue>
                 Merge<TKey,TValue>(IEnumerable<Dictionary<TKey,TValue>> dictionaries);

EDIT: Mendapat solusi keren dari JaredPar dan Jon Skeet, tapi saya memikirkan sesuatu yang menangani kunci duplikat. Dalam kasus tabrakan, tidak masalah nilai mana yang disimpan ke dikt selama itu konsisten.

Ini sebagian tergantung pada apa yang Anda inginkan terjadi jika Anda mengalami duplikat. Misalnya, Anda dapat melakukan:

var result = dictionaries.SelectMany(dict => dict)
                         .ToDictionary(pair => pair.Key, pair => pair.Value);

Itu akan menghasilkan pengecualian jika Anda mendapatkan kunci duplikat.

EDIT: Jika Anda menggunakan ToLookup maka Anda akan mendapatkan pencarian yang dapat memiliki beberapa nilai per kunci. Anda kemudian dapat mengonversinya menjadi kamus:

var result = dictionaries.SelectMany(dict => dict)
                         .ToLookup(pair => pair.Key, pair => pair.Value)
                         .ToDictionary(group => group.Key, group => group.First());

Agak jelek - dan tidak efisien - tetapi ini adalah cara tercepat untuk melakukannya dalam hal kode. (Aku belum mengujinya, diakui.)

Anda dapat menulis metode ekstensi ToDictionary2 Anda sendiri tentu saja (dengan nama yang lebih baik, tapi saya tidak punya waktu untuk memikirkannya sekarang) - tidak terlalu sulit untuk dilakukan, hanya menimpa (atau mengabaikan) kunci duplikat. Bit penting (menurut saya) adalah menggunakan SelectMany, dan menyadari bahwa kamus mendukung iterasi dari pasangan kunci / nilainya.

Saya akan melakukannya seperti ini:

dictionaryFrom.ToList().ForEach(x => dictionaryTo.Add(x.Key, x.Value));

Sederhana dan mudah. Menurut posting blog ini , ini bahkan lebih cepat daripada kebanyakan loop karena implementasi yang mendasarinya mengakses elemen dengan indeks daripada enumerator (lihat jawaban ini) .

Tentu saja akan mengeluarkan pengecualian jika ada duplikat, jadi Anda harus memeriksa sebelum bergabung.

Ini tidak meledak jika ada beberapa kunci ("righter" kunci menggantikan "lefter" kunci), dapat menggabungkan sejumlah kamus (jika diinginkan) dan mempertahankan jenisnya (dengan batasan yang memerlukan konstruktor publik default yang bermakna):

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<T,K,V>(this T me, params IDictionary<K,V>[] others)
        where T : IDictionary<K,V>, new()
    {
        T newMap = new T();
        foreach (IDictionary<K,V> src in
            (new List<IDictionary<K,V>> { me }).Concat(others)) {
            // ^-- echk. Not quite there type-system.
            foreach (KeyValuePair<K,V> p in src) {
                newMap[p.Key] = p.Value;
            }
        }
        return newMap;
    }

}

Solusi sepele adalah:

using System.Collections.Generic;
...
public static Dictionary<TKey, TValue>
    Merge<TKey,TValue>(IEnumerable<Dictionary<TKey, TValue>> dictionaries)
{
    var result = new Dictionary<TKey, TValue>();
    foreach (var dict in dictionaries)
        foreach (var x in dict)
            result[x.Key] = x.Value;
    return result;
}

Coba yang berikut ini

static Dictionary<TKey, TValue>
    Merge<TKey, TValue>(this IEnumerable<Dictionary<TKey, TValue>> enumerable)
{
    return enumerable.SelectMany(x => x).ToDictionary(x => x.Key, y => y.Value);
}

Dictionary<String, String> allTables = new Dictionary<String, String>();
allTables = tables1.Union(tables2).ToDictionary(pair => pair.Key, pair => pair.Value);

Saya sangat terlambat ke pesta dan mungkin melewatkan sesuatu, tetapi jika tidak ada kunci duplikat atau, seperti kata OP, "Dalam kasus tabrakan, tidak masalah nilai yang disimpan ke dikt selama itu konsisten, "apa yang salah dengan ini (menggabungkan D2 ke D1)?

foreach (KeyValuePair<string,int> item in D2)
            {
                 D1[item.Key] = item.Value;
            }

Tampaknya cukup sederhana, mungkin terlalu sederhana, saya ingin tahu apakah saya kehilangan sesuatu. Inilah yang saya gunakan dalam beberapa kode di mana saya tahu tidak ada kunci duplikat. Saya masih dalam pengujian, jadi saya ingin tahu sekarang jika saya mengabaikan sesuatu, daripada mencari tahu nanti.

Berikut ini berfungsi untuk saya. Jika ada duplikat, itu akan menggunakan nilai dictA.

public static IDictionary<TKey, TValue> Merge<TKey, TValue>(this IDictionary<TKey, TValue> dictA, IDictionary<TKey, TValue> dictB)
    where TValue : class
{
    return dictA.Keys.Union(dictB.Keys).ToDictionary(k => k, k => dictA.ContainsKey(k) ? dictA[k] : dictB[k]);
}

Berikut adalah fungsi pembantu yang saya gunakan:

using System.Collections.Generic;
namespace HelperMethods
{
    public static class MergeDictionaries
    {
        public static void Merge<TKey, TValue>(this IDictionary<TKey, TValue> first, IDictionary<TKey, TValue> second)
        {
            if (second == null || first == null) return;
            foreach (var item in second) 
                if (!first.ContainsKey(item.Key)) 
                    first.Add(item.Key, item.Value);
        }
    }
}

Opsi 1: Ini tergantung pada apa yang Anda inginkan terjadi jika Anda yakin bahwa Anda tidak memiliki kunci duplikat di kedua kamus. daripada yang bisa Anda lakukan:

var result = dictionary1.Union(dictionary2).ToDictionary(k => k.Key, v => v.Value)

Catatan: Ini akan menimbulkan kesalahan jika Anda mendapatkan kunci duplikat dalam kamus.

Opsi 2: Jika Anda dapat memiliki kunci duplikat maka Anda harus menangani kunci duplikat dengan penggunaan klausa where.

var result = dictionary1.Union(dictionary2.Where(k => !dictionary1.ContainsKey(k.Key))).ToDictionary(k => k.Key, v => v.Value)

Catatan: Itu tidak akan mendapatkan kunci duplikat. jika akan ada kunci duplikat daripada itu akan mendapatkan kunci dictionary1.

Opsi 3: Jika Anda ingin menggunakan ToLookup. maka Anda akan mendapatkan pencarian yang dapat memiliki beberapa nilai per kunci. Anda dapat mengonversi pencarian itu ke kamus:

var result = dictionaries.SelectMany(dict => dict)
                         .ToLookup(pair => pair.Key, pair => pair.Value)
                         .ToDictionary(group => group.Key, group => group.First());

Bagaimana kalau menambahkan paramskelebihan?

Anda juga harus mengetikkannya IDictionaryuntuk fleksibilitas maksimum.

public static IDictionary<TKey, TValue> Merge<TKey, TValue>(IEnumerable<IDictionary<TKey, TValue>> dictionaries)
{
    // ...
}

public static IDictionary<TKey, TValue> Merge<TKey, TValue>(params IDictionary<TKey, TValue>[] dictionaries)
{
    return Merge((IEnumerable<TKey, TValue>) dictionaries);
}

Mempertimbangkan kinerja pencarian kunci kamus dan menghapus karena mereka operasi hash, dan mempertimbangkan kata-kata dari pertanyaan itu adalah cara terbaik , saya pikir di bawah ini adalah pendekatan yang benar-benar valid, dan yang lain agak terlalu rumit, IMHO.

    public static void MergeOverwrite<T1, T2>(this IDictionary<T1, T2> dictionary, IDictionary<T1, T2> 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);
        }
    }

ATAU jika Anda bekerja di aplikasi multithreaded dan kamus Anda tetap aman utas, Anda harus melakukan ini:

    public static void MergeOverwrite<T1, T2>(this ConcurrentDictionary<T1, T2> dictionary, IDictionary<T1, T2> newElements)
    {
        if (newElements == null || newElements.Count == 0) return;

        foreach (var ne in newElements)
        {
            dictionary.AddOrUpdate(ne.Key, ne.Value, (key, value) => value);
        }
    }

Anda kemudian dapat membungkus ini untuk membuatnya menangani enumerasi kamus. Apapun, Anda sedang melihat ~ O (3n) (semua kondisi menjadi sempurna), karena .Add()akan melakukan tambahan, tidak perlu tetapi praktis gratis,Contains() belakang layar. Saya tidak berpikir itu menjadi lebih baik.

Jika Anda ingin membatasi operasi tambahan pada koleksi besar, Anda harus meringkas Countsetiap kamus yang akan Anda gabungkan dan atur kapasitas kamus target menjadi itu, yang menghindari biaya pengubahan ukuran nanti. Jadi, produk akhir adalah sesuatu seperti ini ...

    public static IDictionary<T1, T2> MergeAllOverwrite<T1, T2>(IList<IDictionary<T1, T2>> allDictionaries)
    {
        var initSize = allDictionaries.Sum(d => d.Count);
        var resultDictionary = new Dictionary<T1, T2>(initSize);
        allDictionaries.ForEach(resultDictionary.MergeOverwrite);
        return resultDictionary;
    }

Perhatikan bahwa saya menggunakan IList<T>metode ini ... sebagian besar karena jika Anda mengambil dalam IEnumerable<T>, Anda telah membuka diri untuk beberapa enumerasi dari set yang sama, yang bisa sangat mahal jika Anda mendapat koleksi kamus dari LINQ yang ditangguhkan pernyataan.

Berdasarkan jawaban di atas, tetapi menambahkan Func-parameter untuk membiarkan pemanggil menangani duplikat:

public static Dictionary<TKey, TValue> Merge<TKey, TValue>(this IEnumerable<Dictionary<TKey, TValue>> dicts, 
                                                           Func<IGrouping<TKey, TValue>, TValue> resolveDuplicates)
{
    if (resolveDuplicates == null)
        resolveDuplicates = new Func<IGrouping<TKey, TValue>, TValue>(group => group.First());

    return dicts.SelectMany<Dictionary<TKey, TValue>, KeyValuePair<TKey, TValue>>(dict => dict)
                .ToLookup(pair => pair.Key, pair => pair.Value)
                .ToDictionary(group => group.Key, group => resolveDuplicates(group));
}

Pesta ini sudah hampir mati sekarang, tapi di sini ada versi "perbaikan" dari user166390 yang memasuki perpustakaan ekstensi saya. Terlepas dari beberapa detail, saya menambahkan delegasi untuk menghitung nilai gabungan.

/// <summary>
/// Merges a dictionary against an array of other dictionaries.
/// </summary>
/// <typeparam name="TResult">The type of the resulting dictionary.</typeparam>
/// <typeparam name="TKey">The type of the key in the resulting dictionary.</typeparam>
/// <typeparam name="TValue">The type of the value in the resulting dictionary.</typeparam>
/// <param name="source">The source dictionary.</param>
/// <param name="mergeBehavior">A delegate returning the merged value. (Parameters in order: The current key, The current value, The previous value)</param>
/// <param name="mergers">Dictionaries to merge against.</param>
/// <returns>The merged dictionary.</returns>
public static TResult MergeLeft<TResult, TKey, TValue>(
    this TResult source,
    Func<TKey, TValue, TValue, TValue> mergeBehavior,
    params IDictionary<TKey, TValue>[] mergers)
    where TResult : IDictionary<TKey, TValue>, new()
{
    var result = new TResult();
    var sources = new List<IDictionary<TKey, TValue>> { source }
        .Concat(mergers);

    foreach (var kv in sources.SelectMany(src => src))
    {
        TValue previousValue;
        result.TryGetValue(kv.Key, out previousValue);
        result[kv.Key] = mergeBehavior(kv.Key, kv.Value, previousValue);
    }

    return result;
}

@Tim: Seharusnya komentar, tetapi komentar tidak memungkinkan untuk mengedit kode.

Dictionary<string, string> t1 = new Dictionary<string, string>();
t1.Add("a", "aaa");
Dictionary<string, string> t2 = new Dictionary<string, string>();
t2.Add("b", "bee");
Dictionary<string, string> t3 = new Dictionary<string, string>();
t3.Add("c", "cee");
t3.Add("d", "dee");
t3.Add("b", "bee");
Dictionary<string, string> merged = t1.MergeLeft(t2, t2, t3);

Catatan: Saya menerapkan modifikasi oleh @ANeves ke solusi oleh @Andrew Orsich, sehingga MergeLeft terlihat seperti ini sekarang:

public static Dictionary<K, V> MergeLeft<K, V>(this Dictionary<K, V> me, params IDictionary<K, V>[] others)
    {
        var newMap = new Dictionary<K, V>(me, me.Comparer);
        foreach (IDictionary<K, V> src in
            (new List<IDictionary<K, V>> { me }).Concat(others))
        {
            // ^-- echk. Not quite there type-system.
            foreach (KeyValuePair<K, V> p in src)
            {
                newMap[p.Key] = p.Value;
            }
        }
        return newMap;
    }

Saya tahu ini adalah pertanyaan lama, tetapi karena sekarang kami memiliki LINQ, Anda dapat melakukannya dalam satu baris seperti ini

Dictionary<T1,T2> merged;
Dictionary<T1,T2> mergee;
mergee.ToList().ForEach(kvp => merged.Add(kvp.Key, kvp.Value));

atau

mergee.ToList().ForEach(kvp => merged.Append(kvp));

Takut melihat jawaban yang rumit, baru mengenal C #.

Inilah beberapa jawaban sederhana.
Menggabungkan d1, d2, dan sebagainya .. kamus dan menangani kunci yang tumpang tindih ("b" dalam contoh di bawah ini):

Contoh 1

{
    // 2 dictionaries,  "b" key is common with different values

    var d1 = new Dictionary<string, int>() { { "a", 10 }, { "b", 21 } };
    var d2 = new Dictionary<string, int>() { { "c", 30 }, { "b", 22 } };

    var result1 = d1.Concat(d2).GroupBy(ele => ele.Key).ToDictionary(ele => ele.Key, ele => 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 => ele.Key).ToDictionary(ele => ele.Key, ele => ele.Last().Value);
    // result2 is  a=10, b=22, c=30    That is, took the "b" value of the last dictionary
}

Contoh 2

{
    // 3 dictionaries,  "b" key is common with different values

    var d1 = new Dictionary<string, int>() { { "a", 10 }, { "b", 21 } };
    var d2 = new Dictionary<string, int>() { { "c", 30 }, { "b", 22 } };
    var d3 = new Dictionary<string, int>() { { "d", 40 }, { "b", 23 } };

    var result1 = d1.Concat(d2).Concat(d3).GroupBy(ele => ele.Key).ToDictionary(ele => ele.Key, ele => 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 => ele.Key).ToDictionary(ele => ele.Key, ele => ele.Last().Value);
    // result2 is  a=10, b=23, c=30, d=40    That is, took the "b" value of the last dictionary
}

Untuk skenario yang lebih kompleks, lihat jawaban lain.
Harapan itu membantu.

using System.Collections.Generic;
using System.Linq;

public static class DictionaryExtensions
{
    public enum MergeKind { SkipDuplicates, OverwriteDuplicates }
    public static void Merge<K, V>(this IDictionary<K, V> target, IDictionary<K, V> source, MergeKind kind = MergeKind.SkipDuplicates) =>
        source.ToList().ForEach(_ => { if (kind == MergeKind.OverwriteDuplicates || !target.ContainsKey(_.Key)) target[_.Key] = _.Value; });
}

Anda dapat melewati / mengabaikan (default) atau menimpa duplikat: Dan Bob paman Anda asalkan Anda tidak terlalu cerewet tentang kinerja Linq tetapi lebih memilih kode dikelola singkat seperti yang saya lakukan: dalam hal ini Anda dapat menghapus MergeKind.SkipDuplicates default untuk menegakkan pilihan untuk penelepon dan buat pengembang tahu apa hasilnya nanti!

Perhatikan bahwa jika Anda menggunakan metode ekstensi yang disebut 'Tambah', Anda bisa menggunakan inisialisasi koleksi untuk menggabungkan sebanyak mungkin kamus seperti ini:

public static void Add<K, V>(this Dictionary<K, V> d, Dictionary<K, V> other) {
  foreach (var kvp in other)
  {
    if (!d.ContainsKey(kvp.Key))
    {
      d.Add(kvp.Key, kvp.Value);
    }
  }
}


var s0 = new Dictionary<string, string> {
  { "A", "X"}
};
var s1 = new Dictionary<string, string> {
  { "A", "X" },
  { "B", "Y" }
};
// Combine as many dictionaries and key pairs as needed
var a = new Dictionary<string, string> {
  s0, s1, s0, s1, s1, { "C", "Z" }
};

Penggabungan menggunakan metode ekstensi. Itu tidak membuang pengecualian ketika ada kunci duplikat, tetapi mengganti kunci-kunci itu dengan kunci dari kamus kedua.

internal static class DictionaryExtensions
{
    public static Dictionary<T1, T2> Merge<T1, T2>(this Dictionary<T1, T2> first, Dictionary<T1, T2> second)
    {
        if (first == null) throw new ArgumentNullException("first");
        if (second == null) throw new ArgumentNullException("second");

        var merged = new Dictionary<T1, T2>();
        first.ToList().ForEach(kv => merged[kv.Key] = kv.Value);
        second.ToList().ForEach(kv => merged[kv.Key] = kv.Value);

        return merged;
    }
}

Pemakaian:

Dictionary<string, string> merged = first.Merge(second);

Disederhanakan dari penggunaan dibandingkan dengan jawaban saya sebelumnya dengan default bool dari gabungan non-destruktif jika ada atau ditimpa seluruhnya jika benar daripada menggunakan enum. Itu masih sesuai dengan kebutuhan saya sendiri tanpa ada kode yang lebih menarik:

using System.Collections.Generic;
using System.Linq;

public static partial class Extensions
{
    public static void Merge<K, V>(this IDictionary<K, V> target, IDictionary<K, V> source, bool overwrite = false)
    {
        source.ToList().ForEach(_ => {
            if ((!target.ContainsKey(_.Key)) || overwrite)
                target[_.Key] = _.Value;
        });
    }
}

Menggabungkan menggunakan EqualityCompareritem peta untuk perbandingan dengan nilai / tipe yang berbeda. Di sini kita akan memetakan dari KeyValuePair(jenis item ketika menghitung kamus) ke Key.

public class MappedEqualityComparer<T,U> : EqualityComparer<T>
{
    Func<T,U> _map;

    public MappedEqualityComparer(Func<T,U> map)
    {
        _map = map;
    }

    public override bool Equals(T x, T y)
    {
        return EqualityComparer<U>.Default.Equals(_map(x), _map(y));
    }

    public override int GetHashCode(T obj)
    {
        return _map(obj).GetHashCode();
    }
}

Pemakaian:

// if dictA and dictB are of type Dictionary<int,string>
var dict = dictA.Concat(dictB)
                .Distinct(new MappedEqualityComparer<KeyValuePair<int,string>,int>(item => item.Key))
                .ToDictionary(item => item.Key, item=> item.Value);

atau :

public static IDictionary<TKey, TValue> Merge<TKey, TValue>( IDictionary<TKey, TValue> x, IDictionary<TKey, TValue> y)
    {
        return x
            .Except(x.Join(y, z => z.Key, z => z.Key, (a, b) => a))
            .Concat(y)
            .ToDictionary(z => z.Key, z => z.Value);
    }

hasilnya adalah gabungan tempat entri duplikat "y" menang.

public static IDictionary<K, V> AddRange<K, V>(this IDictionary<K, V> one, IDictionary<K, V> 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;
        }

Versi dari @ user166390 menjawab dengan IEqualityComparerparameter yang ditambahkan untuk memungkinkan perbandingan kunci yang tidak sensitif huruf.

    public static T MergeLeft<T, K, V>(this T me, params Dictionary<K, V>[] others)
        where T : Dictionary<K, V>, new()
    {
        return me.MergeLeft(me.Comparer, others);
    }

    public static T MergeLeft<T, K, V>(this T me, IEqualityComparer<K> comparer, params Dictionary<K, V>[] others)
        where T : Dictionary<K, V>, new()
    {
        T newMap = Activator.CreateInstance(typeof(T), new object[] { comparer }) as T;

        foreach (Dictionary<K, V> src in 
            (new List<Dictionary<K, V>> { me }).Concat(others))
        {
            // ^-- echk. Not quite there type-system.
            foreach (KeyValuePair<K, V> p in src)
            {
                newMap[p.Key] = p.Value;
            }
        }
        return newMap;
    }

fromDic.ToList().ForEach(x =>
        {
            if (toDic.ContainsKey(x.Key))
                toDic.Remove(x.Key);
            toDic.Add(x);
        });