Как я могу добавить элемент в коллекцию IEnumerable <T>?

Мой вопрос как заголовок выше. Например,

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

но в конце концов он имеет только 1 предмет внутри.

Можем ли мы иметь такой метод items.Add(item)?

словно List<T>

Вы не можете, потому IEnumerable<T>что не обязательно представляет коллекцию, в которую могут быть добавлены элементы. На самом деле, это вовсе не обязательно представляет коллекцию! Например:

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

Однако вы можете создать новый IEnumerable объект (неопределенного типа), который при перечислении предоставит все элементы старого, а также некоторые ваши собственные. Вы используете Enumerable.Concatдля этого:

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

Эта не изменит объект массива (в любом случае вы не можете вставлять элементы в массивы). Но он создаст новый объект, который перечислит все элементы в массиве, а затем "Foo". Кроме того, этот новый объект будет отслеживать изменения в массиве (т. Е. Всякий раз, когда вы его перечисляете, вы увидите текущие значения элементов).

Тип IEnumerable<T>не поддерживает такие операции. Назначение IEnumerable<T>интерфейса - позволить потребителю просматривать содержимое коллекции. Не изменять значения.

Когда вы выполняете такие операции, как .ToList (). Add (), вы создаете новый List<T>и добавляете значение в этот список. Это не имеет никакого отношения к первоначальному списку.

Что вы можете сделать, это использовать метод Add extension, чтобы создать новый IEnumerable<T>с добавленной стоимостью.

items = items.Add("msg2");

Даже в этом случае он не изменит оригинальный IEnumerable<T>объект. Это можно проверить, сохранив ссылку на него. Например

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

После этого набора операций переменная temp по-прежнему будет ссылаться только на перечислимое значение с одним элементом «foo» в наборе значений, в то время как элементы будут ссылаться на другое перечисляемое значение со значениями «foo» и «bar».

РЕДАКТИРОВАТЬ

Я постоянно забываю, что Add не является типичным методом расширения, IEnumerable<T>потому что это один из первых, который я в итоге определил. Вот

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

Рассматривали ли вы использование интерфейсов ICollection<T>или IList<T>вместо них, они существуют по той самой причине, что вы хотите иметь Addметод на IEnumerable<T>.

IEnumerable<T>используется, чтобы «пометить» тип как ... ну, перечисляемый или просто последовательность элементов, не обязательно делая какие-либо гарантии того, поддерживает ли реальный базовый объект добавление / удаление элементов. Также помните, что эти интерфейсы реализованы, IEnumerable<T>так что вы получаете все методы расширений, которые вы получаете IEnumerable<T>также.

Несколько коротких, приятных методов расширения IEnumerableи IEnumerable<T>сделайте это для меня:

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

Элегантный (ну, за исключением неуниверсальных версий). Жаль, что эти методы не в BCL.

В .net Core есть метод, Enumerable.Appendкоторый делает именно это.

Исходный код метода доступен на GitHub. .... Реализация (более сложная, чем предложения в других ответах) стоит посмотреть :).

Нет, IEnumerable не поддерживает добавление элементов к нему.

Вы «альтернатива» это:

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

Чтобы добавить второе сообщение, вам нужно -

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

Вы не только не можете добавлять элементы, как вы заявляете, но если вы добавляете элемент в List<T>(или почти в любую другую не доступную только для чтения коллекцию), для которой у вас есть существующий перечислитель, перечислитель становится недействительным ( InvalidOperationExceptionс тех пор включается ).

Если вы агрегируете результаты из какого-либо типа запроса данных, вы можете использовать Concatметод расширения:

Редактировать: я изначально использовал Unionрасширение в примере, что не совсем правильно. Мое приложение широко использует его, чтобы убедиться, что перекрывающиеся запросы не дублируют результаты.

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

Я просто пришел сюда, чтобы сказать, что, кроме Enumerable.Concatметода расширения, кажется, есть еще один метод, названный Enumerable.Appendв .NET Core 1.1.1. Последнее позволяет объединить один элемент в существующую последовательность. Так что ответ Аамола можно записать так:

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

Тем не менее, обратите внимание, что эта функция не изменит последовательность ввода, она просто вернет оболочку, которая соединит данную последовательность и добавленный элемент вместе.

Другие уже дали отличные объяснения относительно того, почему вы не можете (и не должны!) Добавлять элементы в IEnumerable. Я только добавлю, что если вы хотите продолжить кодирование в интерфейсе, представляющем коллекцию, и хотите добавить метод, вам следует написать код ICollectionили IList. В качестве дополнительного бонуса, эти интерфейсы реализуют IEnumerable.

ты можешь сделать это.

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

Самый простой способ сделать это просто

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

Затем вы можете вернуть список как IEnumerable также потому, что он реализует интерфейс IEnumerable

Если вы создаете свой объект как IEnumerable<int> Ones = new List<int>(); Тогда вы можете сделать((List<int>)Ones).Add(1);

Конечно, вы можете (я оставляю ваш T-бизнес в стороне):

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

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