ToList()— T-il Créer une Nouvelle Liste?

Oui, ToList va créer une nouvelle liste, mais parce que, dans ce cas MyObject est un type de référence, puis la nouvelle liste contiendra des références pour les mêmes objets que la liste d'origine.

La mise à jour de la SimpleInt propriété d'un objet référencé dans la nouvelle liste sera également affecter l'équivalent de l'objet dans la liste d'origine.

(Si MyObject a été déclaré comme un struct plutôt qu'un class puis la nouvelle liste contient des copies des éléments dans la liste d'origine, et la mise à jour d'une propriété d'un élément dans la nouvelle liste pas affecter l'équivalent de l'élément dans la liste d'origine.)

ToList toujours créer une nouvelle liste, qui ne sera pas refléter toute modification ultérieure à la collection.

Cependant, il reflète les changements apportés aux objets eux-mêmes (Sauf s'ils sont mutables les structures).

En d'autres termes, si vous remplacez un objet dans la liste d'origine avec un autre objet, la ToList contient toujours le premier objet.

Toutefois, si vous modifiez l'un des objets de la liste d'origine, le ToList contient toujours les mêmes (modifié) de l'objet.

La accepté de répondre correctement les adresses de l'OP de la question en se basant sur son exemple. Cependant, il ne s'applique que lorsque ToList est appliqué sur un béton de la collection; il ne se pose pas lorsque les éléments de la séquence source doivent encore être instancié (en raison de l'exécution différée). Dans ce dernier cas, vous pourriez obtenir un nouvel ensemble d'éléments que chaque fois que vous appelez ToList (ou énumérer la séquence).

Ici est une adaptation de l'OP de code pour illustrer ce comportement:

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

Alors que le code ci-dessus peut sembler artificiel, ce comportement peut apparaître comme un bug subtil dans d'autres scénarios. Voir mon autre exemple pour une situation où il provoque des tâches donné naissance à plusieurs reprises.

Viens de tomber sur ce vieux post et de la pensée de l'ajout de mes deux cents. En général, si je suis dans le doute, j'ai rapidement à utiliser le GetHashCode() la méthode sur un objet quelconque pour vérifier les identités. Donc, pour ci -

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

Et de répondre sur ma machine -

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

Donc, essentiellement, l'objet qui comporte restent les mêmes dans le code ci-dessus. Espérons que la démarche permet de.

ToList permettra de créer une marque nouvelle liste.

Si les éléments de la liste sont des types valeur, ils seront directement mis à jour, si elles sont des types référence, toute modification sera renvoyée dans les objets référencés.

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

Cela permettra de mettre à jour l'objet d'origine en tant que bien. La nouvelle liste contient les références vers les objets qu'il contient, tout comme la liste d'origine. Vous pouvez modifier les éléments et la mise à jour sera reflétée dans l'autre.

Maintenant, si vous mettez à jour une liste (ajout ou suppression d'un élément) qui ne seront pas répercutées dans l'autre liste.