Як я можу додати предмет до колекції 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>і додаєте значення до цього списку. Він не має зв'язку з оригінальним списком.

Що ви можете зробити, це використовувати метод Додати розширення для створення нового IEnumerable<T>з доданою вартістю.

items = items.Add("msg2");

Навіть у цьому випадку він не змінює оригінальний IEnumerable<T>об'єкт. Це можна перевірити, посилаючись на нього. Наприклад

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

Після цього набору операцій змінна temp все ще посилатиметься лише на перелік з одним елементом "foo" у наборі значень, тоді як елементи будуть посилатись на інше число із значеннями "foo" та "bar".

EDIT

Я безперечно забуваю, що 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);
}

Елегантний (ну, крім випадків, що не є загальними). Шкода, що ці методи відсутні в БКЛ.

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