Params IEnumerable<T> c#

Pourquoi ne puis-je pas utiliser un IEnumerable avec params? Sera-ce jamais être corrigé? Je souhaite vraiment que de la réécrire les anciennes bibliothèques à utiliser des génériques...

  • Est-ce un coup de gueule ou une question?
  • clairement, c'est les deux. +1 pour la question. Souhaite que je pourrais lui donner une seconde +1 pour le coup de gueule aussi.
  • avant la modification, la question ressemblait coup de gueule, mais pour quoi le titre de la question transmet, c'est une très bonne question..
  • Restaurée à la question d'origine, principalement parce que la réponse ci-dessous à partir de Eric Lippert - qui était alors un compilateur C# dev - se réfère à la formulation d'origine. Si il ne l'avait pas exception à la formulation, nous avons probablement n'avez pas besoin non plus!
  • Légère tatillonne, params array est encore générique, rendant IEnumerable l'habitude d'ajouter à son genericity. Peut-être que vous avez voulu dire la rendre plus générale (but).
InformationsquelleAutor Dested | 2010-01-24
  1. 97

    Pourquoi ne puis-je pas utiliser un IEnumerable avec params?

    La question présuppose que l'équipe de conception doit fournir une raison pour pas ajouter une fonctionnalité à la langue. Ce présupposé est faux.

    Plutôt, pour qu'une fonction soit utilisée par vous, il doit être pensé, conçu, a précisé, mise en œuvre, testé, documenté et expédiés. Toutes ces activités ont des coûts importants.

    La "params énumérable" a été pensé et conçu. Il n'a jamais été spécifié, mise en œuvre, testé, documenté ou expédiés.

    Par conséquent, vous ne pouvez pas utiliser la fonction.

    Mise à JOUR: cette écriture -- début de l'année 2015, a été spécifié, mais la mise en œuvre, les essais, la documentation et l'expédition ont été coupés pour C# 6.0 dans la dernière partie de 2014. Voir Lucian de l'annonce ici: http://roslyn.codeplex.com/discussions/568820.

    Depuis il n'a pas encore été mis en place, testé, documenté et expédié, il n'y a toujours pas de cette fonctionnalité. J'espère que cela va le faire dans un futur hypothétique version de C#.

    Mise à JOUR: je me dois de préciser ce que j'entends par "la fonction" puisque c'est possible, nous avons tous des idées différentes dans nos têtes que "la fonctionnalité" est. La fonctionnalité que je suis en train de parler de vous permettre de dire quelque chose comme

    void Frob(params IEnumerable<int> x)
{
    foreach(int y in x) ...
}

    et puis le site d'appel peut être soit dans la "forme normale" de passer d'une séquence d'entiers, ou de la "forme élargie" de Frob(10, 20, 30). Si dans la forme développée, le compilateur génère l'appel comme si vous avais dit Frob(new int[] { 10, 20, 30}), de la même façon que pour les param tableaux. Le point de la caractéristique est qu'il est souvent le cas que la méthode n'utilise jamais l'accès aléatoire à la matrice, et par conséquent, on pourrait affaiblir l'exigence que les params être un tableau. Les params pourrait être simplement une séquence à la place.

    Vous pouvez le faire aujourd'hui en faisant une surcharge:

    void Frob(params int[] x) { Frob((IEnumerable<int>)x); }

