Hi, can you please revise my code in c# and point out my mistakes or inaccuracies?


internal class Program
{
    static bool isArrayCreated = false;
    static void Main(string[] args)
    {

        bool isArrayCreated = false;
        int arrayLength, addedArrayLength;
        byte choice;
        int[] array = new int[0];

        Console.WriteLine("Выберите действие:");
        Console.WriteLine("1. Создать массив");
        Console.WriteLine("2. Создать массив, вводя с клавиатуры");
        Console.WriteLine("3. Вывести массив");
        Console.WriteLine("4. Удалить все четные элементы из массива");
        Console.WriteLine("5. Добавить K элементов в начало массива");
        Console.WriteLine("6. Переставить четные элементы в начало массива, а нечетные - в конец");
        Console.WriteLine("7. Найти первый четный элемент массива и показать кол-во совершенных сравнений");
        Console.WriteLine("8. Выполнить сортировку массива простым выбором");
        Console.WriteLine("9. Бинарный поиск в отсортированном массиве");
        Console.WriteLine("0. Выход из программы");

        do
        {
            Console.Write("\nВыбор действия: ");

            choice = CheckChoiceInput();

            Console.WriteLine();
            switch (choice)
            {
                case 1:
                    Console.WriteLine("Какой массив вы хотите создать?\n1. Из случайных чисел\n2. Вводя с клавиатуры");
                    choice = CheckChoiceInput();

                    Console.Write("Введите длину массива: ");
                    arrayLength = CheckArrayLengthInput();

                    switch (choice)
                    {
                        case 1:
                            Console.WriteLine("Введите через 2 числа - границы диапазона случайных чисел массива: ");

                            int limit1 = CheckInt32Input();
                            int limit2 = CheckInt32Input();

                            array = GenerateArray(arrayLength, Math.Min(limit1, limit2), Math.Max(limit1, limit2));

                            isArrayCreated = true;
                            Console.WriteLine();
                            OutputColoredLine("green", "Массив из случайных чисел успешно сформирован");

                            break;

                        case 2:
                            array = new int[arrayLength];

                            Console.WriteLine("Примечание: вводите элементы массива через enter");

                            for (uint i = 0; i < arrayLength; i++)
                            {
                                array[i] = CheckInt32Input();
                            }

                            isArrayCreated = true;
                            OutputColoredLine("green", "Массив из введенных чисел успешно сформирован");
                            break;
                    }

                    break;
                //case 1:  // Формирование массива из случайных чисел с выбором длины и границ их 
                //    Console.Write("Введите длину массива: ");

                //    arrayLength = CheckArrayLengthInput();

                //    Console.WriteLine("Введите через 2 числа - границы диапазона случайных чисел массива: ");

                //    int limit1 = CheckInt32Input();
                //    int limit2 = CheckInt32Input();

                //    array = GenerateArray(arrayLength, Math.Min(limit1, limit2), Math.Max(limit1, limit2));

                //    isArrayCreated = true;
                //    Console.WriteLine();
                //    OutputColoredLine("green", "Массив из случайных чисел успешно сформирован");

                //    break;

                case 2:  // Формирование массива вводом с клавиатуры с выбором длины
                    Console.Write("Введите длину массива: ");
                    arrayLength = CheckArrayLengthInput();

                    array = new int[arrayLength];

                    Console.WriteLine("Примечание: вводите элементы массива через enter");

                    for (uint i = 0; i < arrayLength; i++)
                    {
                        array[i] = CheckInt32Input();
                    }

                    isArrayCreated = true;
                    OutputColoredLine("green", "Массив из введенных чисел успешно сформирован");

                    break;

                case 3:  // Вывод массива
                    if (!isArrayCreated)  // Проверка на существование массива 
                    {
                        OutputColoredLine("red", "Ошибка: массива не существует, сначала создайте его");
                        break;
                    }

                    CheckIfArrayIsCreated();

                    if (array.Length == 0)  // Проверка на пустоту массива
                    {
                        OutputColoredLine("yellow", "Массив пустой");
                        break;
                    }
                    
                    Console.Write("Массив: ");

                    foreach (int item in array)
                    {
                       Console.Write(item + " ");
                    }

                    Console.WriteLine();
                    break;

                case 4:  // Удаление четных элементов из массива
                    if (!isArrayCreated)  // Проверка на существование массива 
                    {
                        OutputColoredLine("red", "Ошибка: массива не существует, сначала создайте его");
                        break;
                    }

                    if (array.Length == 0)  // Проверка на пустоту массива
                    {
                        OutputColoredLine("red", "Ошибка: массив пустой, удаление четных элементов из массива невозможно");
                        break;
                    }

                    uint oddNumbers = 0;
                    for (uint i = 0; i < array.Length; i++)  // Подсчет количества нечетных элементов в массиве
                    {
                        if (array[i] % 2 != 0)
                            oddNumbers++;
                    }

                    if (array.Length == oddNumbers)  // Проверка на наличие четных элементов в массиве
                    {
                        Console.WriteLine("Четных чисел в массиве нет");
                        break;
                    }

                    int[] noEvenNumberArray = new int[oddNumbers];  // Создание временного массива длинной равной количеству нечетных элементов в массиве

                    uint j = 0;
                    for (uint i = 0; i < array.Length; i++)  // Заполнение массива "noEvenNumberArray" только нечетными элементами
                    {
                        if (array[i] % 2 != 0)
                        {
                            noEvenNumberArray[j] = array[i];
                            j++;
                        }
                    }

                    array = noEvenNumberArray;  // Массив "array" теперь ссылается на массив "noEvenNumberArray" 

                    OutputColoredLine("green", "Четные элементы успешно удалены из массива");

                    break;

                case 5: // Добавление K элементов в начало массива
                    if (!isArrayCreated)  // Проверка на существование массива 
                    {
                        OutputColoredLine("red", "Ошибка: массива не существует, сначала создайте его");
                        break;
                    }

                    Console.WriteLine("Какой массив вы хотите добавить?\n1. Из случайных чисел\n2. Вводя с клавиатуры");
                    choice = CheckChoiceInput();
                    
                    Console.Write("Введите количество элементов, которые хотите добавить в начало массива: ");
                    addedArrayLength = CheckArrayLengthInput();

                    if (addedArrayLength + array.Length > 1000000)
                    {
                        OutputColoredLine("red", "Ошибка: конечный массив получится слишком длинным, длина массива не должна быть больше 1 000 000 ");
                        break;
                    }

                    int[] extendedArray = new int[(addedArrayLength + array.Length)];  // Создание массива длиной в сумму длины основного массива "array" и количества дополнительных введенных элементов

                    switch (choice)
                    {
                        case 1:  // Создание рандомного массива
                            Console.WriteLine("Введите через 2 числа - границы диапазона случайных чисел массива: ");

                            int limit1 = CheckInt32Input();
                            int limit2 = CheckInt32Input();

                            int[] addedArray = GenerateArray(addedArrayLength, Math.Min(limit1, limit2), Math.Max(limit1, limit2));

                            for (uint i = 0; i < addedArrayLength; i++)
                            {
                                extendedArray[i] = addedArray[i];
                            }
                            for (uint i = 0; i < array.Length; i++)
                            {
                                extendedArray[addedArrayLength + i] = array[i];
                            }

                            break;

                        case 2:  // Создание массива вводом с клавиатуры
                            Console.WriteLine("Вводите элементы массива через enter");

                            for (uint i = 0; i < addedArrayLength; i++)
                            {
                                extendedArray[i] = CheckInt32Input();
                            }
                            for (uint i = 0; i < array.Length; i++)
                            {
                                extendedArray[addedArrayLength + i] = array[i];
                            }

                            break;
                    }

                    array = extendedArray;

                    OutputColoredLine("green", "К элементов успешно добавлены в начало массива");

                    break;

                case 6:  // Перестановка четных элементы в начало массива, а нечетных - в конец
                    if (!isArrayCreated)  // Проверка на существование массива 
                    {
                        OutputColoredLine("red", "Ошибка: массива не существует, сначала создайте его");
                        break;
                    }
                    if (array.Length == 0)  // Проверка на пустоту массива
                    {
                        OutputColoredLine("red", "Ошибка: массив пустой, перестановка четных и нечетных элементов невозможна");
                        break;
                    }

                    oddNumbers = 0;
                    uint evenNumbers = 0;
                    for (uint i = 0; i < array.Length; i++)  // Подсчет количества четных и нечетных элементов в массиве
                    {
                        if (array[i] % 2 != 0)
                            oddNumbers++;
                        else
                            evenNumbers++;
                    }

                    if (oddNumbers == 0)  // Проверка на наличие нечетных чисел в массиве
                    {
                        Console.WriteLine("Нечетных элементов нет в массиве");
                        break;
                    }
                    if (evenNumbers == 0)  // Проверка на наличие четных чисел в массиве
                    {
                        Console.WriteLine("Четных элементов нет в массиве");
                        break;
                    }

                    int[] oddNumbersArray = new int[oddNumbers];
                    int[] evenNumbersArray = new int[evenNumbers];

                    j = 0;
                    uint k = 0;
                    for (uint i = 0; i < array.Length; i++)  // Заполнение временных массивов "oddNumbersArray" только нечетными элементами и "evenNumbersArray" только четными 
                    {
                        if (array[i] % 2 != 0)
                        {
                            oddNumbersArray[j] = array[i];
                            j++;
                        }
                        else
                        {
                            evenNumbersArray[k] = array[i];
                            k++;
                        }
                    }

                    for (uint i = 0; i < evenNumbers; i++)  // Заполнение массива "array" числами сначала из массива "evenNumbersArray", а после из массива "oddNumbersArray"
                    {
                        array[i] = evenNumbersArray[i];
                    }
                    for (uint i = 0; i < oddNumbers; i++)
                    {
                        array[evenNumbers + i] = oddNumbersArray[i];
                    }

                    OutputColoredLine("green", "Массив успешно отсортирован. Четные элементы в начале массива, а нечетные - в конце");

                    break;

                case 7:  // Поиск первого четного элемента массива и вывод кол-ва совершенных сравнений");
                    if (!isArrayCreated)  // Проверка на существование массива 
                    {
                        OutputColoredLine("red", "Ошибка: массива не существует, сначала создайте его");
                        break;
                    }

                    if (array.Length == 0)  // Проверка на пустоту массива
                    {
                        OutputColoredLine("red", "Ошибка: массив пустой, поиск первого четного элемента невозможен");
                        break;
                    }

                    for (int i = 0; i < array.Length; i++)
                    {
                        if (array[i] % 2 == 0)
                        {
                            Console.WriteLine($"Первый четный элемент в массиве: {array[i]} \nКол-во совершенных сравнений: {i+1}");
                            break;
                        }
                    }

                    break;

                case 8:  // Сортировка массива простым выбором
                    if (!isArrayCreated)  // Проверка на существование массива 
                    {
                        OutputColoredLine("red", "Ошибка: массива не существует, сначала создайте его");
                        break;
                    }

                    if (array.Length == 0)  // Проверка на пустоту массива
                    {
                        OutputColoredLine("red", "Ошибка: массив пустой, сортировка невозможна");
                        break;
                    }

                    if (array.Length == 1)  // Сортировка бессмысленна если длина массива - 1
                    {
                        OutputColoredLine("yellow", "Внимание: массив длиной 1 нет смысла сортировать");
                        break;
                    }

                    array = SortArr(array);

                    OutputColoredLine("green", "Массив успешно отсортирован по возрастанию методом простого выбора");

                    break;

                case 9:  // Бинарный поиск элемента в остортированном массиве
                    if (!isArrayCreated)  // Проверка на существование массива 
                    {
                        OutputColoredLine("red", "Ошибка: массива не существует, сначала создайте его");
                        break;
                    }

                    if (array.Length == 0)  // Проверка на пустоту массива
                    {
                        OutputColoredLine("red", "Ошибка: массив пустой, поиск элементов невозможен");
                        break;
                    }

                    Console.Write("Введите число для поиска: ");
                    int numToFind = CheckInt32Input();

                    bool isReadyToSearchNum = true;
                    for (int i  = 0; i < array.Length; i++)
                    {
                        int[] temp = new int[array.Length];
                        temp = SortArr(temp);

                        if (array[i] != SortArr(array)[i])
                        {
                            OutputColoredLine("yellow", "Внимание: для бинарного поиска нужен остортированный массив, сначала остортируйте его");
                            isReadyToSearchNum = false;
                            break;
                        }
                        if (array.Length == 1)
                        {
                            if (numToFind == array[0])
                                Console.WriteLine($"Элемент {array[0]} в массиве находится под номером 1");
                            else
                                Console.WriteLine($"Элемент {numToFind} не найден");
                            break;
                        }

                    }

                    if (!isReadyToSearchNum)
                        break;

                    int left = 0;
                    int right = array.Length - 1;
                    int avrg;
                    do
                    {
                        avrg = (left + right) / 2;
                        if (array[avrg] < numToFind)
                            left = avrg + 1;
                        else
                            right = avrg;
                    } while (left != right);

                    if (array[left] == numToFind)
                        Console.WriteLine($"Элемент {numToFind} в массиве находится под номером {left + 1}");
                    else
                        Console.WriteLine($"Элемент {numToFind} не найден");
                    
                    break;
            }

        } while (choice != 0);

        Console.WriteLine("Программа завершила свою работу");
    }

