C #에서 사전 병합

Dictionary<T1,T2>C #에서 둘 이상의 사전 ( ) 을 병합하는 가장 좋은 방법은 무엇입니까 ? (LINQ와 같은 3.0 기능이 좋습니다).

나는 다음과 같은 방법으로 메소드 서명을 생각하고 있습니다.

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

또는

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

편집 : JaredPar와 Jon Skeet에서 멋진 솔루션을 얻었지만 중복 키를 처리하는 것을 생각하고있었습니다. 충돌의 경우 일관된 한 어떤 값이 dict에 저장되는지는 중요하지 않습니다.

이것은 부분적으로 중복이 발생했을 때 어떤 일이 일어나고 싶은가에 달려 있습니다. 예를 들어 다음을 수행 할 수 있습니다.

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

중복 키가 있으면 예외가 발생합니다.

편집 : ToLookup을 사용하면 키 당 여러 값을 가질 수있는 조회가 표시됩니다. 당신은 할 수 후 사전에 그 변환 :

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

약간 추악하고 비효율적이지만 코드 측면에서 가장 빠른 방법입니다. (필자는 테스트하지 않았습니다.)

물론 더 나은 이름으로 자신의 ToDictionary2 확장 방법을 작성할 수 있습니다 (지금은 생각할 시간이 없습니다). 복잡한 키를 덮어 쓰거나 무시하는 것만으로는 어렵지 않습니다. 중요한 점은 내 생각에 SelectMany를 사용하고 사전이 키 / 값 쌍에 대한 반복을 지원한다는 것을 깨닫는 것입니다.

나는 이렇게 할 것입니다 :

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

간단하고 쉽습니다. 이 블로그 게시물 에 따르면 기본 구현이 열거자가 아닌 인덱스로 요소에 액세스하므로 대부분의 루프보다 훨씬 빠릅니다 (이 답변 참조) .

중복이있는 경우 물론 예외가 발생하므로 병합하기 전에 확인해야합니다.

여러 개의 키가있는 경우 ( "오른쪽"키가 "왼쪽"키를 대체 함), 여러 사전을 병합하고 (필요한 경우) 유형을 보존 할 수 있습니다 (유의 한 기본 공용 생성자가 필요하다는 제한 사항 포함).

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;
    }

}

사소한 해결책은 다음과 같습니다.

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;
}

다음을 시도하십시오

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);

나는 파티에 매우 늦었고 어쩌면 뭔가를 잃어 버렸지 만 중복 키가 없거나 OP가 말한 것처럼 "충돌의 경우 어떤 값이 dict에 저장되어 있는지는 중요하지 않습니다. 일관된 ""이 문제가 무엇입니까 (D2를 D1에 병합)?

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

충분히 간단 해 보일 수도 있고 너무 간단 할 수도 있습니다. 이것은 중복 키가 없다는 것을 알고있는 일부 코드에서 사용중인 것입니다. 그래도 여전히 테스트 중이므로 나중에 찾는 것이 아니라 무언가를 간과하고 있는지 알고 싶습니다.

다음은 나를 위해 작동합니다. 중복이 있으면 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]);
}

내가 사용하는 도우미 기능은 다음과 같습니다.

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);
        }
    }
}

옵션 1 : 두 사전에 중복 키가없는 경우 어떤 일이 발생하는지에 따라 다릅니다. 당신이 할 수있는 것보다 :

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

참고 : 사전에 중복 키가 있으면 오류가 발생합니다.

옵션 2 : 중복 키를 가질 수 있다면 where 절을 사용하여 중복 키를 처리해야합니다.

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

참고 : 중복 키는 얻지 않습니다. 중복 키가 있으면 dictionary1의 키를 얻습니다.

옵션 3 : ToLookup을 사용하려는 경우 그러면 키당 여러 값을 가질 수있는 조회가 제공됩니다. 해당 조회를 사전으로 변환 할 수 있습니다.

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

params과부하 를 추가하는 것은 어떻습니까?

또한 IDictionary최대한의 유연성 을 위해 입력해야 합니다.

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);
}

고려하여 사전 키 조회 및 삭제의 성능을 질문의 표현을했다가 해시 작업이기 때문에, 그리고 고려하는 가장 좋은 방법은, 내가 아래에 완벽하게 유효한 방법이라고 생각하고 다른 사람은 약간, 이럴를 너무 복잡하다.

    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);
        }
    }

