En utilisant les paires clé-valeur en tant que paramètres

Question

Simple

. Si j'utilise:

public void Add(params int[] values)

Ensuite, je peux l'utiliser comme:

Add(1, 2, 3, 4);

Mais maintenant, je fais face à des paires clé-valeur! J'ai une classe KeyValue pour lier un entier à une valeur de chaîne. Alors je commence par:

public void Add(params KeyValue[] values)

Mais je ne peux pas utiliser ceci:

Add(1, "A", 2, "B", 3, "C", 4, "D");

Au lieu de cela, je suis obligé d'utiliser:

Add(new KeyValue(1, "A"), new KeyValue(2, "B"), new KeyValue(3, "C"), new KeyValue(4, "D"));

Beurk ... Déjà je n'aime pas ce ...

Alors, en ce moment j'utilise la fonction Ajouter sans le modificateur params et passe juste un tableau prédéfini à cette fonction. Comme il est juste utilisé pour une initialisation rapide pour un test, je ne suis pas trop inquiet au sujet ayant besoin de ce code supplémentaire, même si je veux continuer à lire le code simple. J'aimerais savoir une astuce pour utiliser la méthode que je ne peux pas utiliser, mais est-il possible de le faire sans utiliser la construction « nouvelle KeyValue () »?

Answer 1

Si vous avez accepté un IDictionary<int,string>, vous pourriez probablement utiliser (en C # 3.0, au moins):

Add(new Dictionary<int,string> {
     {1, "A"}, {2, "B"}, {3, "C"}, {4, "D"}
});

Toute utilisation?

Exemple Add:

static void Add(IDictionary<int, string> data) {
    foreach (var pair in data) {
        Console.WriteLine(pair.Key + " = " + pair.Value);
    }
}

Answer 2

Vous pouvez modifier la conception de votre classe actuelle, mais vous aurez besoin d'ajouter des génériques et utiliser l'interface IEnumerable.

    class KeyValue<TKey, TValue>
    {
        public KeyValue()
        {
        }
    }

    // 1. change: need to implement IEnumerable interface
    class KeyValueList<TKey, TValue> : IEnumerable<TKey>
    {
        // 2. prerequisite: parameterless constructor needed
        public KeyValueList()
        {
            // ...
        }

        // 3. need Add method to take advantage of
        // so called "collection initializers"
        public void Add(TKey key, TValue value)
        {
            // here you will need to initalize the
            // KeyValue object and add it
        }

        // need to implement IEnumerable<TKey> here!
    }

Après ces ajouts, vous pouvez effectuer les opérations suivantes:

    new KeyValueList<int, string>() { { 1, "A" }, { 2, "B" } };

Le compilateur utilisera l'interface IEnumerable et la méthode Add pour remplir le keyvaluelist. Notez que cela fonctionne pour 3.0 C #.

Si vous utilisez ce pour les tests, ces changements ne sont pas la peine. Il est tout à fait un effort et vous changer beaucoup de code de production pour les tests.

Answer 3

Vous pouvez utiliser quelque chose comme ce qui suit avec l'inconvénient évident que vous perdez typage fort.

 public void Add(params Object[] inputs)
 {
     Int32 numberPairs = inputs.Length / 2;

     KeyValue[] keyValues = new KeyValue[numberPairs];

     for (Int32 i = 0; i < numberPairs; i++)
     {
         Int32 key = (Int32)inputs[2 * i];
         String value = (String)inputs[2 * i + 1];

         keyvalues[i] = new KeyValue(key, value);
     }

     // Call the overloaded method accepting KeyValue[].
     this.Add(keyValues);
 }

 public void Add(params KeyValue[] values)
 {
     // Do work here.
 }

Vous devez ajouter de la cause une erreur de manipulation si les arguments sont de type incorrect. Non pas que intelligent, mais il fonctionne.