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

Question

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

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

, но в конце концов он имеет только 1 элемент внутри.

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

как List<T>

Answer 1

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

IEnumerable<string> ReadLines() 
{ 
    string s; 
    do 
    { 
      s = Console.ReadLine(); 
      yield return s; 
    } while (s != ""); 
} 

IEnumerable<string> lines = ReadLines(); 
lines.Add("foo") // so what is this supposed to do?? 

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

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

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

Answer 2

Н.О. IEnumerable doens't поддерживает добавление в нее элементов.

«Альтернатива» у вас есть.

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

Answer 3

Тип 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"); 

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

EDIT

Я contstantly забывать, что Занести не типичный метод расширения на 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; 
} 

Answer 4

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

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

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

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

Answer 5

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

Answer 6

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

Answer 7

Пару короткие, сладкие методы расширения на 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); 
} 

Elegant (ну, для нетипичных версий, кроме). Слишком плохо, что эти методы не входят в BCL.

Answer 8

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

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

Answer 9

Easyest способ сделать это просто

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 интерфейс

Answer 10

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

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

Answer 11

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

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

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

Answer 12

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

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

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

Answer 13

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

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