    static void CheckIfArrayIsCreated()
    {
        if (!isArrayCreated)  // Проверка на существование массива 
        {
            OutputColoredLine("red", "Ошибка: массива не существует, сначала создайте его");
            break;
        }
    }
    static int[] SortArr(int[] array)
    {
        int min, n_min, j;
        for (int i = 0; i < array.Length - 1; i++)
        {
            min = array[i];
            n_min = i;
            for (j = i + 1; j < array.Length; j++)
            {
                if (array[j] < min)
                {
                    min = array[j];
                    n_min = j;
                }
            }
            array[n_min] = array[i];
            array[i] = min;
        }
        return array;
    }

    static int[] GenerateArray(int arrayLength, int min, int max)  // Создание массива из случайных чисел (длина - arrayLength, минимальное число - min, максимальное число - max)
    {
        Random number = new();
        int[] array = new int[arrayLength];

        for (uint i = 0; i < arrayLength; ++i)
        {
            array[i] = number.Next(min, max);
        }

        return array;
    }

    static void OutputColoredLine(string color, string line)
    {
        switch (color)
        {
            case "green":
                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine(line);
                Console.ResetColor();
                break;
            case "red":
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine(line);
                Console.ResetColor();
                break;
            case "yellow":
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine(line);
                Console.ResetColor();
                break;
        }
    }

