# Массивы и коллекции

## Введение в массивы и коллекции

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

#### **Определение массивов и коллекций**

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

**Коллекции:** Коллекции представляют собой более гибкий и расширяемый способ хранения данных. В C# коллекции реализуют различные интерфейсы, такие как `IEnumerable`, `ICollection` и `IList`, предоставляя разнообразные функциональные возможности для работы с данными.

#### **Различия между массивами и коллекциями**

* **Фиксированный размер vs. Динамическое расширение:**
  * Массивы имеют фиксированный размер, который определяется при их создании.
  * Коллекции могут динамически увеличиваться или уменьшаться в размере в процессе выполнения программы.
* **Типы данных элементов:**
  * Массивы хранят элементы только одного типа данных.
  * Коллекции могут содержать элементы различных типов данных.
* **Индексация:**
  * Элементы массива доступны по индексу, который начинается с нуля.
  * Коллекции также могут поддерживать индексацию, но не все коллекции обязательно ее поддерживают.

#### **Преимущества использования массивов и коллекций**

**Преимущества массивов:**

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

**Преимущества коллекций:**

* Гибкость в управлении размером и структурой данных.
* Широкий выбор встроенных коллекций, упрощающих многие задачи.
* Встроенная поддержка LINQ (Language Integrated Query) для удобного запроса и обработки данных.

Выбор между массивами и коллекциями зависит от конкретной задачи и требований к хранению и обработке данных в приложении.

## Массивы в C\#

#### **Определение и объявление массивов**

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

```csharp
csharpCopy code// Одномерный массив целых чисел
int[] myArray;

// Инициализация массива
myArray = new int[5]; // Создание массива из 5 элементов

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

#### **Индексация и доступ к элементам массива**

**Индексация массива:** Элементы массива нумеруются с нуля. Для доступа к элементам используется их индекс:

```csharp
csharpCopy codeint[] myArray = { 10, 20, 30, 40, 50 };

// Доступ к элементам массива
int firstElement = myArray[0];   // 10
int thirdElement = myArray[2];   // 30
```

**Изменение элементов массива:** Элементы массива можно изменять:

```csharp
csharpCopy codemyArray[1] = 25; // Изменение второго элемента на 25
```

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

**Определение многомерных массивов:** C# поддерживает создание многомерных массивов. Например, двумерный массив:

```csharp
csharpCopy codeint[,] twoDimensionalArray = new int[3, 4]; // 3 строки, 4 столбца
```

**Индексация многомерных массивов:** Доступ к элементам двумерного массива осуществляется с помощью двух индексов:

```csharp
csharpCopy codetwoDimensionalArray[0, 1] = 10; // Задание значения для элемента в первой строке и втором столбце
```

#### **Методы массивов: Length, CopyTo, Clone**

**Метод Length:** Свойство `Length` возвращает количество элементов в массиве:

```csharp
csharpCopy codeint[] myArray = { 1, 2, 3, 4, 5 };

int arrayLength = myArray.Length; // 5
```

**Метод CopyTo:** Метод `CopyTo` копирует элементы массива в другой массив:

```csharp
csharpCopy codeint[] sourceArray = { 1, 2, 3, 4, 5 };
int[] destinationArray = new int[5];

sourceArray.CopyTo(destinationArray, 0); // Копирование элементов из sourceArray в destinationArray, начиная с индекса 0
```

**Метод Clone:** Метод `Clone` создает новый массив, являющийся точной копией существующего массива:

```csharp
csharpCopy codeint[] originalArray = { 1, 2, 3, 4, 5 };
int[] clonedArray = (int[])originalArray.Clone(); // Создание копии массива
```

Массивы в C# предоставляют эффективный и удобный способ работы с коллекциями данных, а знание и использование методов таких как `Length`, `CopyTo`, и `Clone` обогащает функциональность работы с массивами.

## Коллекции в C\#

#### **Общие интерфейсы коллекций: `IEnumerable`, `ICollection`, `IList`**

**`IEnumerable`**

Интерфейс `IEnumerable` предоставляет базовую функциональность для перебора элементов коллекции. Он включает в себя метод `GetEnumerator()`, который возвращает объект, реализующий интерфейс `IEnumerator`.

Пример использования `IEnumerable`:

```csharp
csharpCopy codeusing System;
using System.Collections;

