Wie initialisiere ich eine Liste <T> auf eine bestimmte Größe (im Gegensatz zur Kapazität)?

.NET bietet einen generischen Listencontainer, dessen Leistung nahezu identisch ist (siehe Frage Leistung von Arrays vs. Listen). Sie unterscheiden sich jedoch in der Initialisierung erheblich.

Arrays lassen sich sehr einfach mit einem Standardwert initialisieren und haben per Definition bereits eine bestimmte Größe:

string[] Ar = new string[10];

So kann man sicher zufällige Elemente zuweisen, sagen wir:

Ar[5]="hello";

mit Liste sind die Dinge schwieriger. Ich kann zwei Möglichkeiten sehen, um dieselbe Initialisierung durchzuführen, von denen Sie keine als elegant bezeichnen würden:

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

oder

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

Was wäre ein sauberer Weg?

BEARBEITEN: Die bisherigen Antworten beziehen sich auf die Kapazität, die etwas anderes ist als das Vorabfüllen einer Liste. Bei einer Liste, die gerade mit einer Kapazität von 10 erstellt wurde, ist dies beispielsweise nicht möglichL[2]="somevalue"

EDIT 2: Die Leute fragen sich, warum ich Listen auf diese Weise verwenden möchte, da dies nicht die Art ist, wie sie verwendet werden sollen. Ich kann zwei Gründe sehen:

1. Man könnte ziemlich überzeugend argumentieren, dass Listen die Arrays der "nächsten Generation" sind, die Flexibilität ohne Strafe hinzufügen. Daher sollte man sie standardmäßig verwenden. Ich weise darauf hin, dass sie möglicherweise nicht so einfach zu initialisieren sind.

2. Was ich gerade schreibe, ist eine Basisklasse, die Standardfunktionen als Teil eines größeren Frameworks bietet. In der von mir angebotenen Standardfunktionalität ist die Größe der Liste in Advanced bekannt, weshalb ich ein Array hätte verwenden können. Ich möchte jedoch jeder Basisklasse die Möglichkeit bieten, sie dynamisch zu erweitern, und entscheide mich daher für eine Liste.

Ich kann nicht sagen, dass ich das sehr oft brauche - könnten Sie mehr Details darüber geben, warum Sie das wollen? Ich würde es wahrscheinlich als statische Methode in eine Hilfsklasse einfügen:

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

Sie könnten verwenden, Enumerable.Repeat(default(T), count).ToList()aber das wäre aufgrund der Puffergrößenänderung ineffizient.

Wenn Tes sich um einen Referenztyp handelt, werden countKopien der für den valueParameter übergebenen Referenz gespeichert, sodass alle auf dasselbe Objekt verweisen. Das kann je nach Anwendungsfall das sein, was Sie wollen oder nicht.

BEARBEITEN: Wie in den Kommentaren erwähnt, können Sie Repeateddie Liste mit einer Schleife füllen, wenn Sie möchten. Das wäre auch etwas schneller. Persönlich finde ich den Code Repeatbeschreibender und vermute, dass in der realen Welt der Leistungsunterschied irrelevant wäre, aber Ihr Kilometerstand kann variieren.

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

Verwenden Sie den Konstruktor, der ein int ("Kapazität") als Argument verwendet:

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

EDIT: Ich sollte hinzufügen, dass ich Frederik zustimme. Sie verwenden die Liste auf eine Weise, die gegen die gesamte Begründung verstößt, die dahinter steckt.

EDIT2:

EDIT 2: Was ich gerade schreibe, ist eine Basisklasse, die Standardfunktionen als Teil eines größeren Frameworks bietet. In der von mir angebotenen Standardfunktionalität ist die Größe der Liste in Advanced bekannt, weshalb ich ein Array hätte verwenden können. Ich möchte jedoch jeder Basisklasse die Möglichkeit bieten, sie dynamisch zu erweitern, und entscheide mich daher für eine Liste.

Warum sollte jemand die Größe einer Liste mit allen Nullwerten kennen müssen? Wenn die Liste keine realen Werte enthält, würde ich eine Länge von 0 erwarten. Die Tatsache, dass dies ungeschickt ist, zeigt jedenfalls, dass dies gegen die beabsichtigte Verwendung der Klasse verstößt.

