Wie kann ich ein Element zu einer IEnumerable <T> -Sammlung hinzufügen?

Meine Frage als Titel oben. Zum Beispiel,

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

aber es hat doch nur 1 artikel drin.

Können wir eine Methode wie haben items.Add(item)?

wie List<T>

Sie können nicht, da IEnumerable<T>dies nicht unbedingt eine Sammlung darstellt, zu der Elemente hinzugefügt werden können. Tatsächlich handelt es sich nicht unbedingt um eine Sammlung! Zum Beispiel:

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

Sie können jedoch ein neues IEnumerable Objekt (vom nicht angegebenen Typ) erstellen , das bei Aufzählung alle Elemente des alten sowie einige Ihrer eigenen Objekte bereitstellt. Sie verwenden Enumerable.Concatdafür:

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

Dadurch wird das Array-Objekt nicht geändert (Sie können ohnehin keine Elemente in Arrays einfügen). Es wird jedoch ein neues Objekt erstellt, das alle Elemente im Array auflistet, und dann "Foo". Darüber hinaus verfolgt dieses neue Objekt Änderungen im Array (dh, wann immer Sie es aufzählen, werden die aktuellen Werte von Elementen angezeigt).

Der Typ IEnumerable<T>unterstützt solche Operationen nicht. Der Zweck der IEnumerable<T>Schnittstelle besteht darin, einem Verbraucher das Anzeigen des Inhalts einer Sammlung zu ermöglichen. Die Werte nicht ändern.

Wenn Sie Vorgänge wie .ToList (). Add () ausführen, erstellen Sie eine neue List<T>und fügen dieser Liste einen Wert hinzu. Es besteht keine Verbindung zur ursprünglichen Liste.

Was Sie tun können, ist die Erweiterungsmethode Hinzufügen, um eine neue IEnumerable<T>mit dem Mehrwert zu erstellen .

items = items.Add("msg2");

Auch in diesem Fall wird das ursprüngliche IEnumerable<T>Objekt nicht geändert . Dies kann überprüft werden, indem ein Verweis darauf gehalten wird. Zum Beispiel

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

Nach diesem Satz von Operationen verweist die Variable temp immer noch nur auf eine Aufzählung mit einem einzelnen Element "foo" im Wertesatz, während Elemente auf eine andere Aufzählung mit den Werten "foo" und "bar" verweisen.

BEARBEITEN

Ich vergesse immer wieder, dass Add keine typische Erweiterungsmethode ist, IEnumerable<T>da es eine der ersten ist, die ich am Ende definiere. Hier ist es

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

Haben Sie darüber nachgedacht, stattdessen ICollection<T>oder IList<T>Schnittstellen zu verwenden, existieren diese genau aus dem Grund, aus dem Sie eine AddMethode für eine haben möchten IEnumerable<T>.

IEnumerable<T>wird verwendet, um einen Typ als ... gut, aufzählbar oder nur als eine Folge von Elementen zu markieren, ohne unbedingt zu garantieren, ob das eigentliche zugrunde liegende Objekt das Hinzufügen / Entfernen von Elementen unterstützt. Denken Sie auch daran, dass diese Schnittstellen implementiert werden, IEnumerable<T>sodass Sie auch alle Erweiterungsmethoden erhalten, mit denen Sie arbeiten IEnumerable<T>.

Ein paar kurze, süße Verlängerungsmethoden IEnumerableund IEnumerable<T>mach es für mich:

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

Elegant (naja, bis auf die nicht generischen Versionen). Schade, dass diese Methoden nicht in der BCL enthalten sind.

In .net Core gibt es eine Methode Enumerable.Append, die genau das tut.

Der Quellcode der Methode ist auf GitHub verfügbar. .... Die Implementierung (ausgefeilter als die Vorschläge in anderen Antworten) ist einen Blick wert :).

Nein, die IEnumerable unterstützt das Hinzufügen von Elementen nicht.

Ihre "Alternative" ist:

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

Um eine zweite Nachricht hinzuzufügen, müssen Sie -

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

Sie können nicht nur keine Elemente hinzufügen, wie Sie angeben, sondern wenn Sie ein Element zu einer List<T>(oder so ziemlich jeder anderen nicht schreibgeschützten Sammlung) hinzufügen, für die Sie einen vorhandenen Enumerator haben, wird der Enumerator ungültig (wirft InvalidOperationExceptionfortan).

Wenn Sie Ergebnisse aus einer Datenabfrage aggregieren, können Sie die ConcatErweiterungsmethode verwenden:

Bearbeiten: Ich habe ursprünglich die UnionErweiterung im Beispiel verwendet, was nicht wirklich korrekt ist. Meine Anwendung verwendet es ausgiebig, um sicherzustellen, dass überlappende Abfragen keine doppelten Ergebnisse liefern.

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

Ich komme nur hierher, um zu sagen, dass es neben der Enumerable.ConcatErweiterungsmethode eine andere Methode mit dem Namen Enumerable.Append.NET Core 1.1.1 zu geben scheint . Mit letzterem können Sie ein einzelnes Element mit einer vorhandenen Sequenz verknüpfen. So kann Aamols Antwort auch geschrieben werden als

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

Beachten Sie jedoch, dass diese Funktion die Eingabesequenz nicht ändert, sondern lediglich einen Wrapper zurückgibt, der die angegebene Sequenz und das angehängte Element zusammenfügt.

Andere haben bereits großartige Erklärungen gegeben, warum Sie nicht in der Lage sein können (und sollten!), Elemente zu einem hinzuzufügen IEnumerable. Ich will nur noch hinzufügen , dass , wenn Sie Codierung an eine Schnittstelle weiterhin suchen, der eine Sammlung und wollen ein Add - Methode darstellt, sollten Sie codieren ICollectionoder IList. Als zusätzliche Goldgrube implementieren diese Schnittstellen IEnumerable.

du kannst das.

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

Der einfachste Weg, dies zu tun, ist einfach

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

Dann können Sie list als IEnumerable zurückgeben, auch weil es die IEnumerable-Schnittstelle implementiert

Wenn Sie Ihr Objekt als IEnumerable<int> Ones = new List<int>(); Dann erstellen, können Sie dies tun((List<int>)Ones).Add(1);

Sicher können Sie (ich lasse Ihr T-Geschäft beiseite):

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

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