class Program
{
    static void Main()
    {
        ArrayList list = new ArrayList() { 1, 2, 3, 4, 5 };

        // Использование foreach с IEnumerable
        foreach (int item in list)
        {
            Console.WriteLine(item);
        }
    }
}
```

**`ICollection`**

Интерфейс `ICollection` расширяет `IEnumerable` и добавляет базовые методы для управления коллекцией, такие как `Add`, `Clear`, `Contains`, `CopyTo`, `Remove`.

```csharp
csharpCopy codeusing System;
using System.Collections;

class Program
{
    static void Main()
    {
        ArrayList list = new ArrayList() { 1, 2, 3, 4, 5 };

        // Использование методов ICollection
        list.Add(6);
        list.Remove(3);

        Console.WriteLine($"Contains 2: {list.Contains(2)}");
    }
}
```

**`IList`**

Интерфейс `IList` расширяет `ICollection` и добавляет методы для работы с элементами по индексу, такие как `IndexOf`, `Insert`, `RemoveAt`.

```csharp
csharpCopy codeusing System;
using System.Collections;

class Program
{
    static void Main()
    {
        ArrayList list = new ArrayList() { 1, 2, 3, 4, 5 };

        // Использование методов IList
        int index = list.IndexOf(4);
        list.Insert(index, 10);

        Console.WriteLine($"Element at index {index}: {list[index]}");
    }
}
```

#### **Примеры стандартных коллекций: `List`, `Dictionary`, `Queue`, `Stack`**

**`List<T>`**

`List<T>` представляет собой динамический массив, который автоматически расширяется при добавлении элементов.

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> myList = new List<int>() { 1, 2, 3, 4, 5 };

        // Добавление элемента
        myList.Add(6);

        // Удаление элемента
        myList.Remove(3);

        // Итерация по списку
        foreach (int item in myList)
        {
            Console.WriteLine(item);
        }
    }
}
```

**`Dictionary<TKey, TValue>`**

`Dictionary<TKey, TValue>` представляет собой коллекцию пар ключ-значение, где каждый ключ должен быть уникален.

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Dictionary<string, int> myDictionary = new Dictionary<string, int>();

        // Добавление элемента
        myDictionary.Add("One", 1);

        // Получение элемента по ключу
        int value = myDictionary["One"];

        // Проверка наличия ключа
        bool containsKey = myDictionary.ContainsKey("Two");

        Console.WriteLine($"Value for key 'One': {value}");
        Console.WriteLine($"Contains key 'Two': {containsKey}");
    }
}
```

**`Queue<T>`**

`Queue<T>` представляет собой очередь элементов, работающую по принципу "первым пришел — первым вышел" (FIFO).

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Queue<string> myQueue = new Queue<string>();

        // Добавление элемента в очередь
        myQueue.Enqueue("First");
        myQueue.Enqueue("Second");
        myQueue.Enqueue("Third");

        // Извлечение элемента из очереди
        string firstItem = myQueue.Dequeue();

        Console.WriteLine($"First item: {firstItem}");
    }
}
```

**`Stack<T>`**

`Stack<T>` представляет собой стек элементов, работающий по принципу "последним пришел — первым вышел" (LIFO).

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Stack<int> myStack = new Stack<int>();

        // Добавление элемента в стек
        myStack.Push(1);
        myStack.Push(2);
        myStack.Push(3);

        // Извлечение элемента из стека
        int poppedItem = myStack.Pop();

        Console.WriteLine($"Popped item: {poppedItem}");
    }
}
```

#### **Работа с коллекциями: добавление, удаление, поиск элементов**

Рассмотрим общие методы для работы с коллекциями: `Add`, `Remove`, `Contains`.

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<string> myCollection = new List<string>() { "One", "Two", "Three" };

        // Добавление элемента
        myCollection.Add("Four");

        // Удаление элемента
        myCollection.Remove("Two");

        // Проверка наличия элемента
        bool containsElement = myCollection.Contains("Three");

        Console.WriteLine($"Contains element 'Three': {containsElement}");
    }
}
```

