Как инициализировать List <T> заданным размером (в отличие от емкости)?

.NET предлагает общий контейнер списков, производительность которого практически идентична (см. Вопрос «Производительность массивов и списков»). Однако они совершенно разные по инициализации.

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

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

Что было бы чище?

РЕДАКТИРОВАТЬ: ответы пока относятся к емкости, которая представляет собой нечто иное, чем предварительное заполнение списка. Например, в только что созданном списке с емкостью 10 нельзя сделатьL[2]="somevalue"

РЕДАКТИРОВАТЬ 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параметра, поэтому все они будут ссылаться на один и тот же объект. Это может быть или не быть тем, что вы хотите, в зависимости от вашего варианта использования.

РЕДАКТИРОВАТЬ: как отмечено в комментариях, вы можете Repeatedиспользовать цикл для заполнения списка, если хотите. Это тоже было бы немного быстрее. Лично я считаю, что код Repeatболее нагляден, и подозреваю, что в реальном мире разница в производительности не имеет значения, но ваш опыт может отличаться.

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

Используйте конструктор, который принимает в качестве аргумента int ("емкость"):

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

РЕДАКТИРОВАТЬ: Я должен добавить, что согласен с Фредериком. Вы используете Список таким образом, который, в первую очередь, идет вразрез со всей логикой его использования.

РЕДАКТИРОВАТЬ2:

РЕДАКТИРОВАТЬ 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);


    }

Надеюсь, я помог вам, ребята.

Немного поздно, но первое предложенное вами решение кажется мне намного чище: вы не выделяете память дважды. Даже конструктору List необходимо пройти через массив, чтобы скопировать его; он даже заранее не знает, что внутри есть только нулевые элементы.

1. - выделить N - цикл N Стоимость: 1 * выделить (N) + N * loop_iteration

2. - выделить N - выделить N + loop () Стоимость: 2 * выделить (N) + N * loop_iteration

Однако распределение циклов в List может быть быстрее, так как List является встроенным классом, но C # скомпилирован jit sooo ...