    static byte CheckChoiceInput()
    {
        while (true)
        {
            try
            {
                byte choice = Convert.ToByte(Console.ReadLine());

                if (choice >= 0 && choice <= 9)
                    return choice;

                OutputColoredLine("red", "Ошибка: введите номер действия только от 0 до 9");
            }
            catch (FormatException)
            {
                OutputColoredLine("red", "Ошибка: введите номер действия!");
            }
            catch (OverflowException)
            {
                OutputColoredLine("red", "Ошибка: введите номер действия только от 0 до 9");
            }
        }
    }

    static int CheckInt32Input()
    {
        while (true)
        {
            try
            {
                int number = Convert.ToInt32(Console.ReadLine());
                return number;
            }
            catch (FormatException)
            {
                OutputColoredLine("red", "Ошибка: введите число!");
            }
            catch (OverflowException)
            {
                OutputColoredLine("red", "Ошибка: можно вводить только числа в диапазоне Int32 (от -2 147 483 648 до 2 147 483 647)");
            }
        }
    }

    static int CheckArrayLengthInput()
    {
        while (true)
        {
            try
            {
                int number = Convert.ToInt32(Console.ReadLine());

                if (number > 0 && number <= 1000000)
                    return number;
                else
                    OutputColoredLine("red", "Ошибка: длина может быть только в диапазоне от 1 до 1 000 000");
            }
            catch (FormatException)
            {
                OutputColoredLine("red", "Ошибка: введите число!");
            }
            catch (OverflowException)
            {
                OutputColoredLine("red", "Ошибка: длина может быть только в диапазоне от 1 до 1 000 000");
            }
        }
    }
}