Come posso aggiungere un elemento a una raccolta IEnumerable <T>?

La mia domanda come titolo sopra. Per esempio,

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

ma dopotutto contiene solo 1 oggetto.

Possiamo avere un metodo simile items.Add(item)?

come il List<T>

Non è possibile, poiché IEnumerable<T>non rappresenta necessariamente una raccolta a cui è possibile aggiungere elementi. In realtà, non rappresenta necessariamente una collezione! Per esempio:

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??

Quello che puoi fare, tuttavia, è creare un nuovo IEnumerable oggetto (di tipo non specificato) che, quando elencato, fornirà tutti gli elementi di quello vecchio, oltre a alcuni dei tuoi. Usi Enumerable.Concatper quello:

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

Ciò non modificherà l'oggetto array (non è possibile inserire comunque elementi negli array). Ma creerà un nuovo oggetto che elencherà tutti gli elementi dell'array e quindi "Foo". Inoltre, quel nuovo oggetto terrà traccia delle modifiche nell'array (cioè ogni volta che lo enumererai, vedrai i valori correnti degli elementi).

Il tipo IEnumerable<T>non supporta tali operazioni. Lo scopo IEnumerable<T>dell'interfaccia è consentire a un consumatore di visualizzare il contenuto di una raccolta. Non modificare i valori.

Quando esegui operazioni come .ToList (). Aggiungi () stai creando un nuovo List<T>e aggiungendo un valore a quell'elenco . Non ha alcun collegamento con l'elenco originale.

Quello che puoi fare è usare il metodo di estensione Aggiungi per crearne uno nuovo IEnumerable<T>con il valore aggiunto.

items = items.Add("msg2");

Anche in questo caso non modificherà l' IEnumerable<T>oggetto originale . Questo può essere verificato tenendo un riferimento ad esso. Per esempio

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

Dopo questo insieme di operazioni, la variabile temp farà ancora riferimento a un enumerabile con un singolo elemento "foo" nell'insieme di valori mentre gli elementi faranno riferimento a un diverso enumerabile con valori "foo" e "bar".

MODIFICARE

Dimentico costantemente che Aggiungi non è un tipico metodo di estensione IEnumerable<T>perché è uno dei primi che finisco per definire. Ecco qui

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

Hai preso in considerazione l'utilizzo ICollection<T>o le IList<T>interfacce invece, esistono proprio per il motivo per cui vuoi avere un Addmetodo su un IEnumerable<T>.

IEnumerable<T>viene utilizzato per "contrassegnare" un tipo come ... beh, enumerabile o solo una sequenza di elementi senza necessariamente fornire garanzie sul fatto che l'oggetto reale sottostante supporti l'aggiunta / rimozione di elementi. Ricorda inoltre che queste interfacce implementano in IEnumerable<T>modo da ottenere anche tutti i metodi di estensione che ottieni IEnumerable<T>.

Un paio di metodi di estensione brevi e dolci IEnumerablee IEnumerable<T>fallo per me:

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);
}

Elegante (bene, tranne per le versioni non generiche). Peccato che questi metodi non siano nel BCL.

In .net Core, esiste un metodo Enumerable.Appendche fa esattamente questo.

Il codice sorgente del metodo è disponibile su GitHub. .... L'implementazione (più sofisticata dei suggerimenti in altre risposte) merita una visita :).

No, IEnumerable non supporta l'aggiunta di elementi ad esso.

La tua "alternativa" è:

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

Per aggiungere un secondo messaggio devi:

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

Non solo non è possibile aggiungere elementi come si afferma, ma se si aggiunge un elemento a List<T>(o praticamente a qualsiasi altra raccolta di sola lettura) per cui si dispone di un enumeratore esistente, l'enumeratore viene invalidato (generato InvalidOperationExceptionda allora in poi).

Se si stanno aggregando risultati da un tipo di query di dati, è possibile utilizzare il Concatmetodo di estensione:

Modifica: inizialmente ho usato l' Unionestensione nell'esempio, che non è proprio corretta. La mia applicazione lo utilizza ampiamente per assicurarsi che le query sovrapposte non duplicino i risultati.

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

Vengo solo qui per dire che, oltre al Enumerable.Concatmetodo di estensione, sembra esserci un altro metodo chiamato Enumerable.Appendin .NET Core 1.1.1. Quest'ultimo consente di concatenare un singolo elemento in una sequenza esistente. Quindi la risposta di Aamol può anche essere scritta come

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

Tuttavia, si noti che questa funzione non modificherà la sequenza di input, ma restituirà semplicemente un wrapper che mette insieme la sequenza data e l'elemento aggiunto.

Altri hanno già dato grandi spiegazioni sul perché non puoi (e non dovresti!) Essere in grado di aggiungere elementi a un IEnumerable. Aggiungerò che se stai cercando di continuare a scrivere codice su un'interfaccia che rappresenta una raccolta e desideri un metodo di aggiunta, dovresti scrivere il codice ICollectiono IList. Come ulteriore bonanza, queste interfacce implementano IEnumerable.

Puoi farlo.

//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;

Il modo più semplice per farlo è semplicemente

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

Quindi è possibile restituire l'elenco come IEnumerable anche perché implementa l'interfaccia IEnumerable

Se crei il tuo oggetto come IEnumerable<int> Ones = new List<int>(); Allora puoi farlo((List<int>)Ones).Add(1);

Certo, puoi (lascio da parte la tua T-business):

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

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