Est-il préférable d'appeler ToList () ou ToArray () dans les requêtes LINQ?

Je rencontre souvent le cas où je veux évaluer une requête là où je la déclare. C'est généralement parce que j'ai besoin de répéter plusieurs fois et que le calcul est coûteux. Par exemple:

string raw = "...";
var lines = (from l in raw.Split('\n')
             let ll = l.Trim()
             where !string.IsNullOrEmpty(ll)
             select ll).ToList();

Cela fonctionne bien. Mais si je ne vais pas modifier le résultat, je ferais aussi bien d'appeler à la ToArray()place de ToList().

Je me demande cependant si ToArray() est implémenté par le premier appel ToList()et est donc moins efficace en mémoire que le simple appel ToList().

Suis-je fou? Dois-je simplement appelerToArray() - sûr et sécurisé en sachant que la mémoire ne sera pas allouée deux fois?

Sauf si vous avez simplement besoin d'un tableau pour répondre à d'autres contraintes que vous devez utiliser ToList. Dans la majorité des scénarios, ToArrayil allouera plus de mémoire que ToList.

Les deux utilisent des tableaux pour le stockage, mais ToListont une contrainte plus flexible. Il a besoin que le tableau soit au moins aussi grand que le nombre d'éléments dans la collection. Si le tableau est plus grand, ce n'est pas un problème. Cependant ToArray, le tableau doit être dimensionné exactement au nombre d'éléments.

Répondre à cette contrainte fait ToArraysouvent une allocation de plus que ToList. Une fois qu'il a un tableau suffisamment grand, il alloue un tableau qui a exactement la bonne taille et copie les éléments dans ce tableau. La seule fois où il peut éviter cela, c'est lorsque l'algorithme de croissance du tableau coïncide avec le nombre d'éléments devant être stockés (certainement dans la minorité).

ÉDITER

Quelques personnes m'ont interrogé sur les conséquences de la mémoire supplémentaire inutilisée dans le List<T> valeur.

C'est une préoccupation valable. Si la collection créée a une longue durée de vie, n'est jamais modifiée après avoir été créée et a de grandes chances d'atterrir dans le tas Gen2, alors vous feriez mieux de prendre l'allocation supplémentaire deToArray avance.

En général, je trouve que c'est le cas le plus rare. Il est beaucoup plus courant de voir un grand nombre d' ToArrayappels qui sont immédiatement transmis à d'autres utilisations de courte durée de la mémoire, auquel cas il ToListest manifestement préférable.

La clé ici est de profiler, profiler puis profiler un peu plus.

La différence de performance sera insignifiante, car List<T> est implémentée en tant que tableau de taille dynamique. Appelant soit ToArray()(qui utilise une Buffer<T>classe interne pour agrandir le tableau) soit ToList()(qui appelle leList<T>(IEnumerable<T>) constructeur) finira par les placer dans un tableau et agrandir le tableau jusqu'à ce qu'il convienne à tous.

Si vous souhaitez une confirmation concrète de ce fait, consultez la mise en œuvre des méthodes en question dans Reflector - vous verrez qu'elles se résument à un code presque identique.

(sept ans plus tard ...)

Quelques autres (bonnes) réponses se sont concentrées sur les différences de performances microscopiques qui se produiront.

Cet article n'est qu'un complément pour mentionner la différence sémantique qui existe entre le IEnumerator<T>produit par un tableau ( T[]) et celui renvoyé par a List<T>.

Mieux illustré par l'exemple:

IList<int> source = Enumerable.Range(1, 10).ToArray();  // try changing to .ToList()

foreach (var x in source)
{
  if (x == 5)
    source[8] *= 100;
  Console.WriteLine(x);
}

Le code ci-dessus s'exécutera sans exception et produira la sortie:

1
2
3
4
5
6
7
8
900
dix

Cela montre que le IEnumarator<int>retourné par un int[]ne garde pas de trace si le tableau a été modifié depuis la création de l'énumérateur.

Notez que j'ai déclaré la variable locale en sourcetant que IList<int>. De cette façon, je m'assure que le compilateur C # n'optimise pas l' foreachinstruction en quelque chose qui équivaut à une for (var idx = 0; idx < source.Length; idx++) { /* ... */ }boucle. C'est quelque chose que le compilateur C # pourrait faire si j'utilise à la var source = ...;place. Dans ma version actuelle du framework .NET, l'énumérateur réel utilisé ici est un type de référence non public, System.SZArrayHelper+SZGenericArrayEnumerator`1[System.Int32]mais bien sûr, c'est un détail d'implémentation.

Maintenant, si je change .ToArray()en .ToList(), je reçois seulement:

1
2
3
4
5

suivi d'un System.InvalidOperationExceptionéclatement disant:

La collection a été modifiée; L'opération d'énumération peut ne pas s'exécuter.

L'énumérateur sous-jacent dans ce cas est le type de valeur mutable public System.Collections.Generic.List`1+Enumerator[System.Int32](encadré dans une IEnumerator<int>boîte dans ce cas parce que j'utilise IList<int>).

