Jak zainicjować List <T> do danego rozmiaru (w przeciwieństwie do pojemności)?

.NET oferuje ogólny kontener listy, którego wydajność jest prawie identyczna (zobacz pytanie Wydajność tablic a listy). Jednak są one zupełnie inne w inicjalizacji.

Tablice są bardzo łatwe do zainicjowania z wartością domyślną iz definicji mają już określony rozmiar:

string[] Ar = new string[10];

Co pozwala na bezpieczne przypisywanie losowych przedmiotów, powiedzmy:

Ar[5]="hello";

z listą rzeczy są trudniejsze. Widzę dwa sposoby wykonania tej samej inicjalizacji, z których żaden nie jest tym, co nazwałbyś eleganckim:

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

lub

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

Jaki byłby czystszy sposób?

EDYCJA: dotychczasowe odpowiedzi odnoszą się do pojemności, co jest czymś innym niż wstępne wypełnienie listy. Na przykład na właśnie utworzonej liście o pojemności 10 nie można tego zrobićL[2]="somevalue"

EDYCJA 2: Ludzie zastanawiają się, dlaczego chcę używać list w ten sposób, skoro nie jest to sposób, w jaki mają być używane. Widzę dwa powody:

1. Można by całkiem przekonująco argumentować, że listy są tablicami „nowej generacji”, dodającymi elastyczności prawie bez żadnych kar. Dlatego należy ich używać domyślnie. Zwracam uwagę, że mogą nie być tak łatwe do zainicjowania.

2. To, co obecnie piszę, to klasa bazowa oferująca domyślną funkcjonalność jako część większego frameworka. W domyślnej funkcjonalności, którą oferuję, rozmiar listy jest znany w zaawansowanym i dlatego mogłem użyć tablicy. Chcę jednak zaoferować każdej klasie bazowej możliwość jej dynamicznego rozszerzenia, dlatego wybieram listę.

Nie mogę powiedzieć, że potrzebuję tego bardzo często - czy możesz podać więcej szczegółów, dlaczego tego chcesz? Prawdopodobnie umieściłbym to jako metodę statyczną w klasie pomocniczej:

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

Państwo mogli używać Enumerable.Repeat(default(T), count).ToList(), ale to byłoby nieefektywne ze względu na bufor zmiany rozmiaru.

Zauważ, że jeśli Tjest typem referencyjnym, będzie przechowywać countkopie referencji przekazanej dla valueparametru - więc wszystkie będą odnosić się do tego samego obiektu. To może, ale nie musi być tym, czego chcesz, w zależności od twojego przypadku użycia.

EDYCJA: Jak zauważono w komentarzach, jeśli chcesz, możesz Repeatedużyć pętli do wypełnienia listy. To też byłoby nieco szybsze. Osobiście uważam, że kod jest Repeatbardziej opisowy i podejrzewam, że w prawdziwym świecie różnica w wydajności byłaby nieistotna, ale przebieg może się różnić.

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

Użyj konstruktora, który przyjmuje jako argument int („capacity”):

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

EDYCJA: Dodam, że zgadzam się z Frederikiem. Używasz Listy w sposób, który jest sprzeczny z całym rozumowaniem stojącym za jej użyciem.

EDYCJA2:

EDYCJA 2: To, co obecnie piszę, to klasa bazowa oferująca domyślną funkcjonalność jako część większego frameworka. W domyślnej funkcjonalności, którą oferuję, rozmiar listy jest znany w zaawansowanym i dlatego mogłem użyć tablicy. Chcę jednak zaoferować każdej klasie bazowej możliwość jej dynamicznego rozszerzenia, dlatego wybieram listę.

Dlaczego ktoś miałby znać rozmiar listy zawierającej wszystkie wartości null? Gdyby na liście nie było żadnych rzeczywistych wartości, spodziewałbym się, że długość będzie równa 0. W każdym razie fakt, że jest on gęsty, dowodzi, że jest to sprzeczne z przeznaczeniem tej klasy.

