На сколько элементов создаётся List

Подробный ответ по внутренней структуре List<T>

Вопрос "На сколько элементов создаётся List<T>?" требует понимания двух аспектов: начальной емкости (Capacity) и динамического расширения.

1. Конструкторы и начальная емкость

List<T> в C# имеет несколько конструкторов, каждый из которых определяет начальное состояние внутреннего массива:

// 1. Конструктор по умолчанию - создает внутренний массив нулевой длины
// Capacity = 0, Count = 0
List<int> list1 = new List<int>();

// 2. Конструктор с указанием начальной емкости
// Создается внутренний массив размером 10
// Capacity = 10, Count = 0
List<int> list2 = new List<int>(10);

// 3. Конструктор с коллекцией
// Создается внутренний массив, равный размеру коллекции
IEnumerable<int> collection = new int[] {1, 2, 3, 4, 5};
List<int> list3 = new List<int>(collection); // Capacity = 5, Count = 5

Ключевой момент: При создании List через конструктор по умолчанию, внутренний массив имеет длину 0. Это оптимизация для случаев, когда список может остаться пустым.

2. Динамическое расширение List

Когда вы добавляете элементы, происходит следующее:

List<int> list = new List<int>(); // Capacity = 0, Count = 0

// При первом добавлении элемента:
list.Add(1); 
// Выделяется внутренний массив размером 4 (значение по умолчанию)
// Capacity становится 4, Count = 1

// Дальнейшее добавление элементов:
list.Add(2); // Capacity = 4, Count = 2
list.Add(3); // Capacity = 4, Count = 3
list.Add(4); // Capacity = 4, Count = 4

// При попытке добавить 5-й элемент:
list.Add(5);
// Происходит расширение (resize) внутреннего массива:
// 1. Создается новый массив в 2 раза больше предыдущего (4 * 2 = 8)
// 2. Все существующие элементы копируются в новый массив
// 3. Capacity становится 8, Count = 5

Алгоритм расширения:

• Начальная емкость при первом добавлении: 4 элемента
• При каждом переполнении емкость увеличивается в 2 раза
• Если указать начальную емкость в конструкторе - расширение будет происходить от указанного значения

3. Практические рекомендации для Unity

В Unity разработке важно правильно работать с List для минимизации аллокаций:

// ХОРОШО: Предварительное выделение памяти для известного количества элементов
void SpawnEnemies(int count) {
    List<GameObject> enemies = new List<GameObject>(count);
    // Теперь при добавлении count элементов не будет переаллокаций
    for (int i = 0; i < count; i++) {
        enemies.Add(Instantiate(enemyPrefab));
    }
}

// ПЛОХО: Частые переаллокации в цикле
void BadExample() {
    List<GameObject> objects = new List<GameObject>();
    for (int i = 0; i < 1000; i++) {
        objects.Add(new GameObject()); // Множественные переаллокации
    }
}

4. Основные выводы

• Конструктор по умолчанию создает List с нулевой емкостью
• Первое добавление элемента выделяет массив на 4 элемента
• Расширение происходит в геометрической прогрессии (x2 каждый раз)
• В Unity особенно важно предварительно задавать Capacity для коллекций, которые будут интенсивно наполняться, чтобы избежать GC аллокаций при расширении внутреннего массива
• Capacity ≠ Count - Capacity это размер внутреннего массива, Count - реальное количество элементов

Для оптимизации производительности в Unity всегда старайтесь использовать конструктор с указанием начальной емкости, если заранее известно примерное количество элементов. Это значительно снижает количество аллокаций и сборок мусора, особенно важно на мобильных платформах.