En conclusion, l'énumérateur produit par unList<T>garde la trace de la modification de la liste pendant l'énumération, alors que l'énumérateur produit parT[]ne le fait pas. Considérez donc cette différence lors du choix entre.ToList()et.ToArray().

Les gens en ajoutent souvent un supplémentaire .ToArray() ou .ToList()contournent une collection qui garde la trace de sa modification pendant la durée de vie d'un enquêteur.

(Si quelqu'un veut savoir comment le List<>garde trace si la collection a été modifiée, il y a un champ privé _versiondans cette classe qui est changé à chaque List<>mise à jour.)

Je suis d'accord avec @mquander que la différence de performances devrait être insignifiante. Cependant, je voulais le comparer pour être sûr, alors je l'ai fait - et c'est insignifiant.

Testing with List<T> source:
ToArray time: 1934 ms (0.01934 ms/call), memory used: 4021 bytes/array
ToList  time: 1902 ms (0.01902 ms/call), memory used: 4045 bytes/List

Testing with array source:
ToArray time: 1957 ms (0.01957 ms/call), memory used: 4021 bytes/array
ToList  time: 2022 ms (0.02022 ms/call), memory used: 4045 bytes/List

Chaque tableau / liste source avait 1 000 éléments. Vous pouvez donc voir que les différences de temps et de mémoire sont négligeables.

Ma conclusion: vous pourriez aussi bien utiliser ToList () , car a List<T>fournit plus de fonctionnalités qu'un tableau, à moins que quelques octets de mémoire ne vous importent vraiment.

ToList()est généralement préférable si vous l'utilisez IEnumerable<T>(depuis ORM, par exemple). Si la longueur de la séquence n'est pas connue au début, ToArray()crée une collection de longueur dynamique comme List, puis la convertit en tableau, ce qui prend plus de temps.

La mémoire sera toujours allouée deux fois - ou quelque chose de proche. Comme vous ne pouvez pas redimensionner un tableau, les deux méthodes utiliseront une sorte de mécanisme pour collecter les données dans une collection croissante. (Eh bien, la Liste est une collection croissante en soi.)

La liste utilise une baie comme stockage interne et double la capacité en cas de besoin. Cela signifie qu'en moyenne 2/3 des articles ont été réalloués au moins une fois, la moitié de ceux réalloués au moins deux fois, la moitié de ceux au moins trois fois, et ainsi de suite. Cela signifie que chaque élément a été en moyenne réalloué 1,3 fois, ce qui n'est pas beaucoup de frais généraux.

N'oubliez pas également que si vous collectez des chaînes, la collection elle-même ne contient que les références aux chaînes, les chaînes elles-mêmes ne sont pas réallouées.

Nous sommes en 2020 à l'extérieur et tout le monde utilise .NET Core 3.1, j'ai donc décidé d'exécuter des benchmarks avec Benchmark.NET.

TL; DR: ToArray () est meilleur en termes de performances et fait une meilleure intention de transmission de travail si vous ne prévoyez pas de muter la collection.

    [MemoryDiagnoser]
    public class Benchmarks
    {
        [Params(0, 1, 6, 10, 39, 100, 666, 1000, 1337, 10000)]
        public int Count { get; set; }

        public IEnumerable<int> Items => Enumerable.Range(0, Count);

        [Benchmark(Description = "ToArray()", Baseline = true)]
        public int[] ToArray() => Items.ToArray();

        [Benchmark(Description = "ToList()")]
        public List<int> ToList() => Items.ToList();

        public static void Main() => BenchmarkRunner.Run<Benchmarks>();
    }

Les résultats sont:

    BenchmarkDotNet=v0.12.0, OS=Windows 10.0.14393.3443 (1607/AnniversaryUpdate/Redstone1)
    Intel Core i5-4460 CPU 3.20GHz (Haswell), 1 CPU, 4 logical and 4 physical cores
    Frequency=3124994 Hz, Resolution=320.0006 ns, Timer=TSC
    .NET Core SDK=3.1.100
      [Host]     : .NET Core 3.1.0 (CoreCLR 4.700.19.56402, CoreFX 4.700.19.56404), X64 RyuJIT
      DefaultJob : .NET Core 3.1.0 (CoreCLR 4.700.19.56402, CoreFX 4.700.19.56404), X64 RyuJIT


    |    Method | Count |          Mean |       Error |      StdDev |        Median | Ratio | RatioSD |   Gen 0 | Gen 1 | Gen 2 | Allocated |
    |---------- |------ |--------------:|------------:|------------:|--------------:|------:|--------:|--------:|------:|------:|----------:|
    | ToArray() |     0 |      7.357 ns |   0.2096 ns |   0.1960 ns |      7.323 ns |  1.00 |    0.00 |       - |     - |     - |         - |
    |  ToList() |     0 |     13.174 ns |   0.2094 ns |   0.1958 ns |     13.084 ns |  1.79 |    0.05 |  0.0102 |     - |     - |      32 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |     1 |     23.917 ns |   0.4999 ns |   0.4676 ns |     23.954 ns |  1.00 |    0.00 |  0.0229 |     - |     - |      72 B |
    |  ToList() |     1 |     33.867 ns |   0.7350 ns |   0.6876 ns |     34.013 ns |  1.42 |    0.04 |  0.0331 |     - |     - |     104 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |     6 |     28.242 ns |   0.5071 ns |   0.4234 ns |     28.196 ns |  1.00 |    0.00 |  0.0280 |     - |     - |      88 B |
    |  ToList() |     6 |     43.516 ns |   0.9448 ns |   1.1949 ns |     42.896 ns |  1.56 |    0.06 |  0.0382 |     - |     - |     120 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |    10 |     31.636 ns |   0.5408 ns |   0.4516 ns |     31.657 ns |  1.00 |    0.00 |  0.0331 |     - |     - |     104 B |
    |  ToList() |    10 |     53.870 ns |   1.2988 ns |   2.2403 ns |     53.415 ns |  1.77 |    0.07 |  0.0433 |     - |     - |     136 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |    39 |     58.896 ns |   0.9441 ns |   0.8369 ns |     58.548 ns |  1.00 |    0.00 |  0.0713 |     - |     - |     224 B |
    |  ToList() |    39 |    138.054 ns |   2.8185 ns |   3.2458 ns |    138.937 ns |  2.35 |    0.08 |  0.0815 |     - |     - |     256 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |   100 |    119.167 ns |   1.6195 ns |   1.4357 ns |    119.120 ns |  1.00 |    0.00 |  0.1478 |     - |     - |     464 B |
    |  ToList() |   100 |    274.053 ns |   5.1073 ns |   4.7774 ns |    272.242 ns |  2.30 |    0.06 |  0.1578 |     - |     - |     496 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |   666 |    569.920 ns |  11.4496 ns |  11.2450 ns |    571.647 ns |  1.00 |    0.00 |  0.8688 |     - |     - |    2728 B |
    |  ToList() |   666 |  1,621.752 ns |  17.1176 ns |  16.0118 ns |  1,623.566 ns |  2.85 |    0.05 |  0.8793 |     - |     - |    2760 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |  1000 |    796.705 ns |  16.7091 ns |  19.8910 ns |    796.610 ns |  1.00 |    0.00 |  1.2951 |     - |     - |    4064 B |
    |  ToList() |  1000 |  2,453.110 ns |  48.1121 ns |  65.8563 ns |  2,460.190 ns |  3.09 |    0.10 |  1.3046 |     - |     - |    4096 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() |  1337 |  1,057.983 ns |  20.9810 ns |  41.4145 ns |  1,041.028 ns |  1.00 |    0.00 |  1.7223 |     - |     - |    5416 B |
    |  ToList() |  1337 |  3,217.550 ns |  62.3777 ns |  61.2633 ns |  3,203.928 ns |  2.98 |    0.13 |  1.7357 |     - |     - |    5448 B |
    |           |       |               |             |             |               |       |         |         |       |       |           |
    | ToArray() | 10000 |  7,309.844 ns | 160.0343 ns | 141.8662 ns |  7,279.387 ns |  1.00 |    0.00 | 12.6572 |     - |     - |   40064 B |
    |  ToList() | 10000 | 23,858.032 ns | 389.6592 ns | 364.4874 ns | 23,759.001 ns |  3.26 |    0.08 | 12.6343 |     - |     - |   40096 B |

    // * Hints *
    Outliers
      Benchmarks.ToArray(): Default -> 2 outliers were removed (35.20 ns, 35.29 ns)
      Benchmarks.ToArray(): Default -> 2 outliers were removed (38.51 ns, 38.88 ns)
      Benchmarks.ToList(): Default  -> 1 outlier  was  removed (64.69 ns)
      Benchmarks.ToArray(): Default -> 1 outlier  was  removed (67.02 ns)
      Benchmarks.ToArray(): Default -> 1 outlier  was  removed (130.08 ns)
      Benchmarks.ToArray(): Default -> 1 outlier  was  detected (541.82 ns)
      Benchmarks.ToArray(): Default -> 1 outlier  was  removed (7.82 us)

    // * Legends *
      Count     : Value of the 'Count' parameter
      Mean      : Arithmetic mean of all measurements
      Error     : Half of 99.9% confidence interval
      StdDev    : Standard deviation of all measurements
      Median    : Value separating the higher half of all measurements (50th percentile)
      Ratio     : Mean of the ratio distribution ([Current]/[Baseline])
      RatioSD   : Standard deviation of the ratio distribution ([Current]/[Baseline])
      Gen 0     : GC Generation 0 collects per 1000 operations
      Gen 1     : GC Generation 1 collects per 1000 operations
      Gen 2     : GC Generation 2 collects per 1000 operations
      Allocated : Allocated memory per single operation (managed only, inclusive, 1KB = 1024B)
      1 ns      : 1 Nanosecond (0.000000001 sec)

Éditer : La dernière partie de cette réponse n'est pas valide. Cependant, le reste est toujours une information utile, donc je vais le laisser.

Je sais que c'est un vieux post, mais après avoir posé la même question et fait quelques recherches, j'ai trouvé quelque chose d'intéressant qui pourrait valoir la peine d'être partagé.

Tout d'abord, je suis d'accord avec @mquander et sa réponse. Il a raison de dire que sur le plan des performances, les deux sont identiques.

Cependant, j'ai utilisé Reflector pour jeter un œil aux méthodes dans l' System.Linq.Enumerableespace de noms des extensions, et j'ai remarqué une optimisation très courante.
Dans la mesure du possible, la IEnumerable<T>source est convertie en IList<T>ou ICollection<T>pour optimiser la méthode. Par exemple, regardezElementAt(int) .

Fait intéressant, Microsoft a choisi d'optimiser uniquement pour IList<T>, mais pas IList. Il semble que Microsoft préfère utiliser l' IList<T>interface.

System.Arrayimplémente uniquement IList, il ne bénéficiera donc d'aucune de ces optimisations d'extension.
Par conséquent, je soumets que la meilleure pratique consiste à utiliser la .ToList()méthode.
Si vous utilisez l'une des méthodes d'extension ou passez la liste à une autre méthode, il est possible qu'elle soit optimisée pour un IList<T>.

J'ai trouvé que les autres repères que les gens ont faits ici manquaient, alors voici ma fissure. Faites-moi savoir si vous trouvez quelque chose de mal avec ma méthodologie.

/* This is a benchmarking template I use in LINQPad when I want to do a
 * quick performance test. Just give it a couple of actions to test and
 * it will give you a pretty good idea of how long they take compared
 * to one another. It's not perfect: You can expect a 3% error margin
 * under ideal circumstances. But if you're not going to improve
 * performance by more than 3%, you probably don't care anyway.*/
void Main()
{
    // Enter setup code here
    var values = Enumerable.Range(1, 100000)
        .Select(i => i.ToString())
        .ToArray()
        .Select(i => i);
    values.GetType().Dump();
    var actions = new[]
    {
        new TimedAction("ToList", () =>
        {
            values.ToList();
        }),
        new TimedAction("ToArray", () =>
        {
            values.ToArray();
        }),
        new TimedAction("Control", () =>
        {
            foreach (var element in values)
            {
                // do nothing
            }
        }),
        // Add tests as desired
    };
    const int TimesToRun = 1000; // Tweak this as necessary
    TimeActions(TimesToRun, actions);
}


#region timer helper methods
// Define other methods and classes here
public void TimeActions(int iterations, params TimedAction[] actions)
{
    Stopwatch s = new Stopwatch();
    int length = actions.Length;
    var results = new ActionResult[actions.Length];
    // Perform the actions in their initial order.
    for (int i = 0; i < length; i++)
    {
        var action = actions[i];
        var result = results[i] = new ActionResult { Message = action.Message };
        // Do a dry run to get things ramped up/cached
        result.DryRun1 = s.Time(action.Action, 10);
        result.FullRun1 = s.Time(action.Action, iterations);
    }
    // Perform the actions in reverse order.
    for (int i = length - 1; i >= 0; i--)
    {
        var action = actions[i];
        var result = results[i];
        // Do a dry run to get things ramped up/cached
        result.DryRun2 = s.Time(action.Action, 10);
        result.FullRun2 = s.Time(action.Action, iterations);
    }
    results.Dump();
}

public class ActionResult
{
    public string Message { get; set; }
    public double DryRun1 { get; set; }
    public double DryRun2 { get; set; }
    public double FullRun1 { get; set; }
    public double FullRun2 { get; set; }
}

public class TimedAction
{
    public TimedAction(string message, Action action)
    {
        Message = message;
        Action = action;
    }
    public string Message { get; private set; }
    public Action Action { get; private set; }
}

public static class StopwatchExtensions
{
    public static double Time(this Stopwatch sw, Action action, int iterations)
    {
        sw.Restart();
        for (int i = 0; i < iterations; i++)
        {
            action();
        }
        sw.Stop();

        return sw.Elapsed.TotalMilliseconds;
    }
}
#endregion

Vous pouvez télécharger le script LINQPad ici .

Résultats:

En ajustant le code ci-dessus, vous découvrirez que:

1. La différence est moins importante lorsqu'il s'agit de petits tableaux .
2. La différence est moins importante lorsqu'il s'agit de ints plutôt que destring art.
3. L'utilisation de grands structs au lieu de strings prend généralement beaucoup plus de temps, mais ne change pas vraiment le rapport.

Cela rejoint les conclusions des réponses les mieux notées:

1. Il est peu probable que vous remarquiez une différence de performances, sauf si votre code produit fréquemment de nombreuses grandes listes de données. (Il n'y avait qu'une différence de 200 ms lors de la création de 1000 listes de 100K cordes chacune.)
2. ToList() fonctionne toujours plus rapidement et serait un meilleur choix si vous ne prévoyez pas de vous accrocher aux résultats pendant longtemps.

Mise à jour

@JonHanna a souligné qu'en fonction de l'implémentation de, Selectil est possible pour a ToList()ou l' ToArray()implémentation de prédire à l'avance la taille de la collection résultante. Remplacer .Select(i => i)dans le code ci-dessus avec Where(i => true) des résultats très similaires pour le moment, et est plus susceptible de le faire quelle que soit l'implémentation .NET.

Vous devez baser votre décision sur ToListou en ToArrayfonction de ce que, idéalement, le choix de conception est. Si vous voulez une collection qui ne peut être itérée et accessible que par index, choisissez ToArray. Si vous souhaitez des fonctionnalités supplémentaires d'ajout et de suppression de la collection plus tard sans trop de tracas, faites unToList (pas vraiment que vous ne pouvez pas ajouter à un tableau, mais ce n'est généralement pas le bon outil pour cela).