Методы `Add` и `Remove` используются для добавления и удаления элементов из коллекции. Метод `Contains` проверяет, содержится ли элемент в коллекции.

Коллекции в C# предоставляют удобные средства для организации данных и обеспечивают широкие возможности по управлению и работе с элементами.

## Итерация по массивам и коллекциям

#### **Использование циклов для перебора элементов**

**Итерация по массиву с использованием цикла for:**

Цикл `for` предоставляет возможность последовательного обхода элементов массива по индексам. Обратите внимание, что индексы начинаются с 0, и цикл выполняется до значения `Length - 1`.

```csharp
csharpCopy codeusing System;

class Program
{
    static void Main()
    {
        int[] myArray = { 1, 2, 3, 4, 5 };

        // Итерация по массиву с использованием цикла for
        for (int i = 0; i < myArray.Length; i++)
        {
            Console.WriteLine(myArray[i]);
        }
    }
}
```

**Итерация по коллекции с использованием цикла for:**

Для коллекций, имеющих свойство `Count`, можно использовать цикл `for` аналогичным образом.

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<string> myCollection = new List<string>() { "One", "Two", "Three" };

        // Итерация по коллекции с использованием цикла for
        for (int i = 0; i < myCollection.Count; i++)
        {
            Console.WriteLine(myCollection[i]);
        }
    }
}
```

#### **Использование ключевого слова foreach**

**Итерация по массиву с использованием foreach:**

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

```csharp
csharpCopy codeusing System;

class Program
{
    static void Main()
    {
        int[] myArray = { 1, 2, 3, 4, 5 };

        // Итерация по массиву с использованием foreach
        foreach (int item in myArray)
        {
            Console.WriteLine(item);
        }
    }
}
```

**Итерация по коллекции с использованием foreach:**

`foreach` также применим к коллекциям, реализующим интерфейс `IEnumerable`.

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<string> myCollection = new List<string>() { "One", "Two", "Three" };

        // Итерация по коллекции с использованием foreach
        foreach (string item in myCollection)
        {
            Console.WriteLine(item);
        }
    }
}
```

## Сортировка и поиск в массивах и коллекциях

#### **Методы сортировки для массивов и коллекций**

**Сортировка массива с использованием метода Array.Sort:**

Массивы в C# предоставляют метод `Sort()`, который позволяет отсортировать элементы в порядке возрастания.

```csharp
csharpCopy codeusing System;

class Program
{
    static void Main()
    {
        int[] myArray = { 5, 3, 1, 4, 2 };

        // Сортировка массива
        Array.Sort(myArray);

        // Вывод отсортированного массива
        foreach (int item in myArray)
        {
            Console.WriteLine(item);
        }
    }
}
```

**Сортировка коллекции с использованием метода List.Sort:**

`List<T>` также предоставляет метод `Sort()`, который используется для сортировки элементов.

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> myList = new List<int>() { 5, 3, 1, 4, 2 };

        // Сортировка коллекции
        myList.Sort();

        // Вывод отсортированной коллекции
        foreach (int item in myList)
        {
            Console.WriteLine(item);
        }
    }
}
```

#### **Поиск элементов: методы `IndexOf`, `Contains`**

**Поиск элемента в массиве с использованием метода `Array.IndexOf`:**

Массивы поддерживают метод `IndexOf`, который возвращает индекс первого вхождения элемента или -1, если элемент не найден.

```csharp
csharpCopy codeusing System;

class Program
{
    static void Main()
    {
        int[] myArray = { 1, 2, 3, 4, 5 };

        // Поиск индекса элемента в массиве
        int index = Array.IndexOf(myArray, 3);

        Console.WriteLine($"Index of element 3: {index}");
    }
}
```

**Поиск элемента в коллекции с использованием метода `List.Contains`:**

Коллекции, реализующие интерфейс `ICollection<T>`, обычно предоставляют метод `Contains`, который проверяет наличие элемента.

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<string> myCollection = new List<string>() { "One", "Two", "Three" };

        // Проверка наличия элемента в коллекции
        bool containsElement = myCollection.Contains("Two");

        Console.WriteLine($"Contains element 'Two': {containsElement}");
    }
}
```

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

## Работа с коллекциями в LINQ

#### **Введение в LINQ**

