Как создать массив в си шарп

Массив представляет набор однотипных данных. Объявление массива похоже на объявление переменной за тем исключением, что после указания типа ставятся квадратные скобки:

тип_переменной[] название_массива;

Например, определим массив целых чисел:

int[] numbers;

После определения переменной массива мы можем присвоить ей определенное значение:

int[] nums = new int[4];

Здесь вначале мы объявили массив nums, который будет хранить данные типа int . Далее используя операцию new , мы выделили память для 4 элементов массива: new int[4] . Число 4 еще называется длиной массива . При таком определении все элементы получают значение по умолчанию, которое предусмотренно для их типа. Для типа int значение по умолчанию — 0.

Также мы сразу можем указать значения для этих элементов:

int[] nums2 = new int[4] < 1, 2, 3, 5 >; int[] nums3 = new int[] < 1, 2, 3, 5 >; int[] nums4 = new[] < 1, 2, 3, 5 >; int[] nums5 = < 1, 2, 3, 5 >;

Все перечисленные выше способы будут равноценны.

Подобным образом можно определять массивы и других типов, например, массив значений типа string :

string[] people = < "Tom", "Sam", "Bob" >;

Начиная с версии C# 12 для определения массивов можно использовать выражения коллекций , которые предполагают заключение элементов массива в квадратные скобки:

int[] nums1 = [ 1, 2, 3, 5 ]; int[] nums2 = []; // пустой массив

Индексы и получение элементов массива

Для обращения к элементам массива используются индексы . Индекс представляет номер элемента в массиве, при этом нумерация начинается с нуля, поэтому индекс первого элемента будет равен 0, индекс четвертого элемента — 3.

Используя индексы, мы можем получить элементы массива:

int[] numbers = < 1, 2, 3, 5 >; // получение элемента массива Console.WriteLine(numbers[3]); // 5 // получение элемента массива в переменную var n = numbers[1]; // 2 Console.WriteLine(n); // 2

Также мы можем изменить элемент массива по индексу:

int[] numbers = < 1, 2, 3, 5 >; // изменим второй элемент массива numbers[1] = 505; Console.WriteLine(numbers[1]); // 505

И так как у нас массив определен только для 4 элементов, то мы не можем обратиться, например, к шестому элементу. Если мы так попытаемся сделать, то мы получим ошибку во время выполнения:

int[] numbers = < 1, 2, 3, 5 >; Console.WriteLine(numbers[6]); // ! Ошибка - в массиве только 4 элемента

Свойство Length и длина массива

каждый массив имеет свойство Length , которое хранит длину массива. Например, получим длину выше созданного массива numbers:

int[] numbers = < 1, 2, 3, 5 >; Console.WriteLine(numbers.Length); // 4

Для получения длины массива после названия массива через точку указывается свойство Length : numbers.Length .

Получение элементов с конца массива

Благодаря наличию свойства Length , мы можем вычислить индекс последнего элемента массива — это длина массива — 1. Например, если длина массива — 4 (то есть массив имеет 4 элемента), то индекс последнего элемента будет равен 3. И, используя свойство Length , мы можем легко получить элементы с конца массива:

int[] numbers = < 1, 2, 3, 5>; Console.WriteLine(numbers[numbers.Length - 1]); // 5 - первый с конца или последний элемент Console.WriteLine(numbers[numbers.Length - 2]); // 3 - второй с конца или предпоследний элемент Console.WriteLine(numbers[numbers.Length - 3]); // 2 - третий элемент с конца

Однако при подобном подходе выражения типа numbers.Length — 1 , смысл которых состоит в том, чтобы получить какой-то определенный элемент с конца массива, утяжеляют код. И, начиная, с версии C# 8.0 в язык был добавлен специальный оператор ^ , с помощью которого можно задать индекс относительно конца коллекции.

Перепишем предыдущий пример, применяя оператор ^ :

int[] numbers = < 1, 2, 3, 5>; Console.WriteLine(numbers[^1]); // 5 - первый с конца или последний элемент Console.WriteLine(numbers[^2]); // 3 - второй с конца или предпоследний элемент Console.WriteLine(numbers[^3]); // 2 - третий элемент с конца