Erstellen Sie zuerst ein Array mit der Anzahl der gewünschten Elemente und konvertieren Sie das Array dann in eine Liste.

int[] fakeArray = new int[10];

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

Warum verwenden Sie eine Liste, wenn Sie sie mit einem festen Wert initialisieren möchten? Ich kann verstehen, dass Sie aus Gründen der Leistung eine anfängliche Kapazität haben möchten, aber ist dies nicht einer der Vorteile einer Liste gegenüber einem regulären Array, das bei Bedarf erweitert werden kann?

Wenn Sie dies tun:

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

Sie erstellen eine Liste mit einer Kapazität von 100 Ganzzahlen. Dies bedeutet, dass Ihre Liste erst wachsen muss, wenn Sie das 101. Element hinzufügen. Das zugrunde liegende Array der Liste wird mit einer Länge von 100 initialisiert.

Das Initialisieren des Inhalts einer solchen Liste ist nicht wirklich das, wofür Listen gedacht sind. Listen dienen zur Aufnahme von Objekten. Wenn Sie bestimmten Objekten bestimmte Zahlen zuordnen möchten, sollten Sie anstelle einer Liste eine Schlüssel-Wert-Paar-Struktur wie eine Hash-Tabelle oder ein Wörterbuch verwenden.

Sie scheinen die Notwendigkeit einer Positionszuordnung zu Ihren Daten zu betonen. Wäre ein assoziatives Array also nicht passender?

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

Wenn Sie die Liste mit N Elementen eines festen Werts initialisieren möchten:

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

Mit Linq können Sie Ihre Liste geschickt mit einem Standardwert initialisieren. (Ähnlich wie die Antwort von David B. )

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

Gehen Sie einen Schritt weiter und initialisieren Sie jede Zeichenfolge mit unterschiedlichen Werten: "Zeichenfolge 1", "Zeichenfolge 2", "Zeichenfolge 3" usw.:

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

Die akzeptierte Antwort (die mit dem grünen Häkchen) weist ein Problem auf.

Das Problem:

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

Ich empfehle, die obige Zeile zu ändern, um eine Kopie des Objekts zu erstellen. Es gibt viele verschiedene Artikel darüber:

• Die durch Reflektion aufgerufene String.MemberwiseClone () -Methode funktioniert nicht. Warum?
• https://code.msdn.microsoft.com/windowsdesktop/CSDeepCloneObject-8a53311e

Wenn Sie jedes Element in Ihrer Liste mit dem Standardkonstruktor und nicht mit NULL initialisieren möchten, fügen Sie die folgende Methode hinzu:

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

Ein Hinweis zu IList: MSDN IList Anmerkungen : "IList-Implementierungen lassen sich in drei Kategorien einteilen: schreibgeschützt, feste Größe und variable Größe. (...). Die generische Version dieser Schnittstelle finden Sie unter System.Collections.Generic.IList<T>."

IList<T>erbt NICHT von IList( List<T>implementiert aber beide IList<T>und IList), hat aber immer eine variable Größe . Seit .NET 4.5 haben wir aber auch IReadOnlyList<T>AFAIK, es gibt keine generische Liste mit fester Größe, nach der Sie suchen würden.

Dies ist ein Beispiel, das ich für meinen Unit-Test verwendet habe. Ich habe eine Liste von Klassenobjekten erstellt. Dann habe ich forloop verwendet, um die 'X'-Anzahl von Objekten hinzuzufügen, die ich vom Dienst erwarte. Auf diese Weise können Sie eine Liste für eine bestimmte Größe hinzufügen / initialisieren.

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


    }

Ich hoffe, ich habe euch geholfen.

Ein bisschen spät, aber die erste Lösung, die Sie vorgeschlagen haben, scheint mir viel sauberer zu sein: Sie weisen den Speicher nicht zweimal zu. Sogar List Constrcutor muss das Array durchlaufen, um es zu kopieren. es weiß nicht einmal im Voraus, dass nur Nullelemente darin sind.

1. - N zuordnen - Schleife N Kosten: 1 * Zuweisen (N) + N * Schleifen_iteration

2. - N zuweisen - N + loop () zuweisen Kosten: 2 * (N) + N * loop_iteration zuweisen

Die Zuweisung von List und Loops in List kann jedoch schneller sein, da List eine integrierte Klasse ist, aber C # sooo jit-kompiliert ist ...