Si les performances sont importantes, vous devez également envisager ce qui serait plus rapide à utiliser. De façon réaliste, vous n'appelerez pas ToListou ToArrayun million de fois, mais vous pourriez travailler sur la collection obtenue un million de fois. À cet égard, []c'est mieux, car List<>c'est []avec des frais généraux. Voir ce fil pour une comparaison d'efficacité: Lequel est le plus efficace: List <int> or int []

Dans mes propres tests il y a quelque temps, j'avais trouvé ToArrayplus vite. Et je ne sais pas à quel point les tests étaient biaisés. La différence de performances est cependant insignifiante, ce qui ne peut être perceptible que si vous exécutez ces requêtes dans une boucle des millions de fois.

Une réponse très tardive mais je pense que ce sera utile pour les googleurs.

Ils sucent tous les deux lorsqu'ils ont créé avec linq. Ils implémentent tous les deux le même code pour redimensionner le tampon si nécessaire . ToArrayutilise en interne une classe pour convertir IEnumerable<>en tableau, en allouant un tableau de 4 éléments. Si cela ne suffit pas, cela double la taille en créant un nouveau tableau double la taille du tableau actuel et en copiant le tableau actuel. À la fin, il alloue un nouveau tableau de comptage de vos articles. Si votre requête retourne 129 éléments, ToArray effectuera 6 allocations et opérations de copie de mémoire pour créer un tableau de 256 éléments et puis un autre tableau de 129 pour retourner. tant pour l'efficacité de la mémoire.

