Перейти на PRO

Какие основные проблемы возникают при использовании необобщенной коллекции ArrayList в C#?

Тип вопроса: C# Core Вероятность: 25% Категория: C# Разработчик

Ответ

System.Collections.ArrayList — устаревший (legacy) тип из .NET Framework 1.x, который не следует использовать в современном коде на C#. Его основные проблемы:

  1. Отсутствие типобезопасности (Type Safety)

    • ArrayList хранит элементы как object. Это приводит к необходимости боксинга (boxing) для значимых типов (value types) и явного приведения (casting) при извлечении.
    • Ошибки типа обнаруживаются не на этапе компиляции, а во время выполнения (InvalidCastException), что снижает надежность кода. 
      
ArrayList legacyList = new ArrayList();
legacyList.Add(42);           // Боксинг int в object
legacyList.Add("Hello");      // Строка - ссылочный тип

    int first = (int)legacyList[0]; // Анбоксинг + приведение (OK) int second = (int)legacyList[1]; // InvalidCastException во время выполнения!

  2. Снижение производительности

    • Операции боксинга и анбоксинга создают дополнительную нагрузку на сборщик мусора (GC), так как для каждого значимого типа создается новый объект в куче. 
      // Неэффективно с ArrayList
for (int i = 0; i < 100000; i++)
{
legacyList.Add(i); // 100000 операций боксинга
}

  3. Отсутствие контроля типов на этапе компиляции

    • Компилятор не может проверить, что в коллекцию добавляются элементы правильного типа. Это усложняет рефакторинг и повышает риск ошибок.

Современная альтернатива: List<T> (System.Collections.Generic)

// Используйте обобщенную коллекцию List<T>
List<int> modernList = new List<int>();
modernList.Add(42); // Тип проверяется компилятором, боксинга НЕТ
modernList.Add("Hello"); // ОШИБКА КОМПИЛЯЦИИ: нельзя преобразовать string в int

int first = modernList[0]; // Приведение не требуется, тип известен

// Высокая производительность для значимых типов
for (int i = 0; i < 100000; i++)
{
    modernList.Add(i); // Без боксинга, значения хранятся в массиве int[]
}

Вывод: Всегда используйте обобщенные коллекции (List<T>, Dictionary<TKey, TValue> и т.д.) из пространства имен System.Collections.Generic. Они обеспечивают типобезопасность, лучшую производительность и читаемость кода.

Ответ 18+ 🔞

Да ты посмотри, что за дичь оставили нам в наследство из каменного века .NET! System.Collections.ArrayList — это ж как старый "Запорожец" в мире коллекций: вроде едет, но бензина жрёт дохуя, и в любой момент может развалиться на ходу.

Смотри, в чём главная засада:

  1. Типы? Какие нахуй типы? Эта штука всё тащит как object. Кинул туда число — оно упаковалось в объект (boxing). Вытащил — нужно вручную разворачивать и кастовать. Ошибку узнаешь не когда пишешь код, а когда программа уже работает и внезапно — хрясь! — InvalidCastException тебе в ебало.

    ArrayList старьё = new ArrayList();
старьё.Add(42);           // Опа, бокснул int в object, создал мусор
старьё.Add("Привет");     // Ну и ладно, пускай

int первое = (int)старьё[0]; // Анбокс + каст (пока норм)
int второе = (int)старьё[1]; // Ёб твою мать! InvalidCastException в рантайме!

  2. Производительность — просто пиздец. Каждое твоё Add(123) для инта — это отдельный акт боксинга. Создаётся новый объект в куче. Делаешь это в цикле на 100к итераций — поздравляю, ты насрал 100к мелких объектов, которые потом GC будет героически выгребать. Красота.

    // Не делай так. Серьёзно.
for (int i = 0; i < 100000; i++)
{
    старьё.Add(i); // 100 тысяч раз "оберни-и-и-и-и-и-и-и-и-и-и-и-и-ись!"
}

  3. Компилятор — в сторонке курит. Он вообще нихуя не понимает, что ты там в эту коллекцию пихаешь. Хочешь рефакторить? Удачи, ищи все места кастов по всему коду. Ошибка всплывёт в самый неподходящий момент.

Нормальная альтернатива: List<T> (из System.Collections.Generic)

Вот это уже адекватный инструмент. Как иномарка после "Запорожца".

// Работаем как взрослые
List<int> нормальныйСписок = new List<int>();
нормальныйСписок.Add(42); // Компилятор видит: int -> List<int>. ОК.
нормальныйСписок.Add("Привет"); // ОШИБКА КОМПИЛЯЦИИ. Сразу, тут же. Нельзя string в List<int>.

int первое = нормальныйСписок[0]; // Никаких кастов! Тип известен.

// И производительность — огонь
for (int i = 0; i < 100000; i++)
{
    нормальныйСписок.Add(i); // Никакого бокса! Числа тупо ложатся в массив int[].
}

Короче, вывод простой, как три копейки: выкинь нахуй этот ArrayList на свалку истории. Бери List<T>, Dictionary<TKey, TValue> и другие обобщённые коллекции. Код будет безопасным, быстрым и понятным. А не этот цирк с приведением типов и исключениями из ниоткуда.

Видео-ответы

© ХакСобесов, 2026
support@hacksobesov.com