web-dev-qa-db-fra.com

Comment ajouter plusieurs valeurs au dictionnaire en C #

Quel est le meilleur moyen d'ajouter plusieurs valeurs à un dictionnaire, si je ne veux pas appeler ".Add ()" plusieurs fois . Edit : Je veux le remplir après l'initiation! il y a déjà des valeurs dans le dictionnaire!

Donc au lieu de 

    myDictionary.Add("a", "b");
    myDictionary.Add("f", "v");
    myDictionary.Add("s", "d");
    myDictionary.Add("r", "m");
    ...

je veux faire quelque chose comme ça

 myDictionary.Add(["a","b"], ["f","v"],["s","d"]);

Y a-t-il un moyen de le faire?

c#dictionary
15
LocalHorst

Vous pouvez utiliser des accolades pour cela, bien que cela ne fonctionne que pour l'initialisation:

var myDictionary = new Dictionary<string, string>
{
    {"a", "b"},
    {"f", "v"},
    {"s", "d"},
    {"r", "m"}
};

Ceci s'appelle "initialisation de collection" et fonctionne pour tout ICollection<T> (voir link pour les dictionnaires ou this link pour tout autre type de collection). En fait, cela fonctionne pour tout type d'objet implémentant IEnumerable et contenant une méthode Add:

class Foo : IEnumerable
{
    public void Add<T1, T2, T3>(T1 t1, T2 t2, T3 t3) { }
    // ...
}

Foo foo = new Foo
{
    {1, 2, 3},
    {2, 3, 4}
};

Fondamentalement, il ne s'agit que du sucre syntaxique pour appeler la méthode Add- à plusieurs reprises. Après l'initialisation, il existe plusieurs façons de procéder, l'une d'entre elles appelant les méthodes Add- manuellement:

var myDictionary = new Dictionary<string, string>
    {
        {"a", "b"},
        {"f", "v"}
    };

var anotherDictionary = new Dictionary<string, string>
    {
        {"s", "d"},
        {"r", "m"}
    };

// Merge anotherDictionary into myDictionary, which may throw
// (as usually) on duplicate keys
foreach (var keyValuePair in anotherDictionary)
{
    myDictionary.Add(keyValuePair.Key, keyValuePair.Value);
}

Ou comme méthode d'extension:

static class DictionaryExtensions
{
    public static void Add<TKey, TValue>(this IDictionary<TKey, TValue> target, IDictionary<TKey, TValue> source)
    {
        if (source == null) throw new ArgumentNullException("source");
        if (target == null) throw new ArgumentNullException("target");

        foreach (var keyValuePair in source)
        {
            target.Add(keyValuePair.Key, keyValuePair.Value);
        }
    }
}

var myDictionary = new Dictionary<string, string>
    {
        {"a", "b"},
        {"f", "v"}
    };

myDictionary.Add(new Dictionary<string, string>
    {
        {"s", "d"},
        {"r", "m"}
    });
16
Caramiriel

Ce n'est pas exactement une question en double, mais ce que vous voulez probablement, c'est qu'il y ait une méthode Dictionary.AddRange(). Et voici pourquoi cela n'existe pas:

Pourquoi dictionnaire n'a pas AddRange?

"Range n'a pas vraiment de sens pour un conteneur associatif."

Mais il pourrait être judicieux d’écrire votre propre méthode .AddRange() dans la classe Dictionary. Ce serait essentiellement une boucle d'appels .Add() cependant.

5
catfood

Bien que la question ait été résolue, j’étais curieux de savoir s’il serait possible d’appliquer la syntaxe de type initialiseur de collection à un dictionnaire déjà initialisé sans la création/surcharge de la création d’un deuxième dictionnaire à fusionner et à supprimer.

Vous pouvez utiliser (abus?) Initialisateurs de collection pour ajouter une plage de valeurs à un dictionnaire existant après sa création. Comment? En créant une classe d'assistance pour le faire:

public class AddRangeTo<TKey, TValue> : IEnumerable
{
    private readonly IDictionary<TKey, TValue> WrappedDictionary;

    public AddRangeTo(IDictionary<TKey, TValue> wrappedDictionary)
    {
        this.WrappedDictionary = wrappedDictionary;
    }

    public void Add(TKey key, TValue value)
    {
        this.WrappedDictionary.Add(key, value);
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        throw new NotSupportedException();
    }
}

Avec usage:

var myDictionary = new Dictionary<string, string>();

new AddRangeTo<string, string>(myDictionary)
{
    {"a", "b"},
    {"f", "v"},
    {"s", "d"},
    {"r", "m"}
};

Notez que cela vous permet d’ajouter des entrées au dictionnaire en utilisant une syntaxe similaire mais à un dictionnaire déjà initialisé. La partie qui craint est la répétition des génériques <string, string>, mais cela ne sera pas nécessaire avec C # 6.0. (EDIT: En C # 6, cela ressemblerait à new AddRangeTo(myDictionary)) (EDIT: cette fonctionnalité a été supprimée de C # 6)

Cela étant dit, je ne recommande pas vraiment de le faire nécessairement. Ceci est odd syntaxe/usage avec des effets secondaires inattendus et je pense que cela pourrait être déroutant pour les autres quand ils le découvriraient. Mais si vous trouvez que vous utiliserez beaucoup cela et que votre code internal sera plus facile à utiliser et à maintenir, alors bonus!

4
Chris Sinclair

Vous pouvez le faire à l’initialisation comme tout autre émission de réponse ou le combiner avec cette astuce:

Dictionary<string, string> myDictionary = new Dictionary<string, string>();
Dictionary<string, string> secondDictionary = new Dictionary<string, string>()
{ 
    {"1", "a"}, 
    {"2", b"} 
};
myDictionary = myDictionary.Union(secondDictionary)
                           .ToDictionary(kvp => kvp.Key, kvp => kvp.Value);

Vous devez vous assurer qu'il n'y a pas de clés en double ou vous obtiendrez une exception (mais cela est la même chose avec la méthode Add).

3
Raidri

Vous pouvez le faire comme ça:

var myDict = new Dictionary<string, string>() 
{
    {"a", "aa"},
    {"b", "bb"},
    {"c", "cc"},
    {"d", "dd"}
};
3
Loetn

Cela aurait été une recherche Google facile: http://msdn.Microsoft.com/en-us/library/bb531208.aspx . En tout cas ... voici le code: 

Dictionary<string, string> myDictionary = new Dictionary<string, string>()
{
    { 'a', 'b' },
    { 'c', 'd' },
    { 'e', 'f' }
};

Bien sûr, vous pouvez également écrire une boucle ou quelque chose à parcourir sur vos valeurs et à appeler la méthode .add () à chaque fois.

0
Bas Slagter

Eh bien, vous pouvez à l'initialisation:

new Dictionary<string, string> { {"a","b"}, {"f","v"},{"s","d"} }

Cela s'appelle un initialiseur de collection . Lorsque vous souhaitez ajouter plusieurs éléments à un dictionnaire existant, vous pouvez écrire une méthode.

0
Dennis_E