ToList fait la même chose, mais il ignore la dernière allocation puisque vous pouvez ajouter des éléments à l'avenir. La liste ne se soucie pas si elle est créée à partir d'une requête linq ou créée manuellement.

pour la création List est meilleure avec la mémoire mais pire avec cpu car list est une solution générique chaque action nécessite des vérifications de plage supplémentaires aux vérifications de plage interne du .net pour les tableaux.

Donc, si vous parcourez votre jeu de résultats trop de fois, les tableaux sont bons, car cela signifie moins de vérifications de plage que les listes, et les compilateurs optimisent généralement les tableaux pour un accès séquentiel.

L'allocation d'initialisation de la liste peut être meilleure si vous spécifiez le paramètre de capacité lorsque vous le créez. Dans ce cas, il n'allouera le tableau qu'une seule fois, en supposant que vous connaissez la taille du résultat. ToListde linq ne spécifie pas de surcharge pour le fournir, nous devons donc créer notre méthode d'extension qui crée une liste avec une capacité donnée, puis utilise List<>.AddRange.

Pour terminer cette réponse, je dois écrire les phrases suivantes

1. À la fin, vous pouvez utiliser un ToArray ou ToList, les performances ne seront pas si différentes (voir la réponse de @EMP).
2. Vous utilisez C #. Si vous avez besoin de performances, ne vous inquiétez pas d'écrire sur du code haute performance, mais ne vous inquiétez pas d'écrire du code de mauvaise performance.
3. Ciblez toujours x64 pour du code haute performance. AFAIK, x64 JIT est basé sur le compilateur C ++ et fait des choses amusantes comme des optimisations de récursivité de queue.
4. Avec la version 4.5, vous pouvez également profiter de l'optimisation guidée par profil et du JIT multicœur.
5. Enfin, vous pouvez utiliser le modèle async / attente pour le traiter plus rapidement.