또는 다중 스레드 응용 프로그램에서 작업하고 사전이 스레드 안전해야하는 경우 다음을 수행해야합니다.

    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);
        }
    }

그런 다음 이것을 감싸서 사전의 열거를 처리 할 수 ​​있습니다. 에 관계없이, 당신은 이후 약 ~ O (3N) (모든 조건 인 완벽한)에서 찾고 .Add()할 것, 추가 필요하지만, 실질적으로 무료 Contains()뒤에서. 나는 그것이 훨씬 나아질 것이라고 생각하지 않습니다.

대규모 컬렉션에서 추가 작업을 제한 Count하려면 병합하려는 각 사전을 합산 하고 대상 사전의 용량을 그로 설정해야하므로 나중에 크기 조정 비용이 발생하지 않습니다. 최종 제품은 다음과 같습니다.

    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;
    }

IList<T>내가이 방법을 사용 했다는 점에 유의하십시오 ... 주로을 복용 IEnumerable<T>하면 동일한 세트의 여러 열거를 열었으므로 연기 된 LINQ에서 사전 모음을 가져 오는 경우 비용이 많이들 수 있습니다 성명서.

위의 답변을 기반으로하지만 호출자가 중복을 처리 할 수 ​​있도록 Func 매개 변수를 추가하십시오.

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));
}

파티는 이제 거의 죽었지 만, 여기 내 확장 라이브러리에 들어간 user166390의 "개선 된"버전이 있습니다. 세부 사항 외에도 병합 값을 계산하기 위해 대리자를 추가했습니다.

/// <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 : 주석이어야하지만 주석은 코드 편집을 허용하지 않습니다.

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);

참고 : @ ANdrews의 수정 사항을 @Andrew Orsich의 솔루션에 적용 했으므로 이제 MergeLeft는 다음과 같습니다.

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;
    }

나는 이것이 오래된 질문이라는 것을 알고 있지만 이제 우리는 LINQ를 가지고 있으므로 다음과 같이 한 줄로 할 수 있습니다

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

또는

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

C #에 익숙하지 않은 복잡한 답변을 보는 것이 무서웠습니다.

다음은 간단한 답변입니다.
d1, d2 등을 병합합니다. 사전을 만들고 겹치는 키를 처리합니다 (아래 예에서 "b").

실시 예 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
}

실시 예 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
}

더 복잡한 시나리오는 다른 답변을 참조하십시오.
도움이 되었기를 바랍니다.

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; });
}

당신은 건너 뛰거나 무시하거나 (중복) 중복을 덮어 쓸 수 있습니다 : 그리고 Bob의 삼촌은 Linq 성능에 대해 지나치게 까다 롭지 않지만 대신 간결한 유지 관리 가능한 코드를 선호합니다.이 경우 기본 MergeKind를 제거 할 수 있습니다. 발신자를위한 선택과 개발자에게 결과가 무엇인지 알도록하십시오!

'추가'라는 확장 메서드를 사용하는 경우 컬렉션 초기화 도구를 사용하여 다음과 같이 필요한만큼 사전을 결합 할 수 있습니다.

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" }
};

확장 방법을 사용하여 병합. 중복 키가있는 경우 예외가 발생하지 않지만 해당 키를 두 번째 사전의 키로 바꿉니다.

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;
    }
}

용법:

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

기존의 경우 부울 기본값으로 비파괴 병합의 부울 기본값을 사용하거나 열거 형을 사용하지 않고 참이면 완전히 덮어 쓰는 사용에서 단순화되었습니다. 더 멋진 코드가 필요없이 여전히 내 자신의 요구에 맞습니다.

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;
        });
    }
}

를 사용하여 병합하면 EqualityComparer항목을 다른 값 / 유형과 비교할 수 있습니다. 여기에서 KeyValuePair(사전을 열거 할 때 항목 유형)을로 매핑 합니다 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();
    }
}

용법:

// 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);

또는 :

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);
    }

결과는 중복 항목 "y"가이기는 조합입니다.

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;
        }

@ user166390의 버전은 추가 된 답변 IEqualityComparer 대소 문자를 구분하지 않는 키 비교를 위해 매개 변수로 합니다.

    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);
        });