Jak Mogę dodać przedmiot do kolekcji IEnumerable?

Typ IEnumerable<T> nie obsługuje takich operacji. Celem interfejsu IEnumerable<T> jest umożliwienie konsumentowi przeglądania zawartości kolekcji. Nie modyfikować wartości.

Kiedy robisz operacje jak .ToList().Add() tworzysz nową List<T> i dodajesz wartość do tej listy. Nie ma połączenia z oryginalną listą.

Możesz użyć metody Add extension, aby utworzyć nową IEnumerable<T> z wartością dodaną.

items = items.Add("msg2");

Nawet w tym przypadku nie będzie zmodyfikuj oryginalny obiekt IEnumerable<T>. Można to sprawdzić, trzymając odniesienie do niego. Na przykład

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

Po Tym Zestawie operacji zmienna temp nadal będzie odwoływać się tylko do wyliczenia z pojedynczym elementem " foo "w zestawie wartości, podczas gdy pozycje będą odwoływać się do innego wyliczenia z wartościami" foo "i"bar".

EDIT

Zapominam, że Add nie jest typową metodą rozszerzenia na IEnumerable<T>, ponieważ jest jedną z pierwszych, które kończę definiowanie. Tutaj jest

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

Czy rozważałeś użycie ICollection lub IList interfejsów zamiast tego, istnieją one z tego powodu, że chcesz mieć metodę 'Add' na liczbach. IEnumerable jest używany do 'oznaczania' typu jako będącego ...cóż.. enumerable lub po prostu Sekwencja elementów bez konieczności podejmowania jakichkolwiek gwarancji, czy rzeczywisty obiekt bazowy obsługuje dodawanie / usuwanie elementów. Pamiętaj również, że te interfejsy implementują IEnumerable, więc otrzymasz wszystkie rozszerzenia metody, które można uzyskać z IEnumerable, jak również.

Kilka krótkich, słodkich metod przedłużania na IEnumerable i IEnumerable<T> Zrób to dla mnie:

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

Elegancki (no, z wyjątkiem wersji nie-generycznych). Szkoda, że tych metod nie ma w BCL.

No Theenumerable doens not support adding items to items.

"alternatywą", którą masz, jest.

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

Aby dodać drugą wiadomość musisz -

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

Nie tylko nie możesz dodawać elementów takich jak stan, ale jeśli dodasz element do List<T> (lub prawie każdej innej kolekcji nie tylko do odczytu), dla której masz istniejący licznik, licznik jest unieważniany (od tego momentu rzuca InvalidOperationException).

Jeśli agregujesz wyniki z jakiegoś typu zapytania o dane, możesz użyć metody rozszerzenia Concat:

Edit: pierwotnie użyłem rozszerzenia Union w przykładzie, które nie jest do końca poprawne. Moja aplikacja używa go szeroko, aby na pewno nakładające się zapytania nie powielają wyników.

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

W. Net Core istnieje metoda Enumerable.Append, która dokładnie to robi.

Kod źródłowy metody jest dostępny na Githubie..... Warto zajrzeć do realizacji (bardziej wyrafinowanej niż sugestie w innych odpowiedziach):).

Inni już dali świetne wyjaśnienia, dlaczego nie możesz (i nie powinieneś!) możliwość dodawania elementów do IEnumerable. Dodam tylko, że jeśli chcesz kontynuować kodowanie do interfejsu, który reprezentuje kolekcję i chcesz metody add, powinieneś kodować do ICollection lub IList. Jako dodatkowy bonanza, interfejsy te implementują IEnumerable.

Przyszedłem tylko powiedzieć, że oprócz metody rozszerzenia Enumerable.Concat, wydaje się, że w.NET Core 1.1.1 istnieje inna metoda o nazwie Enumerable.Append. Ta ostatnia pozwala połączyć pojedynczy element z istniejącą sekwencją. Tak więc odpowiedź Aamola może być również zapisana jako

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

Należy jednak pamiętać, że ta funkcja nie zmieni sekwencji wejściowej, po prostu zwraca opakowanie, które umieszcza daną sekwencję i Dołączony element razem.

Dasz radę.

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

Najprostszym sposobem na to jest po prostu

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

Wtedy możesz zwrócić listę jako IEnumerable również dlatego, że implementuje on interfejs IEnumerable

Jasne, że możesz (zostawiam twój t-biznes na bok):

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

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