C'est une vieille question - mais pour le bénéfice des utilisateurs qui y tombent, il existe également une alternative à la `` mémorisation '' de l'énumérable - qui a pour effet de mettre en cache et d'arrêter l'énumération multiple d'une instruction Linq, ce que ToArray () et ToList () sont beaucoup utilisés, même si les attributs de collection de la liste ou du tableau ne sont jamais utilisés.

Memoize est disponible dans la bibliothèque RX / System.Interactive et est expliqué ici: Plus de LINQ avec System.Interactive

(Du blog de Bart De'Smet qui est une lecture fortement recommandée si vous travaillez beaucoup avec Linq to Objects)

Une option consiste à ajouter votre propre méthode d'extension qui renvoie une lecture seule ICollection<T> . Cela peut être mieux que d'utiliser ToListou ToArraylorsque vous ne souhaitez pas utiliser les propriétés d'indexation d'un tableau / liste ou ajouter / supprimer d'une liste.

public static class EnumerableExtension
{
    /// <summary>
    /// Causes immediate evaluation of the linq but only if required.
    /// As it returns a readonly ICollection, is better than using ToList or ToArray
    /// when you do not want to use the indexing properties of an IList, or add to the collection.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="enumerable"></param>
    /// <returns>Readonly collection</returns>
    public static ICollection<T> Evaluate<T>(this IEnumerable<T> enumerable)
    {
        //if it's already a readonly collection, use it
        var collection = enumerable as ICollection<T>;
        if ((collection != null) && collection.IsReadOnly)
        {
            return collection;
        }
        //or make a new collection
        return enumerable.ToList().AsReadOnly();
    }
}

Tests unitaires:

[TestClass]
public sealed class EvaluateLinqTests
{
    [TestMethod]
    public void EvalTest()
    {
        var list = new List<int> {1, 2, 3};
        var linqResult = list.Select(i => i);
        var linqResultEvaluated = list.Select(i => i).Evaluate();
        list.Clear();
        Assert.AreEqual(0, linqResult.Count());
        //even though we have cleared the underlying list, the evaluated list does not change
        Assert.AreEqual(3, linqResultEvaluated.Count());
    }

    [TestMethod]
    public void DoesNotSaveCreatingListWhenHasListTest()
    {
        var list = new List<int> {1, 2, 3};
        var linqResultEvaluated = list.Evaluate();
        //list is not readonly, so we expect a new list
        Assert.AreNotSame(list, linqResultEvaluated);
    }

    [TestMethod]
    public void SavesCreatingListWhenHasReadonlyListTest()
    {
        var list = new List<int> {1, 2, 3}.AsReadOnly();
        var linqResultEvaluated = list.Evaluate();
        //list is readonly, so we don't expect a new list
        Assert.AreSame(list, linqResultEvaluated);
    }

    [TestMethod]
    public void SavesCreatingListWhenHasArrayTest()
    {
        var list = new[] {1, 2, 3};
        var linqResultEvaluated = list.Evaluate();
        //arrays are readonly (wrt ICollection<T> interface), so we don't expect a new object
        Assert.AreSame(list, linqResultEvaluated);
    }

    [TestMethod]
    [ExpectedException(typeof (NotSupportedException))]
    public void CantAddToResultTest()
    {
        var list = new List<int> {1, 2, 3};
        var linqResultEvaluated = list.Evaluate();
        Assert.AreNotSame(list, linqResultEvaluated);
        linqResultEvaluated.Add(4);
    }

    [TestMethod]
    [ExpectedException(typeof (NotSupportedException))]
    public void CantRemoveFromResultTest()
    {
        var list = new List<int> {1, 2, 3};
        var linqResultEvaluated = list.Evaluate();
        Assert.AreNotSame(list, linqResultEvaluated);
        linqResultEvaluated.Remove(1);
    }
}

ToListAsync<T>() est préféré.

Dans Entity Framework 6, les deux méthodes finissent par appeler la même méthode interne, mais les ToArrayAsync<T>()appels list.ToArray()à la fin, qui sont implémentés comme

T[] array = new T[_size];
Array.Copy(_items, 0, array, 0, _size);
return array;

Il en ToArrayAsync<T>()est de même pour certains frais généraux, ce qui ToListAsync<T>()est préférable.

Vieille question mais nouveaux questionneurs en tout temps.

Selon la source de System.Linq.Enumerable , il ToListsuffit de renvoyer a new List(source), tout en ToArrayutilisant a new Buffer<T>(source).ToArray()pour renvoyer a T[].

À propos de l'allocation de mémoire:

Lors de l'exécution sur un IEnumerable<T>seul objet, ToArrayallouez de la mémoire une fois de plus ToList. Mais vous n'avez pas à vous en soucier dans la plupart des cas, car GC effectuera la collecte des ordures en cas de besoin.

À propos de l'exécution efficace:

Ceux qui posent cette question peuvent exécuter le code suivant sur votre propre machine et vous obtiendrez votre réponse.

class PersonC
{
    public Guid uuid;
    public string name;
    public int age;
    public bool sex;
    public DateTime BirthDay;
    public double weight;
}

struct PersonS
{
    public Guid uuid;
    public string name;
    public int age;
    public bool sex;
    public DateTime BirthDay;
    public double weight;
}

class PersonT<T> : IEnumerable<T>
{
    private List<T> items;
    public PersonT(IEnumerable<T> init)
    {
        items = new List<T>(init);
    }

    public IEnumerator<T> GetEnumerator() => items.GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => items.GetEnumerator();
}

private IEnumerable<PersonC> C(int count)
{
    for (var i = 0; i < count; ++i)
    {
        var guid = Guid.NewGuid();
        var guidBytes = guid.ToByteArray(); //16 bytes
        yield return new PersonC
        {
            uuid = guid,
            name = guid.ToString(),
            age = guidBytes[0] ^ guidBytes[7],
            sex = guidBytes[14] % 2 == 0,
            BirthDay = DateTime.Now.AddDays(-guidBytes[11] * 18),
            weight = guidBytes[12] * 100
        };
    }
}

private IEnumerable<PersonS> S(int count)
{
    for (var i = 0; i < count; ++i)
    {
        var guid = Guid.NewGuid();
        var guidBytes = guid.ToByteArray(); //16 bytes
        yield return new PersonS
        {
            uuid = guid,
            name = guid.ToString(),
            age = guidBytes[0] ^ guidBytes[7],
            sex = guidBytes[14] % 2 == 0,
            BirthDay = DateTime.Now.AddDays(-guidBytes[11] * 18),
            weight = guidBytes[12] * 100
        };
    }
}

private void MakeLog(string test, List<long> log) =>
    Console.WriteLine("{0} {1} ms -> [{2}]",
        test,
        log.Average(),
        string.Join(", ", log)
    );

private void Test1(int times, int count)
{
    var test = Enumerable.Range(1, times).ToArray();

    MakeLog("C.ToList", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = C(count).ToList();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("C.ToArray", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = C(count).ToArray();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("S.ToList", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = S(count).ToList();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("S.ToArray", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = S(count).ToArray();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());
}

private void Test2(int times, int count)
{
    var test = Enumerable.Range(1, times).ToArray();

    var dataC1 = new PersonT<PersonC>(C(count));
    var dataS1 = new PersonT<PersonS>(S(count));

    MakeLog("C1.ToList", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataC1.ToList();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("C1.ToArray", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataC1.ToArray();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("S1.ToList", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataS1.ToList();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("S1.ToArray", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataS1.ToArray();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());
}

private void Test3(int times, int count)
{
    var test = Enumerable.Range(1, times).ToArray();

    var dataC2 = (ICollection<PersonC>) new List<PersonC>(C(count));
    var dataS2 = (ICollection<PersonS>) new List<PersonS>(S(count));

    MakeLog("C2.ToList", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataC2.ToList();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("C2.ToArray", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataC2.ToArray();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("S2.ToList", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataS2.ToList();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());

    MakeLog("S2.ToArray", test.Select(o =>
    {
        var sw = new Stopwatch();
        GC.Collect();
        sw.Start();
        var ret = dataS2.ToArray();
        sw.Stop();
        return sw.ElapsedMilliseconds;
    }).ToList());
}

private void TestMain()
{
    const int times = 100;
    const int count = 1_000_000 + 1;
    Test1(times, count);
    Test2(times, count);
    Test3(times, count);
}

J'ai obtenu ces résultats sur ma machine:

Groupe 1:

C.ToList 761.79 ms -> [775, 755, 759, 759, 756, 759, 765, 750, 757, 762, 759, 754, 757, 753, 763, 753, 759, 756, 768, 754, 763, 757, 757, 777, 780, 758, 754, 758, 762, 754, 758, 757, 763, 758, 760, 754, 761, 755, 764, 847, 952, 755, 747, 763, 760, 758, 754, 763, 761, 758, 750, 764, 757, 763, 762, 756, 753, 759, 759, 757, 758, 779, 765, 760, 760, 756, 760, 756, 755, 764, 759, 753, 757, 760, 752, 764, 758, 760, 758, 760, 755, 761, 751, 753, 761, 762, 761, 758, 759, 752, 765, 756, 760, 755, 757, 753, 760, 751, 755, 779]
C.ToArray 782.56 ms -> [783, 774, 771, 771, 773, 774, 775, 775, 772, 770, 771, 774, 771, 1023, 975, 772, 767, 776, 771, 779, 772, 779, 775, 771, 775, 773, 775, 771, 765, 774, 770, 781, 772, 771, 781, 762, 817, 770, 775, 779, 769, 774, 763, 775, 777, 769, 777, 772, 775, 778, 775, 771, 770, 774, 772, 769, 772, 769, 774, 775, 768, 775, 769, 774, 771, 776, 774, 773, 778, 769, 778, 767, 770, 787, 783, 779, 771, 768, 805, 780, 779, 767, 773, 771, 773, 785, 1044, 853, 775, 774, 775, 771, 770, 769, 770, 776, 770, 780, 821, 770]
S.ToList 704.2 ms -> [687, 702, 709, 691, 694, 710, 696, 698, 700, 694, 701, 719, 706, 694, 702, 699, 699, 703, 704, 701, 703, 705, 697, 707, 691, 697, 707, 692, 721, 698, 695, 700, 704, 700, 701, 710, 700, 705, 697, 711, 694, 700, 695, 698, 701, 692, 696, 702, 690, 699, 708, 700, 703, 714, 701, 697, 700, 699, 694, 701, 697, 696, 699, 694, 709, 1068, 690, 706, 699, 699, 695, 708, 695, 704, 704, 700, 695, 704, 695, 696, 702, 700, 710, 708, 693, 697, 702, 694, 700, 706, 699, 695, 706, 714, 704, 700, 695, 697, 707, 704]
S.ToArray 742.5 ms -> [742, 743, 733, 745, 741, 724, 738, 745, 728, 732, 740, 727, 739, 740, 726, 744, 758, 732, 744, 745, 730, 739, 738, 723, 745, 757, 729, 741, 736, 724, 744, 756, 739, 766, 737, 725, 741, 742, 736, 748, 742, 721, 746, 1043, 806, 747, 731, 727, 742, 742, 726, 738, 746, 727, 739, 743, 730, 744, 753, 741, 739, 746, 728, 740, 744, 734, 734, 738, 731, 747, 736, 731, 765, 735, 726, 740, 743, 730, 746, 742, 725, 731, 757, 734, 738, 741, 732, 747, 744, 721, 742, 741, 727, 745, 740, 730, 747, 760, 737, 740]

C1.ToList 32.34 ms -> [35, 31, 31, 31, 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 33, 32, 31, 31, 31, 31, 30, 32, 31, 31, 31, 31, 32, 30, 31, 31, 31, 30, 32, 31, 31, 31, 36, 31, 31, 31, 32, 30, 31, 32, 31, 31, 31, 31, 31, 32, 31, 31, 31, 31, 33, 32, 31, 32, 31, 31, 33, 31, 31, 31, 31, 31, 32, 31, 32, 31, 34, 38, 68, 42, 79, 33, 31, 31, 31, 31, 31, 30, 30, 30, 30, 31, 31, 31, 31, 32, 31, 32, 31, 31, 31, 32, 33, 33, 31, 31]
C1.ToArray 56.32 ms -> [57, 56, 59, 54, 54, 55, 56, 57, 54, 54, 55, 55, 57, 56, 59, 57, 56, 58, 56, 56, 54, 56, 57, 55, 55, 55, 57, 58, 57, 58, 55, 55, 56, 55, 57, 56, 56, 59, 56, 56, 56, 56, 58, 56, 57, 56, 56, 57, 56, 55, 56, 56, 56, 59, 56, 56, 56, 55, 55, 54, 55, 54, 57, 56, 56, 56, 55, 55, 56, 56, 56, 59, 56, 56, 57, 56, 57, 56, 56, 56, 56, 62, 55, 56, 56, 56, 69, 57, 58, 56, 57, 58, 56, 57, 56, 56, 56, 56, 56, 56]
S1.ToList 88.69 ms -> [96, 90, 90, 89, 91, 88, 89, 90, 96, 89, 89, 89, 90, 90, 90, 89, 90, 90, 89, 90, 89, 91, 89, 91, 89, 91, 89, 90, 90, 89, 87, 88, 87, 88, 87, 87, 87, 87, 88, 88, 87, 87, 89, 87, 87, 87, 91, 88, 87, 86, 89, 87, 90, 89, 89, 90, 89, 87, 87, 87, 86, 87, 88, 90, 88, 87, 87, 92, 87, 87, 88, 88, 88, 86, 86, 87, 88, 87, 87, 87, 89, 87, 89, 87, 90, 89, 89, 89, 91, 89, 90, 89, 90, 88, 90, 90, 90, 88, 89, 89]
S1.ToArray 143.26 ms -> [130, 129, 130, 131, 133, 130, 131, 130, 135, 137, 130, 136, 132, 131, 130, 131, 132, 130, 132, 136, 130, 131, 157, 153, 194, 364, 176, 189, 203, 194, 189, 192, 183, 140, 142, 147, 145, 134, 159, 158, 142, 167, 130, 143, 145, 144, 160, 154, 156, 153, 153, 164, 142, 145, 137, 134, 145, 143, 142, 135, 133, 133, 135, 134, 134, 139, 139, 133, 134, 141, 133, 132, 133, 132, 133, 131, 135, 132, 133, 132, 128, 128, 130, 132, 129, 129, 129, 129, 129, 128, 134, 129, 129, 129, 129, 128, 128, 137, 130, 131]

C2.ToList 3.25 ms -> [5, 3, 3, 3, 3, 4, 3, 4, 3, 4, 3, 3, 3, 4, 4, 3, 3, 3, 4, 3, 3, 3, 3, 4, 3, 4, 3, 4, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 3, 4, 3, 3, 3, 3, 3, 4, 3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 4, 3, 3, 3, 4, 3, 3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3]
C2.ToArray 3.37 ms -> [4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 5, 4, 9, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 4, 4, 3, 3, 4, 4, 3, 3, 3, 4, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 4, 4, 3, 4, 4, 3, 3, 4, 3, 3, 4, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 3, 3, 4, 3, 3, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 4, 3, 4, 3, 3, 3]
S2.ToList 37.72 ms -> [38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 40, 38, 38, 39, 39, 38, 38, 38, 38, 37, 37, 37, 37, 39, 37, 37, 39, 38, 37, 37, 37, 37, 39, 38, 37, 37, 38, 37, 38, 37, 37, 38, 37, 37, 37, 38, 37, 37, 36, 37, 38, 37, 39, 37, 39, 38, 37, 38, 38, 38, 38, 38, 38, 37, 38, 38, 38, 38, 38, 37, 38, 37, 37, 38, 37, 37, 39, 41, 37, 38, 38, 37, 37, 37, 37, 38, 37, 37, 37, 40, 37, 37, 37, 37, 39, 38]
S2.ToArray 38.86 ms -> [39, 37, 39, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 39, 38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 38, 38, 38, 39, 37, 38, 38, 38, 38, 38, 37, 37, 38, 37, 37, 38, 38, 40, 38, 38, 38, 38, 38, 39, 38, 38, 39, 38, 38, 39, 38, 38, 40, 38, 39, 38, 38, 39, 38, 38, 38, 38, 38, 39, 38, 38, 38, 39, 39, 37, 38, 38, 39, 71, 78, 37, 37, 37, 39, 38, 38, 39, 38, 38, 38, 38, 38, 39, 38, 38, 38, 39, 38, 38, 38]