Come inizializzare un List <T> a una data dimensione (in contrapposizione alla capacità)?

.NET offre un contenitore di elenchi generico le cui prestazioni sono quasi identiche (vedere la domanda sulle prestazioni di array e sugli elenchi). Tuttavia sono abbastanza diversi nell'inizializzazione.

Gli array sono molto facili da inizializzare con un valore predefinito e per definizione hanno già una certa dimensione:

string[] Ar = new string[10];

Ciò consente di assegnare in modo sicuro elementi casuali, ad esempio:

Ar[5]="hello";

con l'elenco le cose sono più complicate. Posso vedere due modi per eseguire la stessa inizializzazione, nessuno dei quali è ciò che chiameresti elegante:

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

o

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

Quale sarebbe un modo più pulito?

EDIT: Le risposte finora si riferiscono alla capacità, che è qualcos'altro rispetto al pre-compilare un elenco. Ad esempio, su un elenco appena creato con una capacità di 10, non si può fareL[2]="somevalue"

EDIT 2: le persone si chiedono perché voglio usare gli elenchi in questo modo, poiché non è il modo in cui sono destinati ad essere utilizzati. Posso vedere due ragioni:

1. Si potrebbe sostenere in modo abbastanza convincente che gli elenchi sono gli array di "nuova generazione", aggiungendo flessibilità quasi senza penalità. Pertanto si dovrebbero usarli per impostazione predefinita. Sto facendo notare che potrebbero non essere così facili da inizializzare.

2. Quello che sto scrivendo attualmente è una classe base che offre funzionalità predefinite come parte di un framework più grande. Nella funzionalità predefinita che offro, la dimensione dell'elenco è nota in avanzato e quindi avrei potuto utilizzare un array. Tuttavia, voglio offrire a qualsiasi classe base la possibilità di estenderla dinamicamente e quindi opto per un elenco.

Non posso dire di averne bisogno molto spesso - potresti fornire maggiori dettagli sul motivo per cui lo desideri? Probabilmente lo metterei come metodo statico in una classe helper:

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

Si potrebbe usareEnumerable.Repeat(default(T), count).ToList() , ma che sarebbe dovuto inefficiente di buffer ridimensionamento.

Nota che se Tè un tipo di riferimento, memorizzerà le countcopie del riferimento passato pervalue parametro, quindi faranno riferimento allo stesso oggetto. Potrebbe essere o meno quello che vuoi, a seconda del tuo caso d'uso.

MODIFICA: come indicato nei commenti, puoi Repeatedutilizzare un ciclo per popolare l'elenco, se lo desideri. Anche questo sarebbe leggermente più veloce. Personalmente trovo che il codice sia Repeatpiù descrittivo e sospetto che nel mondo reale la differenza di prestazioni sarebbe irrilevante, ma il tuo chilometraggio potrebbe variare.

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

Usa il costruttore che accetta un int ("capacità") come argomento:

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

EDIT: dovrei aggiungere che sono d'accordo con Frederik. Stai usando la Lista in un modo che va contro l'intero ragionamento dietro al suo utilizzo in primo luogo.

EDIT2:

EDIT 2: Quello che sto scrivendo attualmente è una classe base che offre funzionalità predefinite come parte di un framework più grande. Nella funzionalità predefinita che offro, la dimensione dell'elenco è nota in avanzato e quindi avrei potuto utilizzare un array. Tuttavia, voglio offrire a qualsiasi classe base la possibilità di estenderla dinamicamente e quindi opto per un elenco.

Perché qualcuno dovrebbe conoscere la dimensione di un elenco con tutti i valori nulli? Se non ci sono valori reali nell'elenco, mi aspetto che la lunghezza sia 0. In ogni caso, il fatto che questo sia cludgy dimostra che va contro l'uso previsto della classe.

Crea prima un array con il numero di elementi che desideri, quindi converti l'array in un elenco.

int[] fakeArray = new int[10];

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

Perché stai usando una lista se vuoi inizializzarla con un valore fisso? Posso capire che -per il bene delle prestazioni- vuoi dargli una capacità iniziale, ma non è uno dei vantaggi di un elenco rispetto a un array normale che può crescere quando necessario?

Quando lo fai:

List<int> = new List<int>(100);

