Quel est le moyen le plus simple et le plus compact de créer un IEnumerable ou ICollection ?

Question

Alors, plusieurs fois nous avons une fonction qui accepte un IEnumerable ou ICollection comme paramètre. Dans les cas où nous avons des éléments simples, mais pas de collection pour les tenir, il faut créer une collection avant de les transmettre à la fonction, comme:

T o1, o2, o3;
Foo(new T[] { o1, o2, o3 });

J'ai toujours créé un tableau ou une liste, comme je l'ai fait dans le dernier exemple. Mais je me demande, est-il une façon plus élégante pour créer le IEnumerable ou ICollection nécessaire?

Il serait assez cool, si l'on pouvait faire ceci:

Foo({ o1, o2, o3 });

Et le compilateur créerait la plus abstraite collection possible qui satisferait aux besoins de IEnumerable ou ICollection (selon lequel la fonction accepte).

De toute façon, comment vous passeriez o1, o2 et o3 à un ou paramètres IEnumerable ICollection?

Answer 1

La version actuelle de C # (3) prend en charge une notation sans type explicite, i.e..

Foo(new [] { o1, o2, o3 })

pour créer un tableau. Il y a aussi la Enumerable.Range de LINQ pour créer une gamme continue de nombres. Tout le reste doit être mis en œuvre. Dans l'esprit de Java:

public static IEnumerable<T> AsList<T>(params T[] values) {
    return values;
}

être appelé comme ceci:

Foo(Enumerable.AsList(o1, o2, o3));

Answer 2

Parfois, j'ai utilisé une méthode avec un argument "params".

Foo(params T[] ts)

Et si je suis mort sur IEnumerable ensemble je viens de ce délégué de méthode pour celui qui veut IEnumerable.

Foo(params T[] ts) { Foo(ts.AsEnumerable()); }

Vous devez appeler AsEnumerable ou vous allez récursif.

Answer 3

En supposant Foo attend un IEnumerable , vous pouvez profiter de l'inférence de type et faire:

T o1, o2, o3;
Foo(new []{o1, o2, o3});

Answer 4

Création d'un tableau et en passant qui est probablement le moyen le plus simple / la plus élégante d'y arriver dans la version actuelle de C #. Vous pouvez profiter de la saisie du tableau implicite (à savoir new[] { ... }, mais c'est aussi loin que ça se passe.

Je suppose que vous êtes vraiment pour le C # équivalent de cette syntaxe F #:

let foo = seq [ o1; o2; o3 ]

qui génère un IEnumerable<T> qui itérer sur les éléments spécifiés. ( 'Seq' est en fait l'alias F # pour « IEnumerable`, bien que F # a un support intégré pour eux.)

Malheureusement, puisque c'est une notion largement fonctionnelle, il n'y a pas C # équivalent - mais qui sait quand il sera ajouté, en C # devient de plus en plus fonctionnel

.

Answer 5

Si vous avez une méthode qui prend un tableau comme dernier paramètre, il peut être judicieux de marquer ce paramètre params. Cela vous permet d'appeler la méthode comme ceci:

Foo(o1, o2, o3);

Je trouve cela particulièrement utile lors de l'écriture d'un test unitaire pour Foo(), parce que souvent dans une unité de tester mes paramètres sont séparés comme celui-ci, au lieu de dans un tableau.

Je vous déconseille de faire cela s'il y a une surcharge de Foo() qui ne prend pas un tableau dans cette position, car il peut se confondre rapidement.

Je souhaite que le langage C # a permis params pour IList<T>:

void Foo(params IList<T> ts) { ... }