Como posso adicionar um item a uma coleção IEnumerable <T>?

Minha pergunta como título acima. Por exemplo,

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

mas afinal ele tem apenas 1 item dentro.

Podemos ter um método como items.Add(item)?

como o List<T>

Você não pode, porque IEnumerable<T>não representa necessariamente uma coleção à qual itens podem ser adicionados. De fato, não representa necessariamente uma coleção! Por exemplo:

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

O que você pode fazer, no entanto, é criar um novo IEnumerable objeto (de tipo não especificado), que, quando enumerado, fornecerá todos os itens do antigo, além de alguns dos seus. Você usa Enumerable.Concatpara isso:

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

Isso não altera o objeto da matriz (você não pode inserir itens nas matrizes, de qualquer maneira). Mas ele criará um novo objeto que listará todos os itens da matriz e, em seguida, "Foo". Além disso, esse novo objeto acompanhará as alterações na matriz (ou seja, sempre que você a enumerar, você verá os valores atuais dos itens).

O tipo IEnumerable<T>não suporta essas operações. O objetivo da IEnumerable<T>interface é permitir que um consumidor visualize o conteúdo de uma coleção. Não para modificar os valores.

Ao executar operações como .ToList (). Add (), você cria um novo List<T>e adiciona um valor a essa lista. Não tem conexão com a lista original.

O que você pode fazer é usar o método Add extension para criar um novo IEnumerable<T>com o valor agregado.

items = items.Add("msg2");

Mesmo nesse caso, ele não modificará o IEnumerable<T>objeto original . Isso pode ser verificado mantendo uma referência a ele. Por exemplo

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

Após esse conjunto de operações, a variável temp ainda fará referência a um enumerável com um único elemento "foo" no conjunto de valores, enquanto os itens farão referência a um enumerável diferente com os valores "foo" e "bar".

EDITAR

Eu sempre esqueço que o Add não é um método de extensão típico, IEnumerable<T>porque é um dos primeiros que eu acabo definindo. Aqui está

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

Você já pensou em usar interfaces ICollection<T>ou IList<T>, em vez disso, elas existem pelo mesmo motivo que você deseja ter um Addmétodo em uma IEnumerable<T>.

IEnumerable<T>é usado para 'marcar' um tipo como sendo ... bem, enumerável ou apenas uma sequência de itens sem necessariamente garantir que o objeto subjacente real suporte a adição / remoção de itens. Lembre-se também de que essas interfaces são implementadas IEnumerable<T>para que você obtenha todos os métodos de extensão com os IEnumerable<T>quais também se relaciona.

Alguns métodos de extensão curtos IEnumerablee IEnumerable<T>agradáveis ​​estão disponíveis para mim:

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

Elegante (bem, exceto para as versões não genéricas). Pena que esses métodos não estão no BCL.

No .net Core, existe um método Enumerable.Appendque faz exatamente isso.

O código fonte do método está disponível no GitHub. .... A implementação (mais sofisticada do que as sugestões em outras respostas) vale a pena dar uma olhada :).

Não, o IEnumerable não oferece suporte à adição de itens.

Você 'alternativa' é:

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

Para adicionar a segunda mensagem, você precisa -

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

Não apenas você não pode adicionar itens como você declara, mas se você adicionar um item a List<T>(ou praticamente qualquer outra coleção não somente leitura) para a qual você tem um enumerador existente, o enumerador será invalidado (será lançado a InvalidOperationExceptionpartir de então).

Se você estiver agregando resultados de algum tipo de consulta de dados, poderá usar o Concatmétodo de extensão:

Editar: originalmente usei a Unionextensão no exemplo, o que não é realmente correto. Meu aplicativo o usa extensivamente para garantir que as consultas sobrepostas não duplicem os resultados.

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

Eu só vim aqui para dizer que, além do Enumerable.Concatmétodo de extensão, parece haver outro método nomeado Enumerable.Appendno .NET Core 1.1.1. O último permite concatenar um único item para uma sequência existente. Portanto, a resposta de Aamol também pode ser escrita como

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

Ainda assim, observe que esta função não altera a sequência de entrada, apenas retorna um wrapper que coloca a sequência fornecida e o item anexado.

Outros já deram grandes explicações sobre por que você não pode (e não deveria!) Ser capaz de adicionar itens a um IEnumerable. Acrescentarei apenas que, se você deseja continuar codificando para uma interface que representa uma coleção e deseja um método add, deve codificar para ICollectionor IList. Como uma vantagem adicional, essas interfaces são implementadas IEnumerable.

você consegue fazer isso.

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

A maneira mais fácil de fazer isso é simplesmente

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

Em seguida, você pode retornar a lista como IEnumerable também porque implementa a interface IEnumerable

Se você criar seu objeto como IEnumerable<int> Ones = new List<int>(); Então você pode fazer((List<int>)Ones).Add(1);

Claro, você pode (estou deixando seu negócio de lado):

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

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