¿Cómo puedo agregar un elemento a una colección IEnumerable <T>?

Mi pregunta como título arriba. Por ejemplo,

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

pero después de todo, solo tiene 1 elemento dentro.

¿Podemos tener un método como items.Add(item)?

como el List<T>

No puede, porque IEnumerable<T>no representa necesariamente una colección a la que se pueden agregar elementos. De hecho, ¡no representa necesariamente una colección en absoluto! Por ejemplo:

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

Sin embargo, lo que puede hacer es crear un nuevo IEnumerable objeto (de tipo no especificado) que, cuando se enumera, proporcionará todos los elementos del anterior, más algunos propios. Usas Enumerable.Concatpara eso:

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

Esto no cambiará el objeto de matriz (de todos modos, no puede insertar elementos en las matrices). Pero creará un nuevo objeto que enumerará todos los elementos de la matriz y luego "Foo". Además, ese nuevo objeto hará un seguimiento de los cambios en la matriz (es decir, cada vez que lo enumere, verá los valores actuales de los elementos).

El tipo IEnumerable<T>no admite tales operaciones. El propósito de la IEnumerable<T>interfaz es permitir que un consumidor vea el contenido de una colección. No modificar los valores.

Cuando realiza operaciones como .ToList (). Add (), está creando una nueva List<T>y agregando un valor a esa lista. No tiene conexión con la lista original.

Lo que puede hacer es usar el método Agregar extensión para crear uno nuevo IEnumerable<T>con el valor agregado.

items = items.Add("msg2");

Incluso en este caso no modificará el IEnumerable<T>objeto original . Esto se puede verificar manteniendo una referencia a él. Por ejemplo

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

Después de este conjunto de operaciones, la variable temp solo hará referencia a un enumerable con un solo elemento "foo" en el conjunto de valores, mientras que los elementos harán referencia a un enumerable diferente con los valores "foo" y "bar".

EDITAR

Continuamente olvido que Agregar no es un método de extensión típico IEnumerable<T>porque es uno de los primeros que termino definiendo. Aquí está

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

¿Ha considerado usar interfaces ICollection<T>o IList<T>, en cambio, existen por la misma razón que desea tener un Addmétodo en un IEnumerable<T>.

IEnumerable<T>se usa para 'marcar' un tipo como ... bueno, enumerable o simplemente una secuencia de elementos sin necesariamente garantizar si el objeto subyacente real admite la adición / eliminación de elementos. También recuerde que estas interfaces se implementan IEnumerable<T>para que también obtenga todos los métodos de extensiones que obtiene IEnumerable<T>.

Un par de métodos de extensión cortos y dulces IEnumerabley IEnumerable<T>hazlo por mí:

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 (bueno, excepto las versiones no genéricas). Lástima que estos métodos no están en el BCL.

En .net Core, hay un método Enumerable.Appendque hace exactamente eso.

El código fuente del método está disponible en GitHub. .... Vale la pena echarle un vistazo a la implementación (más sofisticada que las sugerencias en otras respuestas) :).

No, el IEnumerable no admite agregarle elementos.

Su 'alternativa' es:

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

Para agregar un segundo mensaje necesita:

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

No solo no puede agregar elementos como List<T>dice , sino que si agrega un elemento a una (o prácticamente cualquier otra colección que no sea de solo lectura) para la que tiene un enumerador existente, el enumerador se invalida (se lanza a InvalidOperationExceptionpartir de ese momento).

Si está agregando resultados de algún tipo de consulta de datos, puede usar el Concatmétodo de extensión:

Editar: Originalmente usé la Unionextensión en el ejemplo, que no es realmente correcta. Mi aplicación lo utiliza ampliamente para asegurar que las consultas superpuestas no dupliquen los resultados.

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

Solo vine a decir que, aparte del Enumerable.Concatmétodo de extensión, parece haber otro método nombrado Enumerable.Appenden .NET Core 1.1.1. Este último le permite concatenar un solo elemento a una secuencia existente. Entonces la respuesta de Aamol también se puede escribir como

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

Aún así, tenga en cuenta que esta función no cambiará la secuencia de entrada, solo devolverá un contenedor que juntará la secuencia dada y el elemento adjunto.

Otros ya han dado excelentes explicaciones sobre por qué no puede (y no debería) poder agregar elementos a un IEnumerable. Solo agregaré que si desea continuar codificando en una interfaz que representa una colección y desea un método de agregar, debe codificar ICollectiono IList. Como una bonanza adicional, se implementan estas interfaces IEnumerable.

Puedes hacerlo.

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

La forma más fácil de hacerlo es simplemente

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

Entonces puede devolver la lista como IEnumerable también porque implementa la interfaz IEnumerable

Si crea su objeto como IEnumerable<int> Ones = new List<int>(); Entonces puede hacer((List<int>)Ones).Add(1);

Claro, puedes (estoy dejando de lado tu negocio T):

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

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