Як ініціалізувати Список <T> до заданого розміру (на відміну від ємності)?

.NET пропонує контейнер із загальним списком, продуктивність якого майже однакова (див. Питання Performance of Arrays vs. Lists). Однак при ініціалізації вони досить різні.

Масиви дуже легко ініціалізувати зі значенням за замовчуванням, і за визначенням вони вже мають певний розмір:

string[] Ar = new string[10];

Що дозволяє безпечно призначити випадкові предмети, скажімо:

Ar[5]="hello";

зі списком речі більш складні. Я бачу два способи зробити ту саму ініціалізацію, жоден з яких ви б не назвали елегантною:

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

або

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

Який би був чистіший спосіб?

EDIT: На сьогодні відповіді стосуються можливості, яка є чимось іншим, ніж попереднє заповнення списку. Наприклад, у щойно створеному списку місткістю 10, цього не можна робитиL[2]="somevalue"

EDIT 2: Люди задаються питанням, чому я хочу використовувати списки таким чином, оскільки це не той спосіб, яким вони призначені для використання. Я бачу дві причини:

1. Можна досить переконливо стверджувати, що списки - це масиви "наступного покоління", додаючи гнучкість майже без штрафу. Тому слід використовувати їх за замовчуванням. Я вказую, що їх може бути не так просто ініціалізувати.

2. Зараз я пишу базовий клас, який пропонує функціонал за замовчуванням як частину більш широкої основи. У пропонованій мені програмі за замовчуванням розмір списку відомий розширено, тому я міг би використовувати масив. Однак я хочу запропонувати будь-якому базовому класу можливість його динамічно розширити, і тому я вибираю список.

Я не можу сказати, що мені це дуже часто потрібно - ви могли б дати детальнішу інформацію, чому ви цього хочете? Я, мабуть, ставлю це як статичний метод у класі помічників:

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

Ви можете використовувати, Enumerable.Repeat(default(T), count).ToList()але це було б неефективно через зміну розміру буфера.

Зауважте, що якщо Tтип посилань, він зберігатиме countкопії посилань, переданих для valueпараметра, тому всі вони будуть посилатися на один і той же об'єкт. Це може бути або не бути тим, що ви хочете, залежно від випадку використання.

EDIT: Як зазначено в коментарях, ви можете Repeatedскористатися циклом, щоб заповнити список, якщо хочете. Це теж було б трохи швидше. Особисто я знаходжу код, використовуючи Repeatбільш описовий характер, і підозрюю, що в реальному світі різниця в продуктивності була б неактуальною, але ваш пробіг може відрізнятися.

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

Використовуйте конструктор, який приймає int ("місткість") як аргумент:

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

РЕДАКТУ: Додам, що я погоджуюся з Фредеріком. Ви використовуєте Список таким чином, що в першу чергу суперечить усім міркуванням щодо його використання.

EDIT2:

EDIT 2: Те, що я зараз пишу, - це базовий клас, який пропонує функціонал за замовчуванням як частину більш широкої основи. У пропонованій мені програмі за замовчуванням розмір списку відомий розширено, тому я міг би використовувати масив. Однак я хочу запропонувати будь-якому базовому класу можливість його динамічно розширити, і тому я вибираю список.

Чому хтось повинен знати розмір списку з усіма нульовими значеннями? Якщо в списку немає реальних значень, я б очікував, що довжина дорівнює 0. Як би то не було, факт, що це невдача, свідчить про те, що це суперечить передбачуваному використанню класу.

Створіть масив із кількістю потрібних елементів спочатку, а потім перетворіть масив у Список.

int[] fakeArray = new int[10];

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

Чому ви використовуєте Список, якщо ви хочете ініціалізувати його з фіксованим значенням? Я можу зрозуміти, що - заради продуктивності - ви хочете надати йому початкову потужність, але чи не є однією з переваг списку над звичайним масивом, який він може зростати при необхідності?

Коли ви це зробите:

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

Ви створюєте список, місткість якого становить 100 цілих чисел. Це означає, що списку не потрібно буде "рости", поки ви не додасте 101-й елемент. Базовий масив списку буде ініціалізований довжиною 100.

Ініціалізація вмісту такого списку насправді не є списком. Списки призначені для розміщення предметів. Якщо ви хочете зіставити певні номери з певними об'єктами, розгляньте використання структури пари ключових значень, таких як хеш-таблиця або словник замість списку.

Здається, ви наголошуєте на необхідності позиційної асоціації з вашими даними, тож чи не асоціативний масив був би більш придатним?

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

Якщо ви хочете ініціалізувати список із N елементами певного фіксованого значення:

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

Ви можете використовувати Linq для спритного ініціалізації списку зі значенням за замовчуванням. (Подібно до відповіді Девіда Б. )

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

Перейдіть на один крок далі та ініціалізуйте кожен рядок з різними значеннями "рядок 1", "рядок 2", "рядок 3" тощо:

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

У прийнятій відповіді (одна із зеленою галочкою) є питання.

Проблема:

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

Рекомендую змінити рядок вище, щоб виконати копію об'єкта. Про це існує багато різних статей:

• Метод String.MemberwiseClone (), викликаний через рефлексію, не працює, чому?
• https://code.msdn.microsoft.com/windowsdesktop/CSDeepCloneObject-8a53311e

Якщо ви хочете ініціалізувати кожен елемент у своєму списку конструктором за замовчуванням, а не NULL, то додайте наступний метод:

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

Повідомлення про IList: MSDN IList Зауваження : "Реалізації IList поділяються на три категорії: лише для читання, фіксованого розміру та змінного розміру. (...). Про загальну версію цього інтерфейсу див System.Collections.Generic.IList<T>."

IList<T>НЕ успадковує IList(але List<T>реалізує і те, IList<T>і інше IList), але завжди має змінний розмір . Оскільки .NET 4.5 у нас є, IReadOnlyList<T>окрім AFAIK, немає загального списку фіксованого розміру, який був би тим, що ви шукаєте.

Це зразок, який я використав для мого тестування на одиницю. Я створив список об’єкта класу. Тоді я використовував forloop, щоб додати «X» кількість об’єктів, яких я очікую від служби. Таким чином ви можете додати / ініціалізувати список для будь-якого заданого розміру.

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


    }

Сподіваюся, я допомогла вам, хлопці.

Трохи запізнення, але перше запропоноване вами рішення здається мені набагато чистішим: ви не виділяєте пам'ять двічі. Конструктору Even List потрібно провести цикл через масив, щоб скопіювати його; він навіть не знає заздалегідь, що всередині є лише нульові елементи.

1. - виділити N - цикл N Вартість: 1 * виділити (N) + N * цикл_ітерації

2. - виділити N - виділити N + петлю () Вартість: 2 * виділити (N) + N * loop_iteration

Однак виділення списку циклів може бути швидшим, оскільки List - це вбудований клас, але C # - це компільований jit-sooo ...