**LINQ (Language Integrated Query)** представляет собой набор языковых расширений в C#, которые добавляют возможности для выполнения запросов к данным наподобие SQL запросов. LINQ позволяет удобно и эффективно работать с различными источниками данных, включая массивы, коллекции, базы данных и другие.

LINQ состоит из двух основных частей:

1. **LINQ to Objects:** Предоставляет возможности для выполнения запросов к объектам и коллекциям в памяти.
2. **LINQ to SQL, LINQ to Entities:** Предоставляют возможности для выполнения запросов к базам данных.

#### **Основные операции LINQ: Where, Select, OrderBy**

**Оператор `Where`:**

Оператор `Where` используется для фильтрации элементов коллекции, основываясь на условии.

```csharp
csharpCopy codeusing System;
using System.Linq;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

        // Выбор только четных чисел
        var evenNumbers = numbers.Where(n => n % 2 == 0);

        // Вывод результата
        foreach (var number in evenNumbers)
        {
            Console.WriteLine(number);
        }
    }
}
```

**Оператор `Select`:**

Оператор `Select` используется для проекции (выбора) определенных свойств или преобразования элементов коллекции.

```csharp
csharpCopy codeusing System;
using System.Linq;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

        // Проекция: умножение каждого числа на 2
        var doubledNumbers = numbers.Select(n => n * 2);

        // Вывод результата
        foreach (var number in doubledNumbers)
        {
            Console.WriteLine(number);
        }
    }
}
```

**Оператор `OrderBy`:**

Оператор `OrderBy` используется для сортировки элементов коллекции по возрастанию.

```csharp
csharpCopy codeusing System;
using System.Linq;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 5, 3, 8, 1, 7 };

        // Сортировка чисел по возрастанию
        var sortedNumbers = numbers.OrderBy(n => n);

        // Вывод результата
        foreach (var number in sortedNumbers)
        {
            Console.WriteLine(number);
        }
    }
}
```

#### **Применение LINQ к коллекциям**

LINQ часто применяется для выполнения сложных запросов к коллекциям. Например, объединение операторов `Where`, `Select` и `OrderBy`:

```csharp
csharpCopy codeusing System;
using System.Linq;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 5, 3, 8, 1, 7 };

        // Выбор и сортировка четных чисел
        var result = numbers
            .Where(n => n % 2 == 0)    // Фильтрация четных чисел
            .OrderBy(n => n);          // Сортировка по возрастанию

        // Вывод результата
        foreach (var number in result)
        {
            Console.WriteLine(number);
        }
    }
}
```

Этот код выбирает только четные числа из списка и сортирует их по возрастанию. LINQ предоставляет мощные инструменты для упрощения кода и выполнения операций с коллекциями.

## Практические примеры использования массивов и коллекций

#### **Сценарии применения массивов**

**Пример 1: Хранение и обработка данных о студентах.**

```csharp
csharpCopy codeusing System;

class Program
{
    static void Main()
    {
        // Использование массива для хранения имен студентов
        string[] studentNames = { "Alice", "Bob", "Charlie", "David" };

        // Вывод списка студентов
        Console.WriteLine("Список студентов:");
        foreach (var name in studentNames)
        {
            Console.WriteLine(name);
        }
    }
}
```

**Пример 2: Обработка оценок студентов.**

```csharp
csharpCopy codeusing System;

class Program
{
    static void Main()
    {
        // Использование массива для хранения оценок студентов
        int[] grades = { 90, 85, 92, 88, 95 };

        // Вычисление средней оценки
        double averageGrade = 0;
        foreach (var grade in grades)
        {
            averageGrade += grade;
        }
        averageGrade /= grades.Length;

        // Вывод результата
        Console.WriteLine($"Средняя оценка: {averageGrade}");
    }
}
```

#### **Эффективное использование коллекций**

