ToList (): ¿crea una nueva lista?

Digamos que tengo una clase

public class MyObject
{
   public int SimpleInt{get;set;}
}

Y tengo un List<MyObject>, y ToList()lo cambio, y luego uno de los SimpleInt, ¿se propagará mi cambio a la lista original? En otras palabras, ¿cuál sería el resultado del siguiente método?

public void RunChangeList()
{
  var objs = new List<MyObject>(){new MyObject(){SimpleInt=0}};
  var whatInt = ChangeToList(objs );
}
public int ChangeToList(List<MyObject> objects)
{
  var objectList = objects.ToList();
  objectList[0].SimpleInt=5;
  return objects[0].SimpleInt;

}

¿Por qué?

P / S: Lo siento si parece obvio averiguarlo. Pero no tengo compilador conmigo ahora ...

Sí, ToListcreará una nueva lista, pero como en este caso MyObjectes un tipo de referencia, la nueva lista contendrá referencias a los mismos objetos que la lista original.

La actualización de la SimpleIntpropiedad de un objeto al que se hace referencia en la nueva lista también afectará al objeto equivalente en la lista original.

(Si MyObjectse declarara como un en structlugar de un classentonces, la nueva lista contendría copias de los elementos en la lista original, y la actualización de una propiedad de un elemento en la nueva lista no afectaría al elemento equivalente en la lista original).

De la fuente Reflector'd:

public static List<TSource> ToList<TSource>(this IEnumerable<TSource> source)
{
    if (source == null)
    {
        throw Error.ArgumentNull("source");
    }
    return new List<TSource>(source);
}

Entonces, sí, su lista original no se actualizará (es decir, adiciones o eliminaciones), pero los objetos a los que se hace referencia lo harán.

ToList siempre creará una nueva lista, que no reflejará ningún cambio posterior en la colección.

Sin embargo, reflejará los cambios en los objetos mismos (a menos que sean estructuras mutables).

En otras palabras, si reemplaza un objeto en la lista original con un objeto diferente, ToListtodavía contendrá el primer objeto.
Sin embargo, si modifica uno de los objetos en la lista original, ToListseguirá conteniendo el mismo objeto (modificado).

La respuesta aceptada aborda correctamente la pregunta del OP basada en su ejemplo. Sin embargo, solo se aplica cuando ToListse aplica a una colección concreta; no se mantiene cuando los elementos de la secuencia fuente aún no se han instanciado (debido a la ejecución diferida). En el caso de este último, puede obtener un nuevo conjunto de elementos cada vez que llame ToList(o enumere la secuencia).

Aquí hay una adaptación del código del OP para demostrar este comportamiento:

public static void RunChangeList()
{
    var objs = Enumerable.Range(0, 10).Select(_ => new MyObject() { SimpleInt = 0 });
    var whatInt = ChangeToList(objs);   // whatInt gets 0
}

public static int ChangeToList(IEnumerable<MyObject> objects)
{
    var objectList = objects.ToList();
    objectList.First().SimpleInt = 5;
    return objects.First().SimpleInt;
}

Si bien el código anterior puede parecer artificial, este comportamiento puede aparecer como un error sutil en otros escenarios. Vea mi otro ejemplo para una situación en la que hace que las tareas se generen repetidamente.

Sí, crea una nueva lista. Esto es por diseño.

La lista contendrá los mismos resultados que la secuencia enumerable original, pero se materializó en una colección persistente (en memoria). Esto le permite consumir los resultados varias veces sin incurrir en el costo de volver a calcular la secuencia.

La belleza de las secuencias de LINQ es que son componibles. A menudo, lo IEnumerable<T>que obtiene es el resultado de combinar múltiples operaciones de filtrado, pedidos y / o proyección. Los métodos de extensión tienen gusto ToList()y le ToArray()permiten convertir la secuencia calculada en una colección estándar.

Se crea una nueva lista, pero los elementos que contiene son referencias a los elementos originales (al igual que en la lista original). Los cambios en la lista en sí son independientes, pero los elementos encontrarán el cambio en ambas listas.

Simplemente me topé con este viejo post y pensé en agregar mis dos centavos. En general, si tengo dudas, uso rápidamente el método GetHashCode () en cualquier objeto para verificar las identidades. Entonces para arriba -

    public class MyObject
{
    public int SimpleInt { get; set; }
}


class Program
{

    public static void RunChangeList()
    {
        var objs = new List<MyObject>() { new MyObject() { SimpleInt = 0 } };
        Console.WriteLine("objs: {0}", objs.GetHashCode());
        Console.WriteLine("objs[0]: {0}", objs[0].GetHashCode());
        var whatInt = ChangeToList(objs);
        Console.WriteLine("whatInt: {0}", whatInt.GetHashCode());
    }

    public static int ChangeToList(List<MyObject> objects)
    {
        Console.WriteLine("objects: {0}", objects.GetHashCode());
        Console.WriteLine("objects[0]: {0}", objects[0].GetHashCode());
        var objectList = objects.ToList();
        Console.WriteLine("objectList: {0}", objectList.GetHashCode());
        Console.WriteLine("objectList[0]: {0}", objectList[0].GetHashCode());
        objectList[0].SimpleInt = 5;
        return objects[0].SimpleInt;

    }

    private static void Main(string[] args)
    {
        RunChangeList();
        Console.ReadLine();
    }

Y responde en mi máquina

• objs: 45653674
• objs [0]: 41149443
• objetos: 45653674
• objetos [0]: 41149443
• objectList: 39785641
• objectList [0]: 41149443
• whatInt: 5

Entonces, esencialmente, el objeto que lleva la lista permanece igual en el código anterior. Espero que el enfoque ayude.

Creo que esto es equivalente a preguntar si ToList hace una copia profunda o superficial. Como ToList no tiene forma de clonar MyObject, debe hacer una copia superficial, por lo que la lista creada contiene las mismas referencias que la original, por lo que el código devuelve 5.

ToList creará una nueva lista.

Si los elementos de la lista son tipos de valor, se actualizarán directamente, si son tipos de referencia, cualquier cambio se reflejará en los objetos a los que se hace referencia.

En el caso donde el objeto fuente es un verdadero IEnumerable (es decir, no solo una colección empaquetada como enumerable), ToList () NO puede devolver las mismas referencias de objeto que en el IEnumerable original. Devolverá una nueva lista de objetos, pero esos objetos pueden no ser iguales o incluso iguales a los objetos producidos por IEnumerable cuando se enumera nuevamente

 var objectList = objects.ToList();
  objectList[0].SimpleInt=5;

Esto actualizará el objeto original también. La nueva lista contendrá referencias a los objetos que contiene, al igual que la lista original. Puede cambiar los elementos y la actualización se reflejará en el otro.

Ahora, si actualiza una lista (agregando o eliminando un elemento) que no se reflejará en la otra lista.

No veo en ninguna parte de la documentación que ToList () siempre tenga la garantía de devolver una nueva lista. Si un IEnumerable es una Lista, puede ser más eficiente verificar esto y simplemente devolver la misma Lista.

La preocupación es que a veces es posible que desee estar absolutamente seguro de que la Lista devuelta está! = A la Lista original. Debido a que Microsoft no documenta que ToList devolverá una nueva Lista, no podemos estar seguros (a menos que alguien haya encontrado esa documentación). También podría cambiar en el futuro, incluso si funciona ahora.

Se garantiza que la nueva lista (IEnumerable enumerablestuff) devolverá una nueva lista. Yo usaría esto en su lugar.