Перебор массивов

Для перебора массивов мы можем использовать различные типы циклов. Например, цикл foreach :

int[] numbers = < 1, 2, 3, 4, 5 >; foreach (int i in numbers)

Здесь в качестве контейнера выступает массив данных типа int . Поэтому мы объявляем переменную с типом int

Подобные действия мы можем сделать и с помощью цикл for:

int[] numbers = < 1, 2, 3, 4, 5 >; for (int i = 0; i

В то же время цикл for более гибкий по сравнению с foreach . Если foreach последовательно извлекает элементы контейнера и только для чтения, то в цикле for мы можем перескакивать на несколько элементов вперед в зависимости от приращения счетчика, а также можем изменять элементы:

int[] numbers = < 1, 2, 3, 4, 5 >; for (int i = 0; i

Также можно использовать и другие виды циклов, например, while :

int[] numbers = < 1, 2, 3, 4, 5 >; int i = 0; while(i

Многомерные массивы

Массивы характеризуются таким понятием как ранг или количество измерений. Выше мы рассматривали массивы, которые имеют одно измерение (то есть их ранг равен 1) — такие массивы можно представлять в виде ряда (строки или столбца) элемента. Но массивы также бывают многомерными. У таких массивов количество измерений (то есть ранг) больше 1.

Массивы которые имеют два измерения (ранг равен 2) называют двухмерными. Например, создадим одномерный и двухмерный массивы, которые имеют одинаковые элементы:

int[] nums1 = new int[] < 0, 1, 2, 3, 4, 5 >; int[,] nums2 = < < 0, 1, 2 >, < 3, 4, 5 >>;

Визуально оба массива можно представить следующим образом:

Массивы

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

Массивами в C# можно пользоваться практически так же, как и в других языках программирования. Тем не менее у них имеется одна особенность: они реализованы в виде объектов.

Для тoго чтобы воспользоваться массивом в программе, требуется двухэтапная процедура, поскольку в C# массивы реализованы в виде объектов. Во-первых, необходимо объявить переменную, которая может обращаться к массиву. И во-вторых, нужно создать экземпляр массива, используя оператор new.

using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 < class Program < static void Main(string[] args) < // Объявляем массив int[] myArr = new int[5]; // Инициализируем каждый элемент массива вручную myArr[0] = 100; myArr[1] = 23; myArr[2] = 25; myArr[3] = 31; myArr[4] = 1; foreach (int i in myArr) Console.WriteLine(i); Console.ReadLine(); >> >

Следует иметь в виду, что если массив только объявляется, но явно не инициализируется, каждый его элемент будет установлен в значение, принятое по умолчанию для соответствующего типа данных (например, элементы массива типа bool будут устанавливаться в false, а элементы массива типа int — в 0).

Инициализация массива

Помимо заполнения массива элемент за элементом (как показано в предыдущем примере), можно также заполнять его с использованием специального синтаксиса инициализации массивов. Для этого необходимо перечислить включаемые в массив элементы в фигурных скобках < >. Такой синтаксис удобен при создании массива известного размера, когда нужно быстро задать его начальные значения:

// Синтаксис инициализации массива с использованием // ключевого слова new int[] myArr = new int[] ; // Синтаксис инициализации массива без использования // ключевого слова new string[] info = < "Фамилия", "Имя", "Отчество" >; // Используем ключевое слово new и желаемый размер char[] symbol = new char[4] < 'X','Y','Z','M' >;

Обратите внимание, что в случае применения синтаксиса с фигурными скобками размер массива указывать не требуется (как видно на примере создания переменной myArr), поскольку этот размер автоматически вычисляется на основе количества элементов внутри фигурных скобок. Кроме того, применять ключевое слово new не обязательно (как при создании массива info).

Неявно типизированные массивы

Ключевое слово var позволяет определить переменную так, чтобы лежащий в ее основе тип выводился компилятором. Аналогичным образом можно также определять неявно типизированные локальные массивы. С использованием такого подхода можно определить новую переменную массива без указания типа элементов, содержащихся в массиве. Давайте рассмотрим пример:

using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 < class Program < static void Main(string[] args) < var arr1 = new[] < 1, 2, 3 >; Console.WriteLine("Тип массива arr1 - ",arr1.GetType()); var arr2 = new[] < "One", "Two", "Three" >; Console.WriteLine("Тип массива arr2 - ",arr2.GetType()); Console.ReadLine(); > > >

Неявно типизированные массивы

Разумеется, как и при создании массива с использованием явного синтаксиса C#, элементы, указываемые в списке инициализации массива, должны обязательно иметь один и тот же базовый тип (т.е. должны все быть int, string или MyCar).

Определение массива объектов

В большинстве случаев при определении массива тип элемента, содержащегося в массиве, указывается явно. Хотя на первый взгляд это выглядит довольно понятно, существует одна важная особенность. В основе каждого типа в системе типов .NET (в том числе фундаментальных типов данных) в конечном итоге лежит базовый класс System.Object. В результате получается, что в случае определения массива объектов находящиеся внутри него элементы могут представлять собой что угодно:

using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 < class Program < static void Main(string[] args) < // Объявляем и инициализируем массив объектов object[] arrByObject = < true, 10, "Привет", 13.7m >; // Выведем в консоль тип каждого члена массива foreach (object me in arrByObject) Console.WriteLine("Тип - ",me,me.GetType()); Console.ReadLine(); > > >

Массив объектов

Свойство Length

Реализация в C# массивов в виде объектов дает целый ряд преимуществ. Одно из них заключается в том, что с каждым массивом связано свойство Length, содержащее число элементов, из которых может состоять массив. Следовательно, у каждого массива имеется специальное свойство, позволяющее определить его длину.

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

using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 < class Program < static void Main(string[] args) < int[] myArr = < 1, 2, 3, 4 >; for (int i = 0; i < myArr.Length; i++) Console.WriteLine(myArr[i]); Console.ReadLine(); >> >

C#. Урок 8. Массивы

Одной из наиболее часто используемых структур данных является массив. О том как работать с массивами в C# вы узнаете в этом уроке.

Объявление массивов и инициализация массивов
- Объявление массивов
- Инициализация массивов
- Неявная типизация
- Прямоугольные массивы
- Зубчатые массивы
Исходный код примеров из этой статьи можете скачать из нашего github-репозитория.

Объявление массивов и инициализация массивов

Объявление массивов

Массив – это структура данных для хранения элементом определенного типа, имеющая фиксированный размер. Доступ к элементам массива производится по числовому индексу.

Для объявления массива, после указания типа его элементов, ставятся квадратные скобки:
```
int[] a1; // массив типа int
```
Перед использованием, массив обязательно нужно проинициализировать, это можно сделать сразу, при его объявлении:
```
int[] na2 = new int[5]; // массив из пяти элементов типа int
```
Либо после объявления:
```
int[] na3; na3 = new int[5]; // массив из пяти элементов типа int
```
Для доступа к элементам массива используются числовые индексы. Значения элементов массива будут равны значению по умолчанию для типа, массив которого был создан.

Например, для указанного выше a3 – это будут нули, так как для типа int значение по умолчанию: 0;
```
Console.WriteLine(na3[0]); // значение: 0 Console.WriteLine(na3[1]); // значение: 0
```
Если попытаться вывести элементы массива na1 :
```
Console.WriteLine(na1[0]); // ошибка компиляции
```
то приложение не будет собрано, т.к. массив предварительно нужно проинициализировать.

Инициализация массивов

Рассмотрим различные варианты инициализации массива. Как уже было сказано, можно просто указать количество элементов в массиве, при этом его элементам будут присвоены значения по умолчанию:
```
bool[] ba1 = new bool[3]; Console.WriteLine("ba1[0]: " + ba1[0].ToString());
```
После объявления массива значения элементам присваиваются через индекс:
```
string[] sa1 = new string[3]; sa1[0] = "abc"; sa1[1] = "def"; sa1[2] = "ghi"; Console.WriteLine($"sa1: , , ");
```
Есть возможность задать конкретные значения в момент объявления с использованием ключевого слова new и указанием типа:
```
double[] da1 = new double[3] ; Console.WriteLine($"da1: , , ");
```
Либо без ключевого слова new:
```
double[] da2 = ; Console.WriteLine($"da2: , , ");
```
Неявная типизация

При объявлении массива можно воспользоваться ключевым словом var . При этом тип элементов массива следует задать явно в правой части объявления:
```
var va2 = new string[3]; va2[0] = "John"; va2[1] = "Mary"; va2[2] = "Mike"; Console.WriteLine($"va2: , , ");
```
Либо предоставить возможность “поработать” системе вывода типов:
```
var va1 = new[] ; Console.WriteLine($"va1: , , ");
```
Доступ к элементам массива. Обход элементов массива.

Как уже было сказано выше, за доступ к элементам массива отвечают числовые индексы:
```
int[] na4 = ; Console.WriteLine($"na4[0]: ");
```
При этом, если вы укажете индекс больше, чем максимально возможный, то будет выброшено исключение:
```
Console.WriteLine($"na4[10]: ");
```
Приведенная выше строка приведет к выбросу следующего исключения:

Unhandled exception. System.IndexOutOfRangeException: Index was outside the bounds of the array .

Обход элементов массива можно производить с помощью циклов for , foreach и while , последний самый неудобный для работы с массивами, его мы рассматривать не будем. Если вы работаете с циклом for , то для указания верхней границы инкрементируемой переменной можно воспользоваться свойством Length у массива:
```
for(int i = 0; i < na4.Length; i++) < Console.Write(na4[i].ToString() + " "); >// 1 2 3 4 5
```
Более удобным для обхода элементов будет foreach :
```
foreach(var v in na4) < Console.Write(v.ToString() + " "); >// 1 2 3 4 5
```
Преимущество цикла for состоит в том, что в нем вы можете модифицировать элементы массива:
```
for(int i = 0; i < na4.Length; i++) < na4[i] = (na4[i] + 3) * 10; Console.Write(na4[i].ToString() + " "); >// 40 50 60 70 80
```
Передача массива в метод

Массивы являются ссылочным типом данных, это означает, что их значения хранятся в куче, а имя переменной массива является ссылкой на соответствующую область памяти. При передаче массива в качестве аргумента в метод, происходит присваивание значения переменной массива переменной определяющей аргумент, а так как имя массива – это ссылка, то фактически происходит передача ссылки на значение в куче. Поэтому, если вы передали массив в функцию и внутри этой функции произошла модификация этого массива, то исходный массив тоже изменится.

Создадим метода WorkWithArray , который изменяет содержимое массива:

public static void WorkWithArray(int[] arr)

Вызовем его в методе Main :
```
int[] na5 = ; foreach(var v in na5) // 1 2 3 4 5 Console.Write(v + " "); Console.WriteLine(); WorkWithArray(na5); foreach(var v in na5) // 123 2 3 4 5 Console.Write(v + " ");
```
Ниже приведена иллюстрация того, как массив и ссылки на него располагаются в памяти.

Переменные na5 в методе Main и arr в методе WorkWithArray ссылаются на одну и ту же область памяти в куче, поэтому изменение массива через переменную arr отражается на переменной na5 .

Многомерные массивы

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

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

Прямоугольные массивы могут содержать несколько измерений (два и более), при этом количество элементов в каждом подизмерении (в каждой строке) одинаково.

Рассмотрим на примерах работу с такими массивами:
```
double[,] dm1 = new double[3, 3]; for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) dm1[i, j] = i + j; for (int i = 0; i < 3; i++) < for (int j = 0; j < 3; j++) Console.Write($""); Console.WriteLine(); > Console.WriteLine(); double[,] dm2 = < < 1, 2, 3 >, < 4, 5, 6 >>; for (int i = 0; i < 2; i++) < for (int j = 0; j < 3; j++) Console.Write($""); Console.WriteLine(); > Console.WriteLine();
```
Зубчатые массивы

В зубчатых массивах элементами верхнего уровня являются другие массивы, это позволяет создавать многомерные структуры, у которых строки имеют разную длину:
```
int[][] nm1 = new int[3][]; for(int i = 0; i < nm1.Length; i++) nm1[i] = new int[i+1]; for(int i = 0; i < nm1.Length; i++) < for(int j = 0; j < nm1[i].Length; j++) Console.Write($""); Console.WriteLine(); >
```
Класс System.Array

Класс System.Array является базовым для всех массивов, это позволяет использовать свойства и методы данного класса при работе с массивом. Ниже в таблицах приведены некоторые полезные свойства и методы из System.Array , более полную информацию вы можете найти в официальной документации Microsoft ( https://docs.microsoft.com/ru-ru/dotnet/api/system.array ).

Свойства класса System.Array

Имя свойства

Назначение

Число элементов в массиве. Учитываются все измерения.

Ранг массива – число измерений.
```
int[] na6 = ; int[,] nm2 = < , >; int[][] nm3 = new int[3][]; for(int i = 0; i < nm3.Length; i++) nm3[i] = new int[i+1]; Console.WriteLine($"na6: Length=, Rank="); // na6: Length=7, Rank=1 Console.WriteLine($"nm2: Length=, Rank="); // nm2: Length=6, Rank=2 Console.WriteLine($"nm3: Length=, Rank="); // nm3: Length=3, Rank=1
```
Методы класса System.Array

Символ * после названия метода означает, что он имеет более одной сигнатуры, за дополнительной информацией обращайтесь к официальной документации.

Имя метода

Назначение

BinarySearch(Array, Object)*

Выполняет поиск элемента в массиве.

Clear(Array, Int32, Int32)

Присваивает значение по умолчанию определенному количеству элементов массива начиная с заданного индекса.

Создает копию массива (неполную).

Copy(Array, Array, Int32)*

Копирует данные из одного массива в другой в заданном количестве.

CopyTo(Array, Int32)*

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

Exists(T[], Predicate)

Определяет наличие элемента удовлетворяющему предикату.

GetValue(Int32)*

Возвращает значение по указанному индексу.

IndexOf(Array, Object)*

Возвращает индекс первого вхождения элемента в массиве.

Reverse(Array)*

Задает обратный порядок для элементов в массиве.

Сортирует элементы массива.

Для вывода содержимого массива в консоль создадим метод PrintArray :
```
public static void PrintArray(string txt, T[] arr) < Console.Write($": "); foreach(var v in arr) < Console.Write($""); > >
```
Ниже приведены примеры использования представленных выше методов и свойств класса System.Array :
```
int[] na6 = ; int[,] nm2 = < , >; int[][] nm3 = new int[3][]; for(int i = 0; i < nm3.Length; i++) nm3[i] = new int[i+1]; Console.WriteLine($"na6: Length=, Rank="); // na6: Length=7, Rank=1 Console.WriteLine($"nm2: Length=, Rank="); // nm2: Length=6, Rank=2 Console.WriteLine($"nm3: Length=, Rank="); // nm3: Length=3, Rank=1 Console.WriteLine("BinarySearch result: " + Array.BinarySearch(na6, 5).ToString()); // BinarySearch result: 4 var na7 = (int[])na6.Clone(); Array.Clear(na7, 2, 2); PrintArray("na6", na6); // na6: 1 2 3 4 5 6 7 PrintArray("na7", na7); // na7: 1 2 0 0 5 6 7 Array.Copy(na7, na6, 4); PrintArray("na6 after copy", na6); // na6 after copy: 1 2 0 0 5 6 7 (new int[]).CopyTo(na6, 0); PrintArray("na6", na6); // na6: 1 2 3 4 5 6 7 var ans = Array.Exists(na6, v => (v % 2) == 0); Console.WriteLine($"Is even number exists in na6? Answer: "); Array.Fill(na7, 7); PrintArray("na7", na7); // na7: 7 7 7 7 7 7 7 Console.WriteLine($"Value at 3 index in na6: "); Console.WriteLine($"Index of value=5 in na6: "); Array.Reverse(na6); PrintArray("na6", na6); // na6: 7 6 5 4 3 2 1 Array.Sort(na6); PrintArray("na6", na6); // na6: 1 2 3 4 5 6 7
```
Исходный код примеров из этой статьи можете скачать из нашего github-репозитория.

Раздел: .NET / C# Уроки по C# Метки: .NET, C#, Уроки по C#

C#. Урок 8. Массивы : 3 комментария
1. Аноним 03.05.2022 А как создать публичный массив?
1. Антон 13.04.2023 Для создания публичного массива в C# нужно использовать модификатор доступа `public` перед типом массива и перед именем переменной массива, которую вы хотите создать. Например: “`
  public int[] myPublicArray = new int[10];
  “` В данном примере мы создаем публичный массив `myPublicArray`, состоящий из 10 элементов типа `int`. Теперь этот массив будет доступен для использования из любого места вашей программы
Массивы в C#: Все что необходимо знать

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

Что такое массив?

Массив в C# — это коллекция элементов одного типа, хранящихся в памяти непрерывно, где каждый элемент имеет индекс. Индексация начинается с нуля.

Объявление массива
```
int[] myArray; 
```
Здесь мы объявили массив целых чисел myArray , но пока что он не содержит ни одного элемента.

Инициализация массива

Статическая инициализация:
```
int[] myArray = new int[5]; // Массив из 5 элементов 
```
Инициализация с набором значений:
```
int[] myArray = < 1, 2, 3, 4, 5 >; 
```
Работа с элементами массива

Доступ к элементам массива осуществляется по индексу:
```
int[] myArray = < 1, 2, 3, 4, 5 >; int firstElement = myArray[0]; // 1 int thirdElement = myArray[2]; // 3 
```
Индексы в массиве начинаются с 0, так что myArray[0] возвращает первый элемент.

Изменение элементов
```
myArray[3] = 100; // Меняем четвертый элемент массива на 100 
```
Особенности массивов в C

Размер массива

Размер массива в C# фиксирован после создания. Вы не можете увеличить или уменьшить его после инициализации. Для динамически изменяемых коллекций используются другие типы, например List .

Перебор элементов массива

Для перебора элементов массива обычно используют циклы, такие как for или foreach :
```
foreach (int item in myArray) < Console.WriteLine(item); > 
```
Многомерные массивы

В C# есть поддержка многомерных массивов. Есть два типа: прямоугольные и ступенчатые (jagged).

Читайте так же Наследование в C# простым языком: 4 наглядных примера

Прямоугольные массивы:
```
int[,] matrix = new int[2, 3]; 
```
Такой массив представляет собой матрицу 2×3.

Ступенчатые массивы:
```
int[][] jaggedArray = new int[3][]; jaggedArray[0] = new int[2]; jaggedArray[1] = new int[3]; jaggedArray[2] = new int[4]; 
```
Каждый ‘ряд’ такого массива может иметь разную длину.

Полезные операции с массивами
- Длина массива: свойство Length возвращает количество элементов в массиве.
- Сортировка: метод Array.Sort(myArray) сортирует массив по возрастанию.
- Поиск: метод Array.Find(myArray, условие) помогает найти элемент, соответствующий условию.
- Копирование: Array.Copy(sourceArray, destinationArray, length) используется для копирования элементов из одного массива в другой.
Заключение

Массивы в C# — это мощный и гибкий инструмент. Хоть их размер и фиксирован после создания, они обеспечивают высокую производительность за счет непрерывного расположения элементов в памяти. Используйте массивы для структурированного хранения данных, когда вы заранее знаете их количество и вам необходим быстрый доступ к элементам по индексу.

Эта статья является лишь вводным руководством в мир массивов C#. Существует множество продвинутых тем и техник работы с массивами, включая многомерные массивы, обработку и трансформацию данных, которые вы сможете изучить по мере погружения в язык.
Похожие публикации:

Как создать массив в си шарп