**Пример: Добавление и удаление элементов из списка.**

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Использование List для хранения и обработки данных
        List<string> fruits = new List<string> { "Apple", "Banana", "Orange" };

        // Добавление нового фрукта
        fruits.Add("Grapes");

        // Удаление фрукта по индексу
        fruits.RemoveAt(1);

        // Вывод обновленного списка фруктов
        Console.WriteLine("Список фруктов:");
        foreach (var fruit in fruits)
        {
            Console.WriteLine(fruit);
        }
    }
}
```

#### **Решение задач: фильтрация, сортировка, поиск**

**Пример: Фильтрация и сортировка чисел.**

```csharp
csharpCopy codeusing System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 5, 3, 8, 1, 7 };

        // Выбор и сортировка четных чисел
        var result = numbers
            .Where(n => n % 2 == 0)    // Фильтрация четных чисел
            .OrderBy(n => n);          // Сортировка по возрастанию

        // Вывод результата
        Console.WriteLine("Отфильтрованные и отсортированные числа:");
        foreach (var number in result)
        {
            Console.WriteLine(number);
        }
    }
}
```

## Лучшие практики при работе с массивами и коллекциями

#### **Оптимизация доступа к элементам массивов**

* **Использование foreach:** При итерации по всем элементам массива предпочтительнее использовать ключевое слово `foreach` вместо цикла `for`, так как оно обеспечивает безопасный доступ к элементам.

```csharp
csharpCopy codeint[] numbers = { 1, 2, 3, 4, 5 };

// Плохо
for (int i = 0; i < numbers.Length; i++)
{
    Console.WriteLine(numbers[i]);
}

// Хорошо
foreach (var number in numbers)
{
    Console.WriteLine(number);
}
```

#### **Избегание изменения коллекций в процессе итерации**

* **Использование копии коллекции:** Если необходимо изменять коллекцию в процессе итерации, создайте ее копию, чтобы избежать ошибок.

```csharp
csharpCopy codeList<string> fruits = new List<string> { "Apple", "Banana", "Orange" };

// Плохо
foreach (var fruit in fruits)
{
    if (fruit == "Banana")
    {
        fruits.Remove(fruit);  // Приведет к ошибке!
    }
}

// Хорошо
foreach (var fruit in fruits.ToList())
{
    if (fruit == "Banana")
    {
        fruits.Remove(fruit);  // Безопасное удаление
    }
}
```

#### **Выбор правильной коллекции для конкретной задачи**

* **List vs. HashSet vs. Dictionary:** Выбирайте коллекцию в зависимости от требований задачи. Например, `List` подходит для хранения упорядоченных элементов, `HashSet` - для уникальных элементов без порядка, `Dictionary` - для пар ключ-значение.

```csharp
csharpCopy code// Пример использования HashSet для уникальных значений
HashSet<int> uniqueNumbers = new HashSet<int> { 1, 2, 3, 1, 4, 5 };

// Пример использования Dictionary для хранения пар ключ-значение
Dictionary<string, int> ages = new Dictionary<string, int>
{
    { "Alice", 25 },
    { "Bob", 30 },
    { "Charlie", 22 }
};
```

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

***

{% embed url="<https://www.youtube.com/watch?v=1TvjgRJ34v8>" fullWidth="true" %}

***

## Упражнения

#### **Упражнение 1: Работа с массивами**

Создайте массив целых чисел и заполните его значениями. Выведите на экран сумму всех элементов массива.

<details>

<summary>Решение</summary>

```csharp
// Упражнение 1: Работа с массивами
using System;

class Program
{
    static void Main()
    {
        // Создание массива и заполнение значениями
        int[] numbers = { 1, 2, 3, 4, 5 };

        // Вычисление и вывод суммы элементов массива
        int sum = 0;
        foreach (int number in numbers)
        {
            sum += number;
        }

        Console.WriteLine($"Сумма элементов массива: {sum}");
    }
}
```

</details>

#### **Упражнение 2: Работа с коллекцией List**

Используя коллекцию List, добавьте несколько строковых значений (например, имен) и выведите их на экран.

<details>

<summary>Решение</summary>

```csharp
// Упражнение 2: Работа с коллекцией List
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Создание и заполнение коллекции List
        List<string> names = new List<string> { "Анна", "Иван", "Мария" };

        // Вывод элементов коллекции на экран
        foreach (string name in names)
        {
            Console.WriteLine(name);
        }
    }
}
```

</details>

#### **Упражнение 3: Поиск элемента в массиве**

Создайте массив строк и попросите пользователя ввести значение для поиска. Проверьте, содержится ли введенное значение в массиве, и выведите соответствующее сообщение.

<details>

<summary>Решение</summary>

```csharp
// Упражнение 3: Поиск элемента в массиве
using System;

