Comment initialiser une List<T> à une taille donnée (par opposition à la capacité) ?

Question

.NET propose un conteneur de liste générique dont les performances sont presque identiques (voir la question sur les performances des tableaux et des listes). Cependant, ils sont très différents au niveau de l'initialisation.

Les tableaux sont très faciles à initialiser avec une valeur par défaut, et par définition ils ont déjà une certaine taille :

string[] Ar = new string[10];

ce qui permet d'attribuer en toute sécurité des éléments aléatoires, par exemple :

Ar[5]="hello";

avec une liste, les choses sont plus délicates. Je peux voir deux façons de faire la même initialisation, aucune n'est ce qu'on pourrait appeler élégante :

List<string> L = new List<string>(10);
for (int i=0;i<10;i++) L.Add(null);

ou

string[] Ar = new string[10];
List<string> L = new List<string>(Ar);

Quel serait le moyen le plus propre ?

EDIT : Les réponses données jusqu'à présent font référence à la capacité, ce qui est autre chose que de pré-remplir une liste. Par exemple, sur une liste qui vient d'être créée avec une capacité de 10, on ne peut pas faire L[2]="une valeur".

EDIT 2 : Les gens se demandent pourquoi je veux utiliser les listes de cette façon, car ce n'est pas la façon dont elles sont censées être utilisées. Je vois deux raisons :

1. On pourrait argumenter de manière tout à fait convaincante que les listes sont les tableaux de "nouvelle génération", ajoutant de la flexibilité sans presque aucune pénalité. On devrait donc les utiliser par défaut. Je signale qu'elles ne sont peut-être pas aussi faciles à initialiser.

2. Ce que j'écris actuellement est une classe de base offrant une fonctionnalité par défaut dans le cadre d'une structure plus large. Dans la fonctionnalité par défaut que je propose, la taille de la liste est connue à l'avance et j'aurais donc pu utiliser un tableau. Cependant, je veux offrir à n'importe quelle classe de base la possibilité de l'étendre dynamiquement et j'opte donc pour une liste.

Answer 1

List<string> L = new List<string> ( new string[10] );

Answer 2

Je ne peux pas dire que j'ai besoin de cela très souvent - pourriez-vous donner plus de détails sur la raison pour laquelle vous voulez cela ? Je le placerais probablement comme une méthode statique dans une classe d'aide :

public static class Lists
{
    public static List<T> RepeatedDefault<T>(int count)
    {
        return Repeated(default(T), count);
    }

    public static List<T> Repeated<T>(T value, int count)
    {
        List<T> ret = new List<T>(count);
        ret.AddRange(Enumerable.Repeat(value, count));
        return ret;
    }
}

Vous pourrait utiliser Enumerable.Repeat(default(T), count).ToList() mais cela serait inefficace en raison du redimensionnement de la mémoire tampon.

EDIT : Comme indiqué dans les commentaires, vous pourriez faire Repeated utiliser une boucle pour remplir la liste si vous le souhaitez. Cela serait aussi un peu plus rapide. Personnellement, je trouve que le code utilisant Repeat plus descriptive, et je soupçonne que dans le monde réel la différence de performance ne serait pas pertinente, mais votre kilométrage peut varier.

Answer 3

Utilisez le constructeur qui prend un int ("capacité") comme argument :

List<string> = new List<string>(10);

EDIT : Je devrais ajouter que je suis d'accord avec Frederik. Vous utilisez la liste d'une manière qui va à l'encontre de la raison pour laquelle vous l'avez utilisée en premier lieu.

EDIT2 :

EDIT 2 : Ce que j'écris actuellement est une classe de base offrant une fonctionnalité par défaut dans le cadre d'une structure plus importante. Dans la fonctionnalité par défaut que je propose, la taille de la liste est connue à l'avance et j'aurais donc pu utiliser un tableau. Cependant, je veux offrir à toute classe de base la possibilité de l'étendre dynamiquement et j'opte donc pour une liste.

Pourquoi quelqu'un aurait-il besoin de connaître la taille d'une liste contenant toutes les valeurs nulles ? S'il n'y a aucune valeur réelle dans la liste, je m'attendrais à ce que la longueur soit de 0. Quoi qu'il en soit, le fait que cela soit maladroit démontre que cela va à l'encontre de l'utilisation prévue de la classe.

Answer 4

Créez d'abord un tableau avec le nombre d'éléments que vous voulez, puis convertissez le tableau en une liste.

int[] fakeArray = new int[10];

List<int> list = fakeArray.ToList();

Answer 5

Si vous voulez initialiser la liste avec N éléments d'une certaine valeur fixe :

public List<T> InitList<T>(int count, T initValue)
{
  return Enumerable.Repeat(initValue, count).ToList();
}