void Frob(IEnumerable<int> x)
{
    foreach(int y in x) ...
}

    qui est un peu de douleur. Nous pourrions tout simplement vous permettre d'utiliser IEnumerable comme le type de la params argument et être fait avec elle.

    Sera-ce jamais être corrigé?

    Je l'espère. Cette fonctionnalité a été sur la liste pendant une longue période. Il ferait beaucoup de fonctions de travail beaucoup plus parfaitement avec LINQ. 

    Frob(from c in customers select c.Age);

    sans avoir à écrire deux versions différentes de Frob.

    Cependant, il est un simple "petit confort" caractéristique; il ne fait pas ajouter tout un tas de nouveau pouvoir de la langue. C'est pourquoi il n'est jamais assez haut sur la liste de priorité pour se rendre à la "spécification est écrit" la scène.

    Je souhaite vraiment que de la réécrire les anciennes bibliothèques à l'utilisation des génériques.

    Noté.

    • La mise en œuvre de cette caractéristique fondamentalement signifie un appel implicite à ToArray, droit?
    • Je ne suis pas à la suite de votre train de pensée. Je pense que la réponse à votre question est "non", mais je ne suis pas sûr de ce que la question que vous posez cette question.
    • La méthode qui prend la params besoins d'une collection avec un accès aléatoire (pas l'avant-uniquement que l'interface IEnumerable offre), de sorte que le IEnumerable doit être réalisé dans une collection qui a tous les éléments de tous les temps. La façon la plus simple à mettre en œuvre ce serait de simplement appeler ToArray sur l'interface IEnumerable (ou quelque chose pour le même effet).
    • Pourquoi ne le destinataire de l'appel besoin que, nécessairement? La grande majorité des méthodes qui prennent params tableaux que j'ai jamais écrit juste en peluche que chose dans un foreach.
    • Je vois cela comme plus que juste une commodité, parce que vous êtes à la solution de contournement est cassé quand il y a un générique impliqués. Bon à savoir il est, au moins sur le radar. L'OMI, les params fonctionnalité doit avoir utilisé IEnumerable en premier lieu (même si je sais qu'à l'époque ce n'était pas une option).
    • Pour quelque chose d'aussi anodin que c'est comme une douleur dans le dos. Un correctif serait de simplifier grandement les Api... s'il vous Plaît corriger pour C# 5. S'il vous plaît?
    • Je viens de toucher le souhait pour cette fois encore aujourd'hui! (Et ce l'absence d'un facile/moyen propre à créer un seul élément énumérable est de commencer à faire de C# se sentir comme un “vieux” de la langue qui a eu linq boulonné sur..)
    • public static IEnumerable<T> Énumérer(ce T o) où T : nouveau { return new T[] {o}; } ou quelque chose de similaire (par l'écriture de ma tête) pourrait aider
    • dit "...le manque de facile/moyen propre à créer un seul élément énumérable". Je suis d'accord. Il serait agréable de type "*foo" et l'étendre à "Énumérable.Répéter(foo, 1)". Certains autres opérateur unaire serait acceptable! 😉
    • Je pense implicitement appel ToArray() serait une sorte de mal que de bien, car il avait à cacher le fait que l'énumération est entièrement réalisé par son passé. Cela rendrait impossible l'utilisation paresseusement chargé infini listes et gênant pour envoyer du lourd requêtes db qui n'ont pas besoin d'être tiré dans tous les cas.
    • La création d'un supplément de surcharge est toujours au moins un peu de gêne, mais parfois, c'est plus gênant, par exemple quand il y a déjà quelques surcharges de la méthode à des fins similaires.
    • Il ne peut pas ajouter beaucoup de puissance, mais il serait certainement faire beaucoup de situations moins ennuyeux.
    • Donc, à compter d'aujourd'Hui, Jan 2018 cette fonction est disponible ? Si non, alors n'importe où près de l'avenir ?
    • Toujours considérés comme faisant partie de la durée de travail je pense. Vérifiez le github forums.

    InformationsquelleAutor Eric Lippert
  2. 11

    Ah, je pense que je peut maintenant avoir compris ce que tu veux dire. Je pense que vous voulez être en mesure de déclarer une méthode comme ceci:

    public void Foo<T>(params IEnumerable<T> items)
{
}

    Et ensuite être capable de l'appeler avec un "normal" argument comme ceci:

    IEnumerable<string> existingEnumerable = ...;
Foo(existingEnumerable);

    ou avec plusieurs paramètres comme ceci:

    Foo("first", "second", "third");

    Est-ce que vous êtes après? (À noter que vous voudriez la première forme d'utilisation T=string, plutôt que de T=IEnumerable<string> avec un seul élément...)

    Si oui, je suis d'accord c' pourrait être utile - mais il est assez facile d'avoir:

    public void Foo<T>(params T[] items)
{
    Foo((IEnumerable<T>) items);
}

public void Foo<T>(IEnumerable<T> items)
{
}

    Je ne trouve pas que je le fais assez souvent pour faire le dessus d'une particulièrement laid solution de contournement.

    Noter que lors de l'appel le code ci-dessus, vous aurez envie de explicitement spécifier le type d'argument, pour éviter que le compilateur préférant la params exemple. Ainsi, par exemple:

    List<string> x = new List<string>();
Foo<string>(x);
    • Êtes-vous sûr que vous avez essayé cela? Quand je le fais il correspond à la params forme première d'ie, il correspond à public void Foo<IEnumerable<int>>(params IEnumerable<int>[])
    • Où ai-je jamais suggèrent params IEnumerable<int>[]?
    • Vous n'avez pas, mais Foo<T>(params T[] items) matchs en premier si T est IEnumerable<int> plutôt que Foo<T>(IEnumerable<T> items)
    • En fait, je viens de le tester à nouveau et l'a trouvé ne fonctionne pas mais dans mon code légèrement différent, il correspond à la bonne. Je vais passer un peu plus avec elle.
    • Ok testé encore, et trouve là où vous avez tort. Vous devez fournir exactement le type IEnumerable<T> plutôt que List<T> ou le compilateur préfère le params version. Voir gist.github.com/bradphelan/9fddca0fa5f1c07ba736 pour un fichier exécutable exemple
    • Ah, je vois ce que tu veux dire. C'est parce qu'il est générique. Si vous l'avez explicitement appel Foo<string> puis il travaille dans les deux cas. Je vais modifier ma réponse pour que ce soit clair.
    • D'avoir à spécifier l'argument de type générique est une bonne raison pourquoi params comme IEnumerable serait un bon ajout à la langue.
    • D'accord. Le compilateur accepte avec plaisir si vous ne spécifiez pas l'argument de type générique, et il échoue uniquement lors de l'exécution (qui, je l'espère dans un test unitaire, et non pas dans la production...).

    InformationsquelleAutor Jon Skeet
  3. 4

    Les paramètres les paramètres sont envoyés sous forme de tableau, et un IEnumerable<T> ne fournit pas l'accès aléatoire qui est requis d'agir comme un tableau.

    Vous devez créer le tableau à partir de l'interface IEnumerable lorsque vous appelez la méthode:

    TheMethod(theIEnumerable.ToArray());
    • Pourquoi ne peut-params paramètres réglés comme un IEnumerable<T> si c'est ce que la méthode de l'écrivain veut?
    • Ringrose: Une des raisons est que le IEnumerable<T> interface n'existait pas lors de params a été ajouté à la langue. Pourquoi il n'a pas été ajouté par la suite est probablement parce qu'il n'est pas très utile. Vous pouvez simplement ajouter une surcharge de soutenir à la fois params T[] et IEnumerable<T>.
    • Pourquoi le downvote? Si vous n'expliquez pas ce que c'est que vous pensez est faux, il ne peut pas améliorer la réponse.
    • non, vous ne pouvez pas surcharger -- le compilateur devient confus lorsque vous essayez de l'appeler et le fait de vous écrire un tas de supplémentaires de la syntaxe. -- Nous pourrions simplement ajouter .ToArray() -- ce qui est stupide.
    InformationsquelleAutor Guffa