class Program
{
    static void Main()
    {
        // Создание массива строк
        string[] words = { "apple", "banana", "orange", "grape" };

        // Ввод значения для поиска
        Console.Write("Введите слово для поиска: ");
        string searchWord = Console.ReadLine();

        // Проверка наличия введенного значения в массиве
        bool found = false;
        foreach (string word in words)
        {
            if (word == searchWord)
            {
                found = true;
                break;
            }
        }

        // Вывод результата
        if (found)
        {
            Console.WriteLine($"Слово '{searchWord}' найдено в массиве.");
        }
        else
        {
            Console.WriteLine($"Слово '{searchWord}' не найдено в массиве.");
        }
    }
}
```

</details>

#### **Упражнение 4: Работа с двумерным массивом**

Создайте двумерный массив (матрицу) и заполните его значениями. Выведите на экран сумму элементов каждой строки.

<details>

<summary>Решение</summary>

```csharp
// Упражнение 4: Работа с двумерным массивом
using System;

class Program
{
    static void Main()
    {
        // Создание двумерного массива и заполнение значений
        int[,] matrix = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

        // Вывод суммы элементов каждой строки
        for (int i = 0; i < matrix.GetLength(0); i++)
        {
            int sum = 0;
            for (int j = 0; j < matrix.GetLength(1); j++)
            {
                sum += matrix[i, j];
            }
            Console.WriteLine($"Сумма элементов строки {i + 1}: {sum}");
        }
    }
}
```

</details>

#### **Упражнение 5: Использование коллекции Dictionary**

Создайте коллекцию Dictionary для хранения пар ключ-значение (например, слово-перевод). Добавьте несколько элементов и выведите их на экран.

<details>

<summary>Решение</summary>

```csharp
// Упражнение 5: Использование коллекции Dictionary
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Создание и заполнение коллекции Dictionary
        Dictionary<string, string> translations = new Dictionary<string, string>
        {
            { "apple", "яблоко" },
            { "banana", "банан" },
            { "orange", "апельсин" }
        };

        // Вывод элементов коллекции на экран
        foreach (var pair in translations)
        {
            Console.WriteLine($"{pair.Key} - {pair.Value}");
        }
    }
}
```

</details>

#### **Упражнение 6: Сортировка массива**

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

<details>

<summary>Решение</summary>

```csharp
// Упражнение 6: Сортировка массива
using System;

