Все возможные способы инициализации массивов в C#: полный обзор синтаксиса

Полный обзор синтаксисов инициализации массивов в C#

Вы абсолютно правы: в C# существует несколько способов инициализации массивов, и новичкам легко запутаться. Давайте разберём все варианты по порядку, от самых старых до современных.

1. Базовые синтаксисы (все версии C#)

Вариант A: Указание размера и значений

int[] arr = new int[3] { 1, 2, 3 };

Самый явный способ. Размер массива (3) должен совпадать с количеством элементов в инициализаторе. Если не совпадёт — ошибка компиляции.

Вариант B: Без указания размера

int[] arr = new int[] { 1, 2, 3 };

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

Вариант C: С неявной типизацией (C# 3.0+)

int[] arr = new[] { 1, 2, 3 };

Компилятор сам определяет тип массива по элементам. Работает только для однотипных данных. Если элементы разных типов (например, 1 и "text"), будет ошибка.

Вариант D: Сокращённый синтаксис (C# 3.0+)

int[] arr = { 1, 2, 3 };

Самый короткий способ. Работает только при объявлении переменной с инициализацией. Именно поэтому ваш пример с arr5 = { 1, 2, 3 }; не работает — это присваивание, а не объявление.

2. Почему arr5 = { 1, 2, 3 } — ошибка?

Сокращённый синтаксис { } — это часть объявления переменной, а не самостоятельное выражение. Вы можете использовать его только в контексте инициализации:

// Работает
int[] arr = { 1, 2, 3 };

// Не работает — отдельное присваивание
int[] arr5;
arr5 = { 1, 2, 3 }; // Ошибка CS1525

// Работает — с new
arr5 = new[] { 1, 2, 3 };
arr5 = new int[] { 1, 2, 3 };

3. Передача массива в метод одной строкой

Да, это возможно. Используйте синтаксис с new[] или new int[] прямо в вызове метода:

void PrintArray(int[] arr) { /* ... */ }

// Вызов с созданием массива на лету
PrintArray(new[] { 10, 20, 30 });
PrintArray(new int[] { 10, 20, 30 });

// Сокращённый синтаксис НЕ работает в этом случае
// PrintArray({ 10, 20, 30 }); // Ошибка!

4. Многомерные и ступенчатые массивы

Прямоугольные (многомерные) массивы:

// Двумерный массив 2x3
int[,] arr2d = new int[2, 3] { { 1, 2, 3 }, { 4, 5, 6 } };

// С неявным размером
int[,] arr2d2 = new int[,] { { 1, 2 }, { 3, 4 } };

// Сокращённо
int[,] arr2d3 = { { 1, 2 }, { 3, 4 } };

Ступенчатые (jagged) массивы:

// Массив массивов — каждый подмассив может быть разной длины
int[][] jagged = new int[2][];
jagged[0] = new int[] { 1, 2, 3 };
jagged[1] = new int[] { 4, 5 };

// Инициализация в одной строке
int[][] jagged2 = new int[][] 
{
    new int[] { 1, 2, 3 },
    new int[] { 4, 5 }
};

5. Рекомендации по выбору синтаксиса

• Для простых случаев — используйте сокращённый { 1, 2, 3 } при объявлении переменной.
• Для передачи в метод — new[] { 1, 2, 3 } или new int[] { 1, 2, 3 }.
• Для пустых массивов — Array.Empty<int>() (эффективнее, чем new int[0]).
• Для больших массивов с повторяющимися значениями — используйте Enumerable.Repeat или циклы.

Надеюсь, теперь стало понятнее! Главное запомнить: сокращённый синтаксис { } — это не самостоятельное выражение, а часть объявления.

List<int> list = new List<int> { 1, 2, 3 };

// Преобразование в массив
int[] arr = list.ToArray();

int[] arr = [1, 2, 3]; // Вместо { 1, 2, 3 }

// Также работает для List и других коллекций
List<int> list = [1, 2, 3];
Span<int> span = [1, 2, 3];

int[] arr;
arr = [1, 2, 3]; // Работает в C# 12+

int[] arr = Enumerable.Range(1, 5).ToArray(); // [1, 2, 3, 4, 5]
int[] zeros = Enumerable.Repeat(0, 10).ToArray(); // [0, 0, 0, ...]