Comment ajouter un élément à une collection IEnumerable<T> ?

Question

Ma question correspond au titre ci-dessus. Par exemple,

IEnumerable<T> items = new T[]{new T("msg")};
items.ToList().Add(new T("msg2"));

mais après tout, il n'y a qu'un seul objet à l'intérieur.

Peut-on avoir une méthode comme items.Add(item) ?

comme le List<T>

Answer 1

Vous ne pouvez pas, parce que IEnumerable<T> ne représente pas nécessairement une collection à laquelle on peut ajouter des éléments. En fait, il ne représente pas nécessairement une collection du tout ! Par exemple :

IEnumerable<string> ReadLines()
{
     string s;
     do
     {
          s = Console.ReadLine();
          yield return s;
     } while (!string.IsNullOrEmpty(s));
}

IEnumerable<string> lines = ReadLines();
lines.Add("foo") // so what is this supposed to do??

Ce que vous pouvez faire, en revanche, c'est créer un fichier nouveau IEnumerable (de type non spécifié), qui, lorsqu'il est énuméré, fournira tous les éléments de l'ancien, plus certains des vôtres. Vous utilisez Enumerable.Concat pour ça :

 items = items.Concat(new[] { "foo" });

Ce site ne modifiera pas l'objet tableau (de toute façon, vous ne pouvez pas insérer d'éléments dans les tableaux to). Mais il créera un nouvel objet qui listera tous les éléments du tableau, et ensuite "Foo". De plus, ce nouvel objet garder la trace des changements dans le tableau (c'est-à-dire qu'à chaque fois que vous l'énumérerez, vous verrez les valeurs actuelles des éléments).

Answer 2

Le type IEnumerable<T> ne prend pas en charge de telles opérations. Le but de la IEnumerable<T> est de permettre à un consommateur de visualiser le contenu d'une collection. Pas de modifier les valeurs.

Lorsque vous effectuez des opérations telles que .ToList().Add(), vous créez un nouveau fichier de type List<T> et en ajoutant une valeur à cette liste. Il n'y a aucun lien avec la liste d'origine.

Ce que vous pouvez faire est d'utiliser la méthode d'extension Add pour créer une nouvelle IEnumerable<T> avec la valeur ajoutée.

items = items.Add("msg2");

Même dans ce cas, il ne modifiera pas l'original. IEnumerable<T> objet. Cela peut être vérifié en détenant une référence à cet objet. Par exemple

var items = new string[]{"foo"};
var temp = items;
items = items.Add("bar");

Après cet ensemble d'opérations, la variable temp ne fera toujours référence qu'à un énumérable avec un seul élément "foo" dans l'ensemble de valeurs, tandis que les éléments feront référence à un énumérable différent avec les valeurs "foo" et "bar".

EDIT

J'oublie constamment que la méthode Add n'est pas une méthode d'extension typique de l'application IEnumerable<T> parce que c'est l'un des premiers que je finis par définir. Le voici

public static IEnumerable<T> Add<T>(this IEnumerable<T> e, T value) {
  foreach ( var cur in e) {
    yield return cur;
  }
  yield return value;
}

Answer 3

Avez-vous envisagé d'utiliser ICollection<T> o IList<T> Au lieu de cela, les interfaces existent pour la raison même que vous voulez avoir une Add sur un IEnumerable<T> .

IEnumerable<T> est utilisé pour "marquer" un type comme étant... énumérable ou simplement une séquence d'éléments sans nécessairement garantir que l'objet sous-jacent réel supporte l'ajout/le retrait d'éléments. Rappelez-vous également que ces interfaces mettent en œuvre IEnumerable<T> de sorte que vous obtenez toutes les méthodes d'extension que vous obtenez avec IEnumerable<T> également.

Answer 4

Quelques méthodes d'extension courtes et douces sur IEnumerable y IEnumerable<T> fais-le pour moi :

public static IEnumerable Append(this IEnumerable first, params object[] second)
{
    return first.OfType<object>().Concat(second);
}
public static IEnumerable<T> Append<T>(this IEnumerable<T> first, params T[] second)
{
    return first.Concat(second);
}   
public static IEnumerable Prepend(this IEnumerable first, params object[] second)
{
    return second.Concat(first.OfType<object>());
}
public static IEnumerable<T> Prepend<T>(this IEnumerable<T> first, params T[] second)
{
    return second.Concat(first);
}

Élégant (enfin, sauf pour les versions non génériques). Dommage que ces méthodes ne soient pas dans la BCL.

Answer 5

Non, l'IEnumerable ne permet pas d'ajouter des éléments.

Votre "alternative" est :

var myList = new List(items);
myList.Add(otherItem);