class Program
{
    static void Main()
    {
        // Создание массива чисел
        int[] numbers = { 5, 3, 8, 1, 2 };

        // Сортировка массива
        Array.Sort(numbers);

        // Вывод отсортированного массива
        foreach (int number in numbers)
        {
            Console.Write(number + " ");
        }
        Console.WriteLine();
    }
}
```

</details>

#### **Упражнение 7: Удаление элемента из коллекции List**

Создайте коллекцию List строк и попросите пользователя ввести значение для удаления. Удалите все вхождения этого значения из списка и выведите результат.

<details>

<summary>Решение</summary>

```csharp
// Упражнение 7: Удаление элемента из коллекции List
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Создание и заполнение коллекции List строк
        List<string> colors = new List<string> { "red", "blue", "green", "red", "yellow" };

        // Вывод элементов коллекции на экран
        Console.WriteLine("Исходная коллекция:");
        foreach (string color in colors)
        {
            Console.Write(color + " ");
        }
        Console.WriteLine();

        // Ввод значения для удаления
        Console.Write("Введите цвет для удаления: ");
        string colorToRemove = Console.ReadLine();

        // Удаление всех вхождений введенного значения из списка
        colors.RemoveAll(c => c == colorToRemove);

        // Вывод измененной коллекции на экран
        Console.WriteLine("Измененная коллекция:");
        foreach (string color in colors)
        {
            Console.Write(color + " ");
        }
        Console.WriteLine();
    }
}
```

</details>

#### **Упражнение 8: Работа с коллекцией HashSet**

Используя коллекцию HashSet, добавьте несколько чисел и проверьте, содержится ли число, введенное пользователем, в этой коллекции.

<details>

<summary>Решение</summary>

```csharp
// Упражнение 8: Работа с коллекцией HashSet
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Создание и заполнение коллекции HashSet числами
        HashSet<int> numbers = new HashSet<int> { 1, 3, 5, 7, 9 };

        // Вывод элементов коллекции на экран
        Console.Write("Введите число для проверки наличия в коллекции: ");
        int userNumber = int.Parse(Console.ReadLine());

        // Проверка наличия введенного числа в коллекции HashSet
        if (numbers.Contains(userNumber))
        {
            Console.WriteLine($"Число {userNumber} содержится в коллекции.");
        }
        else
        {
            Console.WriteLine($"Число {userNumber} не содержится в коллекции.");
        }
    }
}
```

</details>

#### **Упражнение 9: Многомерные коллекции**

Создайте List\<List\<int>> для представления таблицы умножения. Заполните его значениями и выведите таблицу на экран.

<details>

<summary>Решение</summary>

```csharp
// Упражнение 9: Многомерные коллекции
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Создание List<List<int>> для представления таблицы умножения
        List<List<int>> multiplicationTable = new List<List<int>>();

        // Заполнение таблицы умножения значениями
        for (int i = 1; i <= 10; i++)
        {
            List<int> row = new List<int>();
            for (int j = 1; j <= 10; j++)
            {
                row.Add(i * j);
            }
            multiplicationTable.Add(row);
        }

        // Вывод таблицы умножения на экран
        foreach (List<int> row in multiplicationTable)
        {
            foreach (int value in row)
            {
                Console.Write($"{value}\t");
            }
            Console.WriteLine();
        }
    }
}
```

</details>

#### **Упражнение 10: Работа с коллекцией Queue**

Создайте коллекцию Queue для моделирования очереди. Добавьте несколько элементов, выведите их на экран, а затем извлеките и выведите первый элемент.

<details>

<summary>Решение</summary>

```csharp
// Упражнение 10: Работа с коллекцией Queue
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Создание и работа с коллекцией Queue
        Queue<string> queue = new Queue<string>();

        // Добавление элементов в очередь
        queue.Enqueue("Первый");
        queue.Enqueue("Второй");
        queue.Enqueue("Третий");

        // Вывод элементов очереди на экран
        Console.WriteLine("Элементы очереди:");
        foreach (string item in queue)
        {
            Console.WriteLine(item);
        }

        // Извлечение и вывод первого элемента
        string removedItem = queue.Dequeue();
        Console.WriteLine($"Извлеченный элемент: {removedItem}");
    }
}
```

</details>

***

## Вопросы

#### **Работа с массивами**

Как создать массив целых чисел и заполнить его значениями в языке программирования C#?

#### **Работа с коллекцией List**

Как добавить элементы в коллекцию List в C#?

#### **Поиск элемента в массиве**

Как осуществить поиск определенного значения в массиве и определить, содержится ли это значение в нем?

#### **Работа с двумерным массивом**

Как объявить и заполнить двумерный массив в C#? Как вывести сумму элементов каждой строки?

#### **Использование коллекции Dictionary**

Как создать и использовать коллекцию Dictionary для хранения пар ключ-значение?

#### **Сортировка массива**

Как выполнить сортировку массива в порядке возрастания в языке программирования C#?

#### **Удаление элемента из коллекции List**

Как удалить все вхождения определенного элемента из коллекции List в C#?

#### **Работа с коллекцией HashSet**

Как создать и использовать коллекцию HashSet в C#? Как проверить, содержится ли значение в HashSet?

#### **Многомерные коллекции**

Как создать и заполнить многомерную коллекцию List\<List\<int>> в C#?

#### **Работа с коллекцией Queue**

Как создать и использовать коллекцию Queue в C#? Как извлечь и вывести первый элемент из очереди?

***

## Тесты

{% embed url="<https://docs.google.com/forms/d/e/1FAIpQLSeuCLGrHTPcJov-iUvVxJ-wlqNQpJ3ypTLjp_i_mmbTsZYdmA/viewform?usp=sf_link>" fullWidth="true" %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://axideli.gitbook.io/osnovy-programmirovaniya-na-yazyke-c/massivy-i-kollekcii.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.