Si crea un elenco la cui capacità è di 100 numeri interi. Ciò significa che il tuo elenco non avrà bisogno di "crescere" finché non aggiungi il 101esimo elemento. L'array sottostante dell'elenco verrà inizializzato con una lunghezza di 100.

Inizializzare il contenuto di un elenco in questo modo non è esattamente ciò a cui servono gli elenchi. Gli elenchi sono progettati per contenere oggetti. Se desideri mappare numeri particolari su oggetti particolari, considera l'utilizzo di una struttura di coppie chiave-valore come una tabella hash o un dizionario invece di un elenco.

Sembra che tu stia enfatizzando la necessità di un'associazione di posizione con i tuoi dati, quindi un array associativo non sarebbe più adatto?

Dictionary<int, string> foo = new Dictionary<int, string>();
foo[2] = "string";

Se vuoi inizializzare l'elenco con N elementi di qualche valore fisso:

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

Puoi usare Linq per inizializzare in modo intelligente il tuo elenco con un valore predefinito. (Simile alla risposta di David B. )

var defaultStrings = (new int[10]).Select(x => "my value").ToList();

Vai oltre e inizializza ogni stringa con valori distinti "stringa 1", "stringa 2", "stringa 3" e così via:

int x = 1;
var numberedStrings = (new int[10]).Select(x => "string " + x++).ToList();

string [] temp = new string[] {"1","2","3"};
List<string> temp2 = temp.ToList();

La risposta accettata (quella con il segno di spunta verde) presenta un problema.

Il problema:

var result = Lists.Repeated(new MyType(), sizeOfList);
// each item in the list references the same MyType() object
// if you edit item 1 in the list, you are also editing item 2 in the list

Consiglio di cambiare la riga sopra per eseguire una copia dell'oggetto. Ci sono molti articoli diversi su questo:

• Il metodo String.MemberwiseClone () chiamato tramite la reflection non funziona, perché?
• https://code.msdn.microsoft.com/windowsdesktop/CSDeepCloneObject-8a53311e

Se desideri inizializzare ogni elemento nell'elenco con il costruttore predefinito, anziché NULL, aggiungi il seguente metodo:

public static List<T> RepeatedDefaultInstance<T>(int count)
    {
        List<T> ret = new List<T>(count);
        for (var i = 0; i < count; i++)
        {
            ret.Add((T)Activator.CreateInstance(typeof(T)));
        }
        return ret;
    }

Avviso su IList: MSDN IList Osservazioni : "Le implementazioni di IList rientrano in tre categorie: sola lettura, dimensione fissa e dimensione variabile. (...). Per la versione generica di questa interfaccia, vedere System.Collections.Generic.IList<T>."

IList<T>NON eredita da IList(maList<T> implementa sia IList<T>e IList), ma è sempre di dimensione variabile . A partire da .NET 4.5, abbiamo anche, IReadOnlyList<T>ma per quanto ne so, non esiste un elenco generico di dimensioni fisse che sarebbe quello che stai cercando.

Questo è un campione che ho usato per il mio unit test. Ho creato un elenco di oggetti di classe. Quindi ho usato forloop per aggiungere il numero "X" di oggetti che mi aspetto dal servizio. In questo modo puoi aggiungere / inizializzare un elenco per qualsiasi dimensione data.

public void TestMethod1()
    {
        var expected = new List<DotaViewer.Interface.DotaHero>();
        for (int i = 0; i < 22; i++)//You add empty initialization here
        {
            var temp = new DotaViewer.Interface.DotaHero();
            expected.Add(temp);
        }
        var nw = new DotaHeroCsvService();
        var items = nw.GetHero();

        CollectionAssert.AreEqual(expected,items);


    }

Spero di esservi stato d'aiuto ragazzi.

Un po 'tardi ma la prima soluzione che mi hai proposto mi sembra molto più pulita: non allocare la memoria due volte. Anche List constrcutor ha bisogno di scorrere l'array per copiarlo; non sa nemmeno in anticipo che ci sono solo elementi nulli all'interno.

1. - alloca N - loop N Costo: 1 * alloca (N) + N * loop_iteration

2. - alloca N - alloca N + loop () Costo: 2 * alloca (N) + N * loop_iteration

Tuttavia l'allocazione di un ciclo di List potrebbe essere più veloce poiché List è una classe incorporata, ma C # è compilato in modo jit ...