C＃で辞書をマージする
C＃に2つ以上の辞書（Dictionary<T1,T2>）をマージするための最良の方法は何ですか？ （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からクールな解決策を得ましたが、私は重複キーを扱うものを考えていました。衝突の場合、それが一貫している限り、どの値が辞書に保存されるかは問題ではありません。
これは部分的にあなたが重複した場合に何をしたいのかに依存します。たとえば、次のようにします。
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));
シンプルで簡単 このブログ記事 によると、その基礎となる実装は列挙子ではなくインデックスで要素にアクセスするので、ほとんどのループよりもさらに高速です （この答えを参照してください） 。
重複がある場合はもちろん例外が発生しますので、マージする前に確認する必要があります。
さて、私はパーティーに遅れていますが、ここに私が使っているものがあります。複数のキーがある場合は爆発しません（ "より正しい"キーが "lefter"キーを置き換えます）。（必要に応じて）いくつかの辞書をマージし、（意味のあるデフォルトのパブリックコンストラクタを必要とする制限付きで）タイプを保持できます。
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);
以下は私のために働きます。重複がある場合は、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]);
}
私はパーティーに非常に遅れていて、おそらく何かが足りないのですが、重複したキーがないか、OPが言っているように、「衝突の場合、どの値が辞書に保存されるかは問題ではありません。 「これはどうしたのですか（D2とD1をマージする）。
foreach (KeyValuePair<string,int> item in D2)
{
D1[item.Key] = item.Value;
}
それは十分に単純に思えます、おそらくあまりにも単純すぎて、私は何かが足りないかどうか疑問に思います。これは私が重複キーがないことを私が知っているいくつかのコードで使用しているものです。私はまだテスト中です、だから私は後で見つけるのではなく、私が何かを見逃しているかどうかを今知りたいのですが。
これが私が使うヘルパー関数です。
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);
}
}
}
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);
}
辞書のキーの検索と削除はハッシュ演算なので パフォーマンスを考えると 、問題の文言は best wayであると考えると、以下は完全に有効なアプローチです、そして、他は少し過度に複雑です、私見。
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);
}
}
その後、これをラップして辞書の列挙を処理できるようにすることができます。とにかく、.Add()は舞台裏で追加的な、不要ではあるが実質的に無料のContains()をするので、あなたは〜O（3n）（すべての条件は完璧である）について見ている。私はそれがはるかに良くなるとは思わない。
大規模なコレクションに対する余分な操作を制限したい場合は、マージしようとしている各辞書の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;
}
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; });
}
あなたはLinqのパフォーマンスについて過度にうるさいわけではないが、私のように簡潔で保守可能なコードを好むならば、ボブはあなたのおじです。呼び出し元の選択と、結果がどうなるかを開発者に認識させます。
オプション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());
@ティム：コメントする必要がありますが、コメントはコード編集を許可しません。
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);
注：@Andrew Orsichによるソリューションに@ANevesによる修正を適用したので、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;
}
複雑な答えを見るのが怖くなった。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
}
より複雑なシナリオについては、他の答えを参照してください。
お役に立てば幸いです。
私はこれが古い質問であることを知っています、しかし我々は今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));
拡張方法を使用してマージする。重複したキーがあっても例外は発生しませんが、それらのキーを2番目の辞書のキーと置き換えます。
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);
列挙型を使用するのではなく、存在する場合は非破壊的マージ、またはtrueの場合は完全に上書きするboolデフォルトを使用して、以前の回答と比較して使用を簡素化しました。それは今でも手の込んだコードを必要とせずに私自身のニーズに合っています：
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;
});
}
}
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;
}
比較用の項目を別の値/型にマップする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"が優先されることになります。
@ 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);
});
「追加」という拡張メソッドを使用する場合は、コレクション初期化子を使用して、次のように必要な数の辞書を結合することに注意してください。
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" }
};