Najpierw utwórz tablicę z żądaną liczbą elementów, a następnie przekonwertuj ją na listę.

int[] fakeArray = new int[10];

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

Dlaczego używasz listy, jeśli chcesz ją zainicjować ze stałą wartością? Rozumiem, że - ze względu na wydajność - chcesz nadać jej początkową pojemność, ale czy nie jest jedną z zalet listy w porównaniu ze zwykłą tablicą, którą może powiększać w razie potrzeby?

Kiedy to robisz:

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

Tworzysz listę o pojemności 100 liczb całkowitych. Oznacza to, że Twoja lista nie będzie musiała „rosnąć”, dopóki nie dodasz 101 pozycji. Podstawowa tablica listy zostanie zainicjowana z długością 100.

Inicjowanie zawartości takiej listy nie jest tak naprawdę tym, do czego służą listy. Listy są przeznaczone do przechowywania obiektów. Jeśli chcesz odwzorować określone liczby na określone obiekty, rozważ użycie struktury par klucz-wartość, takiej jak tabela skrótów lub słownik, zamiast listy.

Wydaje się, że podkreślasz potrzebę pozycyjnego powiązania z danymi, więc czy tablica asocjacyjna nie byłaby bardziej odpowiednia?

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

Jeśli chcesz zainicjować listę N elementami o stałej wartości:

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

Możesz użyć Linq, aby sprytnie zainicjować listę z wartością domyślną. (Podobnie jak odpowiedź Davida B. )

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

Idź o krok dalej i zainicjuj każdy ciąg odrębnymi wartościami „ciąg 1”, „ciąg 2”, „ciąg 3” itd .:

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

Zaakceptowana odpowiedź (ta z zielonym haczykiem) zawiera problem.

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

Zalecam zmianę powyższej linii, aby wykonać kopię obiektu. Istnieje wiele różnych artykułów na ten temat:

• Metoda String.MemberwiseClone () wywołana przez odbicie nie działa, dlaczego?
• https://code.msdn.microsoft.com/windowsdesktop/CSDeepCloneObject-8a53311e

Jeśli chcesz zainicjować każdy element na liście za pomocą domyślnego konstruktora, a nie NULL, dodaj następującą metodę:

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

Uwaga dotycząca IList: MSDN IList Uwagi : "Implementacje IList dzielą się na trzy kategorie: tylko do odczytu, o stałym rozmiarze i o zmiennym rozmiarze. (...). Ogólną wersję tego interfejsu można znaleźć w System.Collections.Generic.IList<T>."

IList<T>NIE dziedziczy po IList(ale List<T>implementuje oba IList<T>i IList), ale zawsze ma zmienny rozmiar . Od .NET 4.5 mamy również, IReadOnlyList<T>ale AFAIK, nie ma ogólnej listy o stałym rozmiarze, która byłaby tym, czego szukasz.

To jest próbka, której użyłem do mojego testu jednostkowego. Stworzyłem listę obiektów klasy. Następnie użyłem forloop, aby dodać liczbę obiektów „X”, których oczekuję od usługi. W ten sposób możesz dodać / zainicjować listę dla dowolnego rozmiaru.

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


    }

Mam nadzieję, że pomogłem wam.

Trochę późno, ale pierwsze zaproponowane przez ciebie rozwiązanie wydaje mi się o wiele czystsze: nie przydziela się pamięci dwukrotnie. Nawet constrcutor listy musi przejść przez tablicę, aby ją skopiować; nawet z góry nie wie, że w środku są tylko elementy zerowe.

1. - przydziel N - pętla N Koszt: 1 * przydziel (N) + N * loop_iteration

2. - przydziel N - przydziel N + pętlę () Koszt: 2 * przydziel (N) + N * loop_iteration

Jednak alokacja listy, pętle mogą być szybsze, ponieważ List jest klasą wbudowaną, ale C # jest skompilowany w jit, więc ...