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

Ma question comme 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'a qu'un seul élément à l'intérieur.

Pouvons-nous avoir une méthode comme items.Add(item)?

comme le List<T>

Vous ne pouvez pas, car IEnumerable<T>ne représente pas nécessairement une collection à laquelle des éléments peuvent être ajoutés. En fait, ce n'est pas du tout une collection! 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, cependant, est de créer un nouvel IEnumerable objet (de type non spécifié), qui, une fois énuméré, fournira tous les éléments de l'ancien, ainsi que certains des vôtres. Vous utilisez Enumerable.Concatpour cela:

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

Cela ne changera pas l'objet tableau (vous ne pouvez pas insérer d'éléments dans des tableaux, de toute façon). Mais cela créera un nouvel objet qui listera tous les éléments du tableau, puis "Foo". De plus, ce nouvel objet gardera une trace des changements dans le tableau (c'est-à-dire que chaque fois que vous l'énumérez, vous verrez les valeurs actuelles des éléments).

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

Lorsque vous effectuez des opérations comme .ToList (). Add (), vous créez une nouvelle List<T>et ajoutez une valeur à cette liste. Il n'a aucun lien avec la liste d'origine.

Ce que vous pouvez faire, c'est utiliser la méthode Ajouter une extension pour en créer un nouveau IEnumerable<T>avec la valeur ajoutée.

items = items.Add("msg2");

Même dans ce cas, cela ne modifiera pas l' IEnumerable<T>objet d' origine . Cela peut être vérifié en y tenant une référence. 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 autre énumérable avec les valeurs "foo" et "bar".

ÉDITER

J'oublie toujours que Add n'est pas une méthode d'extension typique IEnumerable<T>car c'est l'une des premières que je finis par définir. C'est ici

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

Avez-vous envisagé d'utiliser ICollection<T>ou des IList<T>interfaces à la place, elles existent pour la seule raison que vous souhaitez avoir une Addméthode sur un IEnumerable<T>.

IEnumerable<T>est utilisé pour «marquer» un type comme étant ... enfin, énumérable ou simplement une séquence d'éléments sans nécessairement garantir que le véritable objet sous-jacent prend en charge l'ajout / la suppression d'éléments. Souvenez-vous également que ces interfaces implémentent IEnumerable<T>donc vous obtenez également toutes les méthodes d'extensions que vous obtenez IEnumerable<T>.

Quelques méthodes d'extension courtes et douces IEnumerableet IEnumerable<T>faites-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.

Dans .net Core, il existe une méthode Enumerable.Appendqui fait exactement cela.

Le code source de la méthode est disponible sur GitHub. .... L'implémentation (plus sophistiquée que les suggestions des autres réponses) vaut le détour :).

Non, l'IEnumerable ne prend pas en charge l'ajout d'éléments.

Votre «alternative» est:

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

Pour ajouter un deuxième message, vous devez -

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

Non seulement vous ne pouvez pas ajouter des éléments comme vous le déclarez, mais si vous ajoutez un élément à une List<T>(ou à peu près toute autre collection non en lecture seule) pour laquelle vous avez un énumérateur existant, l'énumérateur est invalidé (jetteInvalidOperationException partir de là).

Si vous regroupez les résultats d'un certain type de requête de données, vous pouvez utiliser le Concat méthode d'extension:

Edit: j'ai utilisé à l'origine l' Unionextension dans l'exemple, ce qui n'est pas vraiment correct. Mon application l'utilise largement pour s'assurer que les requêtes qui se chevauchent ne reproduisent pas les résultats.

IEnumerable<T> itemsA = ...;
IEnumerable<T> itemsB = ...;
IEnumerable<T> itemsC = ...;
return itemsA.Concat(itemsB).Concat(itemsC);

Je viens ici pour dire que, à part la Enumerable.Concatméthode d'extension, il semble y avoir une autre méthode nommée Enumerable.Appenddans .NET Core 1.1.1. Ce dernier vous permet de concaténer un seul élément à une séquence existante. Donc, la réponse d'Aamol peut également être écrite comme

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

Néanmoins, veuillez noter que cette fonction ne changera pas la séquence d'entrée, elle renvoie simplement un wrapper qui associe la séquence donnée et l'élément ajouté.

D'autres ont déjà donné de grandes explications sur les raisons pour lesquelles vous ne pouvez pas (et ne devriez pas!) Être en mesure d'ajouter des éléments à un IEnumerable. J'ajouterai seulement que si vous cherchez à continuer de coder vers une interface qui représente une collection et que vous voulez une méthode add, vous devez coder vers ICollectionou IList. Comme une aubaine supplémentaire, ces interfaces implémentent IEnumerable.

tu peux le faire.

//Create IEnumerable    
IEnumerable<T> items = new T[]{new T("msg")};

//Convert to list.
List<T> list = items.ToList();

//Add new item to list.
list.add(new T("msg2"));

//Cast list to IEnumerable
items = (IEnumerable<T>)items;

Le moyen le plus simple de le faire est tout simplement

IEnumerable<T> items = new T[]{new T("msg")};
List<string> itemsList = new List<string>();
itemsList.AddRange(items.Select(y => y.ToString()));
itemsList.Add("msg2");

Ensuite, vous pouvez renvoyer la liste sous la forme IEnumerable, car elle implémente l'interface IEnumerable

Si vous créez votre objet comme IEnumerable<int> Ones = new List<int>(); alors vous pouvez le faire((List<int>)Ones).Add(1);

Bien sûr, vous pouvez (je laisse votre T-business de côté):

public IEnumerable<string> tryAdd(IEnumerable<string> items)
{
    List<string> list = items.ToList();
    string obj = "";
    list.Add(obj);

    return list.Select(i => i);
}