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

Question

Il m'arrive souvent de vouloir évaluer une requête à l'endroit même où je la déclare. C'est généralement parce que j'ai besoin d'itérer plusieurs fois sur la requête et il est coûteux à calculer. A titre d'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 n'ai pas l'intention de modifier le résultat, autant appeler ToArray() au lieu de ToList() .

Je me demande toutefois si ToArray() est mis en œuvre en appelant d'abord ToList() et est donc moins efficace en termes de mémoire que l'appel à ToList() .

Suis-je fou ? Dois-je appeler ToArray() - en toute sécurité en sachant que la mémoire ne sera pas allouée deux fois ?

Answer 1

À moins que vous n'ayez simplement besoin d'un tableau pour répondre à d'autres contraintes, vous devriez utiliser ToList . Dans la majorité des scénarios ToArray allouera plus de mémoire que ToList .

Les deux utilisent des tableaux pour le stockage, mais ToList a une contrainte plus souple. Il faut que le tableau soit au moins aussi grand que le nombre d'éléments de la collection. Si le tableau est plus grand, cela ne pose pas de problème. En revanche, si le tableau est plus grand, cela ne pose pas de problème. ToArray a besoin que la taille du tableau corresponde exactement au nombre d'éléments.

Pour répondre à cette contrainte ToArray fait souvent une allocation de plus que ToList . Une fois qu'il dispose d'un tableau suffisamment grand, il alloue un tableau ayant exactement la bonne taille et recopie les éléments dans ce tableau. Le seul cas où il peut éviter cela est celui où l'algorithme de croissance du tableau coïncide avec le nombre d'éléments devant être stockés (ce qui est certainement minoritaire).

EDITAR

Quelques personnes m'ont interrogé sur les conséquences de la présence d'une mémoire supplémentaire inutilisée dans le système d'exploitation. List<T> valeur.

Il s'agit d'une préoccupation légitime. Si la collection créée a une longue durée de vie, n'est jamais modifiée après sa création et a de fortes chances d'atterrir dans le tas Gen2, il est préférable d'utiliser l'allocation supplémentaire de ToArray en amont.

En général, je trouve que c'est le cas le plus rare. Il est beaucoup plus courant de voir beaucoup de ToArray qui sont immédiatement transmis à d'autres utilisations de courte durée de la mémoire. ToList est manifestement meilleure.

L'essentiel est d'établir des profils, des profils et encore des profils.

Answer 2

La différence de performance sera insignifiante, puisque List<T> est mis en œuvre sous la forme d'un tableau de taille dynamique. L'appel à l'une ou l'autre des fonctions ToArray() (qui utilise un Buffer<T> pour faire croître le tableau) ou ToList() (qui appelle le List<T>(IEnumerable<T>) ) se résumera à les placer dans un tableau et à agrandir ce tableau jusqu'à ce qu'il les contienne tous.

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

Answer 3

Je suis d'accord avec @mquander pour dire que la différence de performance devrait être insignifiante. Cependant, j'ai voulu faire une analyse comparative pour m'en assurer, et c'est ce que j'ai fait - et c'est effectivement 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 comporte 1000 éléments. Vous pouvez donc constater que les différences de temps et de mémoire sont négligeables.

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

Answer 4

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

Answer 5

La mémoire sera toujours allouée deux fois - ou quelque chose d'approchant. Comme il n'est pas possible de redimensionner un tableau, les deux méthodes utiliseront une sorte de mécanisme pour rassembler les données dans une collection croissante. (En fait, la liste est une collection croissante en elle-même).

La liste utilise une matrice comme stockage interne et double la capacité en cas de besoin. Cela signifie qu'en moyenne, 2/3 des éléments ont été réaffectés au moins une fois, la moitié au moins deux fois, la moitié au moins trois fois, et ainsi de suite. Cela signifie que chaque élément a été réaffecté en moyenne 1,3 fois, ce qui n'est pas très élevé.

N'oubliez pas non plus que si vous collectez des chaînes de caractères, 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.