C# de la Fusion de 2 dictionnaires

Je suis de développer une application en C# ciblage .NET 3.5. J'ai 2 similaires dictionnaires qui contiennent des critères de validation pour un ensemble spécifique d'éléments dans mon application. Les deux dictionnaires ont les mêmes signatures. Le premier dictionnaire a les paramètres par défaut et le 2ème dictionnaire contient certains paramètres définis par l'utilisateur. 

var default_settings = new Dictionary<string, MyElementSettings>();
var custom_settings = new Dictionary<string, MyElementSettings>();

Je voudrais combiner les 2 dictionnaires en un qui contient les éléments des deux dictionnaires.

Le problème que je suis en cours d'exécution, c'est qu'il est possible pour les deux dictionnaires d'avoir certains des mêmes valeurs de clé. La règle de base que je veux, c'est une combinaison à la fois dictionnaire et si il y a toutes les clés en les custom_settings qui existent déjà dans le default_settings, le custom_settings de la valeur de remplacer le default_settings valeur. La meilleure solution que j'ai est juste une boucle foreach, vérifiez si la clé existe dans l'autre dictionnaire, et si non, ajouter.

foreach (var item in custom_settings)
{
    if (default_settings.ContainsKey(item.Key))
        default_settings[item.Key] = item.Value;
    else
        default_settings.Add(item.Key, item.Value);
}

J'ai fait de la base des requêtes LINQ, mais je travaille toujours sur l'apprentissage, les trucs les plus avancés. J'ai vu un peu les requêtes qui va fusionner 2 dictionnaires, mais la plupart comportent un groupement de n'importe quel élément avec des doubles de clés, ou seulement retourner une collection avec juste le double des clés/Est-il une requête LINQ ou l'expression de mimer le comportement de la boucle foreach, je suis en utilisant?

InformationsquelleAutor psubsee2003 | 2010-10-25
  1. 41

    Deux points:

    1. LINQ n'est pas idéal pour l'exécution d'effets secondaires. Dans ce cas, vous êtes de tenter de muter une collection existante plutôt que d'exécuter une requête, donc, je voudrais fuir un pur LINQ solution.
    2. La setter sur le générique du dictionnaire de l'indexeur a déjà l'effet de l'ajout de la paire clé-valeur si la clé n'existe pas, ou à l'écrasement de la valeur si elle n'.

    Lorsque vous définissez la valeur de la propriété, si
    la clé est dans le Dictionnaire, la valeur associée à
    cette clé est remplacé par le
    de la valeur. Si la clé n'est pas dans le
    Dictionnaire, la clé et
    valeur sont ajoutés au dictionnaire.

    De sorte que votre foreach boucle est essentiellement équivalent à:

    foreach (var item in custom_settings)
{
   default_settings[item.Key] = item.Value;
}

    Maintenant c'est assez laconique déjà, donc je ne pense pas que LINQ va vous aider beaucoup.

    • +1 pour le point #2 (msdn.microsoft.com/en-us/library/k7z0zy8k.aspx)
    • +1 pour m'enseigner quelque chose que je ne savais pas. Je suis relativement autodidacte avec C# et ne savait jamais, vous pouvez le faire à l'aide de dictionnaires.
    • Des acclamations. Je suis sûr que j'ai utilisé le même modèle que votre code avant j'ai découvert qu'elle était redondante (par chance, a été farfouillé avec réflecteur).
    InformationsquelleAutor Ani
  2. 8

    Voici une belle extension de la méthode basée sur l'Ani de réponse.

    public static class DictionaryExtensionMethods
{
    public static void Merge<TKey, TValue>(this Dictionary<TKey, TValue> me, Dictionary<TKey, TValue> merge)
    {
        foreach (var item in merge)
        {
            me[item.Key] = item.Value;
        }
    }
}
    • Je voudrais changer de Dictionnaire sur IDictionary
    • Si c'est une collection de dictionnaires IEnumerable<Dictionary<TKey, TValu>> comment les comparer?
    InformationsquelleAutor Daniel Imms
  3. 2

    Si vous allez faire beaucoup, alors je vous recommande la rédaction d'un comparateur d'égalité pour les clés de dictionnaire:

    private class KeyEqualityComparer<T, U> : IEqualityComparer<KeyValuePair<T, U>>
{
    public bool Equals(KeyValuePair<T, U> x, KeyValuePair<T, U> y)
    {
        return x.Key.Equals(y.Key);
    }

    public int GetHashCode(KeyValuePair<T, U> obj)
    {
        return obj.Key.GetHashCode();
    }
}

    Et puis à chaque fois que vous avez besoin de fusionner des dictionnaires, vous pouvez effectuer les opérations suivantes

    var comparer = new KeyEqualityComparer<string, MyElementSettings>();
dict1 = dict1.Union(dict2,comparer).ToDictionary(a => a.Key, b => b.Value);
    • ceci a travaillé pour moi, même sans le KeyEqualityComparer classe/paramètre. Merci
    InformationsquelleAutor Dean Chalk
  4. 1

    Je pense que la réponse que j'ai choisi à l'origine est toujours la meilleure réponse pour ce cas particulier, je me suis retrouvé dans une autre situation similaire il y a peu, où j'ai eu 2 IEnumerable<> les objets que je voulait se convertir à un dictionnaire et se confondent dans un mode similaire alors j'ai pensé que je voudrais ajouter que la solution ici pour aider quelqu'un dans le futur. Plutôt que de convertir à la fois à un dictionnaire et à l'aide de la méthode le choix de la réponse, j'ai trouvé une nouvelle approche.

    J'ai effectivement posté le solution initiale sur SOI-CodeReview et effectivement eu une suggestion pour l'améliorer davantage. Voici le dernier code que j'ai utilisé:

    public Dictionary<String, Foo> Merge(XElement element1, XElement element2)
{
    IEnumerable<Foo> firstFoos = GetXmlData(element1); //parse 1st set from XML
    IEnumerable<Foo> secondFoos = GetXmlData(element2); //parse 2nd set from XML

    var result = firstFoos.Union(secondFoos).ToDictionary(k=>k.Name, v=>v);

    return result;
}

public class Foo
{
    public String Name { get; }

    //other Properties and Methods
    //.
    //.
    //.

    public override Boolean Equals(Object obj)
    {
        if (obj is Foo)
        {
            return this.Name == ((Foo)obj).Name;            
        }

        return false;
    }
}

    La clé, c'est Foo doit remplacer Equals() de définir ce que Foo les objets peuvent être considérés comme des doublons, et les membres qui définissent les objets sont en double devraient également être de la Dictionary<> clé (dans ce cas Name)

    Si vous ne pouvez pas remplacer Equals() dans Foo, puis l'autre option est d'utiliser Concat() et GroupBy() au lieu de Union()

    public Dictionary<String, Foo> Merge(XElement element1, XElement element2)
{
    IEnumerable<Foo> firstFoos = GetXmlData(element1); //parse 1st set from XML
    IEnumerable<Foo> secondFoos = GetXmlData(element2); //parse 2nd set from XML

    var result = firstFoos.Concat(secondFoos)
                          .GroupBy(foo => foo.Name)
                          .Select(grp => grp.First())
                          .ToDictionary(k=>k.Name, v=>v);

    return result;
}
    InformationsquelleAutor psubsee2003