Jak mogę dodać element do kolekcji IEnumerable <T>?

Moje pytanie jako tytuł powyżej. Na przykład,

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

ale w końcu ma tylko 1 przedmiot.

Czy możemy mieć taką metodę items.Add(item)?

podobnie jak List<T>

Nie możesz, ponieważ IEnumerable<T>niekoniecznie oznacza kolekcję, do której można dodać elementy. W rzeczywistości niekoniecznie reprezentuje kolekcję! Na przykład:

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

Możesz jednak utworzyć nowy IEnumerable obiekt (nieokreślonego typu), który po wyliczeniu dostarczy wszystkie elementy starego oraz niektóre własne. Używasz Enumerable.Concatdo tego:

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

To nie zmieni obiektu Array (nie można wstawiać elementy do do tablic, tak). Ale stworzy nowy obiekt, który wyświetli listę wszystkich elementów w tablicy, a następnie „Foo”. Ponadto ten nowy obiekt będzie śledził zmiany w tablicy (tzn. Ilekroć go wyliczysz, zobaczysz bieżące wartości elementów).

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

Wykonując operacje takie jak .ToList (). Add (), tworzysz nowy List<T>i dodajesz wartość do tej listy. Nie ma połączenia z oryginalną listą.

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

items = items.Add("msg2");

Nawet w tym przypadku nie zmodyfikuje oryginalnego IEnumerable<T>obiektu. Można to zweryfikować, 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 będzie nadal odwoływała się do wyliczenia z pojedynczym elementem „foo” w zbiorze wartości, podczas gdy pozycje będą odwoływać się do innego wyliczenia z wartościami „foo” i „bar”.

EDYTOWAĆ

Ciągle zapominam, że Add nie jest typową metodą rozszerzenia, IEnumerable<T>ponieważ jest to jedna z pierwszych metod, które ostatecznie definiuję. Oto 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 zastanawiałeś się nad użyciem ICollection<T>lub IList<T>interfejsów, istnieją one z tego samego powodu, dla którego chcesz mieć Addmetodę na IEnumerable<T>.

IEnumerable<T>służy do „oznaczania” typu jako… cóż, policzalnego lub tylko sekwencji elementów bez konieczności zapewnienia jakiejkolwiek gwarancji, czy prawdziwy obiekt leżący u podstaw obsługuje dodawanie / usuwanie elementów. Pamiętaj również, że te interfejsy są implementowane, IEnumerable<T>dzięki czemu otrzymujesz również wszystkie metody rozszerzeń IEnumerable<T>.

Kilka krótkich, słodkich metod przedłużania IEnumerablei 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 (cóż, z wyjątkiem nietypowych wersji). Szkoda, że ​​tych metod nie ma w BCL.

W .net Core istnieje metoda Enumerable.Append, która właśnie to robi.

Kod źródłowy metody jest dostępny na GitHub. .... Wdrożenie (bardziej wyrafinowane niż sugestie z innych odpowiedzi) jest warte obejrzenia :).

Nie IEnumerable nie obsługuje dodawania do niego elementów.

„Alternatywą” 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 w taki sposób, jak podajesz, ale jeśli dodasz element do List<T>(lub prawie każdej innej kolekcji nie tylko do odczytu), dla której masz istniejący moduł wyliczający, moduł wyliczający jest unieważniany ( InvalidOperationExceptionod tego momentu wyrzuca ).

Jeśli agregujesz wyniki z pewnego rodzaju zapytania o dane, możesz użyć Concatmetody rozszerzenia:

Edycja: pierwotnie użyłem Unionrozszerzenia w tym przykładzie, co nie jest tak naprawdę poprawne. Moja aplikacja korzysta z niego w szerokim zakresie, aby nakładające się zapytania nie dublowały wyników.

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

Przyszedłem tutaj, aby powiedzieć, że oprócz Enumerable.Concatmetody rozszerzenia, wydaje się, że istnieje inna metoda o nazwie Enumerable.Appendw .NET Core 1.1.1. Ta ostatnia pozwala połączyć jeden element z istniejącą sekwencją. Tak więc odpowiedź Aamola można również zapisać jako

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

Pamiętaj jednak, że ta funkcja nie zmieni sekwencji wejściowej, po prostu zwróci opakowanie, które połączy daną sekwencję i dołączony element.

Inni podali już świetne wyjaśnienia dotyczące tego, dlaczego nie możesz (i nie powinieneś!) Mieć możliwości dodawania elementów do IEnumerable. Dodam tylko, że jeśli chcesz kontynuować kodowanie do interfejsu reprezentującego kolekcję i chcesz dodać metodę, powinieneś kodować do ICollectionlub IList. Jako dodatkowa bonanza implementują te interfejsy IEnumerable.

możesz to zrobić.

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

Najłatwiejszym 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");

Następnie możesz zwrócić listę jako IEnumerable, ponieważ implementuje interfejs IEnumerable

Jeśli utworzysz obiekt tak, jak IEnumerable<int> Ones = new List<int>(); możesz, możesz to zrobić((List<int>)Ones).Add(1);

Jasne, że możesz (odkładam na bok swój biznes T):

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

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