Что сделаешь если в массиве закончится место?

Стратегии работы с переполнением массива в Unity (C#)

В C# массивы имеют фиксированный размер, определенный при создании, и не могут динамически расширяться. Если в массиве «закончится место», это вызовет IndexOutOfRangeException при попытке записи за его границами. В Unity-разработке я применяю несколько стратегий для обработки этой ситуации, выбирая подход в зависимости от контекста.

1. Использование динамических коллекций вместо массивов

Чаще всего я заменяю обычные массивы на коллекции из пространства имен System.Collections.Generic, которые автоматически управляют памятью.

// Вместо массива фиксированного размера
GameObject[] enemiesArray = new GameObject[10];

// Используем List<T>
List<GameObject> enemiesList = new List<GameObject>();

// Добавление без риска переполнения
enemiesList.Add(newEnemy);

// При необходимости преобразования в массив
GameObject[] array = enemiesList.ToArray();

List<T> — мой основной инструмент, так как он:

• Автоматически увеличивает вместимость при добавлении элементов
• Предоставляет методы для поиска, сортировки и фильтрации
• Позволяет легко удалять элементы

2. Предварительная проверка границ

Если использование массива обязательно (например, для производительности в часто выполняемом коде), я добавляю проверки:

public void AddToArray<T>(ref T[] array, T newItem)
{
    // Проверяем, есть ли свободное место
    for (int i = 0; i < array.Length; i++)
    {
        if (array[i] == null)
        {
            array[i] = newItem;
            return;
        }
    }
    
    // Если места нет — создаем новый массив большего размера
    T[] newArray = new T[array.Length * 2];
    Array.Copy(array, newArray, array.Length);
    newArray[array.Length] = newItem;
    array = newArray;
}

3. Стратегии увеличения размера массива

При необходимости ручного расширения массива я применяю следующие стратегии:

• Увеличение на фиксированную величину — добавляем N элементов:

  int newSize = currentArray.Length + 10;
  

• Умножение размера (стандартный подход в List<T>):

  int newSize = currentArray.Length * 2;
  

• Стратегия, основанная на статистике использования — если известно, сколько элементов обычно добавляется.

4. Оптимизации для Unity

В Unity особое внимание уделяю:

• Минимизации аллокаций в Update — расширение массивов в реальном времени может вызывать сборку мусора.

• Использованию пулов объектов — для часто создаваемых/удаляемых объектов (пули, враги, эффекты):

  public class ObjectPool : MonoBehaviour
  {
      private GameObject[] pool;
      private int currentIndex = 0;
      
      public GameObject GetNext()
      {
          GameObject obj = pool[currentIndex];
          currentIndex = (currentIndex + 1) % pool.Length; // Циклический буфер
          return obj;
      }
  }
  

• Предварительное выделение памяти — если известно максимальное количество элементов.

5. Выбор структуры данных по потребностям

Помимо List<T>, в зависимости от задачи использую:

• Dictionary<TKey, TValue> — для быстрого доступа по ключу
• HashSet<T> — для хранения уникальных элементов
• Queue<T>/Stack<T> — для обработки в порядке FIFO/LIFO

Практический подход в Unity-проектах

1. На этапе проектирования оцениваю максимальное количество объектов и выбираю структуру данных:

   • Фиксированный массив — если количество строго ограничено
   • List<T> — в большинстве случаев
   • Пул объектов — для игровых объектов

2. При возникновении переполнения добавляю:

   • Логирование с указанием контекста
   • Визуальную индикацию в редакторе Unity
   • Graceful degradation — чтобы игра не крашилась

3. Для критичных по производительности систем (частицы, инстансинг) использую нативные массивы (NativeArray<T>) с Job System и Burst Compiler, где управление памятью требует особой аккуратности.

В итоге, проблема «закончившегося места в массиве» в современной Unity-разработке решается правильным выбором структур данных на этапе проектирования, а не как экстренная ситуация в рантайме.