INDEX monday better

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;


namespace ConsoleApplication2
{
    [Serializable]
    public struct Person
    {
        public bool active;
        public string name;
        public int year;
        public int rank;
        public Person(bool _active, string _name, int _year, int _rank)
        {
            active = _active;
            name = _name;
            year = _year;
            rank = _rank;
        }
        public void Show()
        {
            //if (active)
            //{
            Console.WriteLine("{0,-40} {1,5} {2,3}", name, year, rank);
            //}
        }
    }
    [Serializable]
    public struct IndexEntry
    {
        public string key;
        public int length;
        public int offset;
        public IndexEntry(string _key, int _length, int _offset)
        {
            key = _key;
            length = _length;
            offset = _offset;
        }
        public void Show()
        {
            Console.WriteLine("{0,-40} {1} {2}", key, length, offset);
        }
    }
    class Program
    {
        static string dbPath = Path.Combine(Environment.CurrentDirectory, "contestants.dat");
        static string indexPath = Path.Combine(Environment.CurrentDirectory, "index.dat");
        static IndexEntry[] AddIndexEntryToArray(IndexEntry[] array, IndexEntry entryToAdd)
        {
            var newArray = new IndexEntry[array.Length + 1];
            int i = 0;
            for (i = 0; i < array.Length; i++)
            {
                newArray[i] = array[i];
            }
            newArray[i] = entryToAdd;
            return newArray;
        }
        static Person[] AddPersonToArray(Person[] array, Person personToAdd)
        {
            var newArray = new Person[array.Length + 1];
            int i = 0;
            for (i = 0; i < array.Length; i++)
            {
                newArray[i] = array[i];
            }
            newArray[i] = personToAdd;
            return newArray;
        }
        static void AddToEndOfFile(Person person)                               // добавить переданную запись в конец БД
        {
            var formatter = new BinaryFormatter();
            var memoryStream = new MemoryStream();
            var fs = new FileStream(dbPath, FileMode.OpenOrCreate, FileAccess.Write); // добавление записи в файл
            fs.Seek(0, SeekOrigin.End);
            BinaryWriter bw = new BinaryWriter(fs);
            byte[] data = new byte[255];                // массив байтов под сериализованную запись (решение проблемы с размером)
            formatter.Serialize(memoryStream, person);
            memoryStream.Position = 0;
            data[0] = (byte)memoryStream.Length;        // в нулевую ячейку массива - количество байтов в сериализованной записи
            memoryStream.Read(data, 1, (int)memoryStream.Length); // в массив с первой ячейки все из сериализованной записи из памяти
            bw.Write(data);                             // запись массива байтов в конец файла
            fs.Close();
        }
        static void AddToEndOfFile(IndexEntry entry)                            // добавить переданную запись в конец индексов
        {
            var formatter = new BinaryFormatter();
            var memoryStream = new MemoryStream();
            var fs = new FileStream(indexPath, FileMode.OpenOrCreate, FileAccess.Write); // добавление записи в файл
            fs.Seek(0, SeekOrigin.End);
            BinaryWriter bw = new BinaryWriter(fs);
            byte[] data = new byte[255];                // массив байтов под сериализованную запись (решение проблемы с размером)
            formatter.Serialize(memoryStream, entry);
            memoryStream.Position = 0;
            data[0] = (byte)memoryStream.Length;        // в нулевую ячейку массива - количество байтов в сериализованной записи
            memoryStream.Read(data, 1, (int)memoryStream.Length); // в массив с первой ячейки все из сериализованной записи из памяти
            bw.Write(data);                             // запись массива байтов в конец файла
            fs.Close();
        }
        static void AddToIndexes(IndexEntry entry)
        {
            var fs = new FileStream(dbPath, FileMode.Open, FileAccess.Read);
            fs.Position = 0;
            if ((int)fs.Length == 255)                                              // если в базе 1 запись -
            {
                AddToEndOfFile(entry);                                              // пишем в конец индексов;
            }
            else                                                                    // если больше одной  -
            {
                bool done = false;
                var entryArray = new IndexEntry[(int)fs.Length / 255];
                int counter = 0;
                int i = 0;
                while (i < fs.Length / 255 - 1)
                {
                    IndexEntry ejected = EjectEntry(i);
                    int comp = ejected.key.CompareTo(entry.key);                // ej<en= -1 ej=en =0 ej>en=1
                    if (comp == -1 || comp == 0)                                             // ФИО извлеченной записи < ФИО введенной
                    {
                        entryArray[counter++] = ejected;
                    }
                    else
                    {
                        if (!done)
                        {
                            entryArray[counter++] = entry;
                            done = true;
                        }
                        entryArray[counter++] = ejected;
                    }
                    i++;
                }
                if (!done)
                {
                    entryArray[counter] = entry;
                }

                UpdateIndex(entryArray);
            }
            fs.Close();
        }
        static int[] AddToIntArray(int[] array, int toAdd)
        {
            int i = 0;
            int[] newArray = new int[array.Length + 1];
            for (i = 0; i < array.Length; i++)
            {
                newArray[i] = array[i];
            }
            newArray[i] = toAdd;
            return newArray;
        }
        static byte[] ArrayOfSerialized(Person person)                          // этот массив нужно будет писать в файл БД
        {
            var formatter = new BinaryFormatter();
            var memoryStream = new MemoryStream();
            byte[] data = new byte[255];                            // массив байтов под сериализованную запись (решение проблемы с размером)
            formatter.Serialize(memoryStream, person);
            memoryStream.Position = 0;
            data[0] = (byte)memoryStream.Length;                    // в нулевую ячейку массива - количество байтов в сериализованной записи
            memoryStream.Read(data, 1, (int)memoryStream.Length);   // в массив с первой ячейки все из сериализованной записи из памяти
            return data;                                                    // этот массив нужно будет писать в файл
        }
        static IndexEntry[] ArrayOfEntries()
        {
            var fs = new FileStream(indexPath, FileMode.Open, FileAccess.Read);
            var array = new IndexEntry[fs.Length / 255];
            for (int i = 0; i < fs.Length / 255; i++)
            {
                array[i] = EjectEntry(i);
            }
            fs.Close();
            return (array);
        }
        static int AskForAction(int qtyOfActions)                               // запросить команду меню с проверкой вводимых значений
        {
            int act;
            bool ok;
            Console.WriteLine();
            do
            {
                Console.Write("Команда: ");
                string buf = Console.ReadLine();
                ok = int.TryParse(buf, out act) && act > 0 && act <= qtyOfActions;
                if (!ok)
                    RedLn("Доступны команды 1 - " + qtyOfActions + ".");
            } while (!ok);
            Console.WriteLine();
            return act;
        }
        static Person AskForNewPerson()                                         // запросить нового участника, создать и вернуть запись
        {
            Console.Clear();
            string name;
            int year, rank;
            bool ok;
            Console.Write("ФИО: ");                         // ввод ФИО
            name = Console.ReadLine();
            int tempParse;
            do                                              // ввод года
            {
                Console.Write("Год рождения: ");
                string buf = Console.ReadLine();
                ok = int.TryParse(buf, out tempParse) && tempParse > 1900 && tempParse < 2015;
                if (!ok)
                {
                    RedLn("Ошибка.");
                    Console.WriteLine("Убедитесь в правильности введенного года рождения и повторите ввод.\n");
                }
            } while (!ok);
            year = tempParse;
            do                                              // ввод разряда
            {
                Console.Write("Текущий разряд: ");
                string buf = Console.ReadLine();
                ok = int.TryParse(buf, out tempParse) && tempParse >= 0 && tempParse < 10;
                if (!ok)
                {
                    RedLn("Ошибка.");
                    Console.WriteLine("Убедитесь в правильности введенного разряда и повторите ввод.\n");
                }
            } while (!ok);
            rank = tempParse;
            return new Person(true, name, year, rank);      // конец ввода данных и возврат записи
        }
        static void ChangePerson(int number, Person person)
        {
            var formatter = new BinaryFormatter();
            var memoryStream = new MemoryStream();
            var fs = new FileStream(dbPath, FileMode.Open, FileAccess.Write); // добавление записи в файл
            fs.Position = number * 255;
            BinaryWriter bw = new BinaryWriter(fs);
            byte[] data = new byte[255];                // массив байтов под сериализованную запись (решение проблемы с размером)
            formatter.Serialize(memoryStream, person);
            memoryStream.Position = 0;
            data[0] = (byte)memoryStream.Length;        // в нулевую ячейку массива - количество байтов в сериализованной записи
            memoryStream.Read(data, 1, (int)memoryStream.Length); // в массив с первой ячейки все из сериализованной записи из памяти
            bw.Write(data);                             // запись массива байтов в конец файла
            fs.Close();
        }
        static void ChangeIndex(int number, IndexEntry entry)
        {
            var formatter = new BinaryFormatter();
            var memoryStream = new MemoryStream();
            var fs = new FileStream(indexPath, FileMode.Open, FileAccess.Write); // добавление записи в файл
            fs.Position = number * 255;
            BinaryWriter bw = new BinaryWriter(fs);
            byte[] data = new byte[255];                // массив байтов под сериализованную запись (решение проблемы с размером)
            formatter.Serialize(memoryStream, entry);
            memoryStream.Position = 0;
            data[0] = (byte)memoryStream.Length;        // в нулевую ячейку массива - количество байтов в сериализованной записи
            memoryStream.Read(data, 1, (int)memoryStream.Length); // в массив с первой ячейки все из сериализованной записи из памяти
            bw.Write(data);                             // запись массива байтов в конец файла
            fs.Close();
        }
        static Person EjectPerson(int i)                                        // извлечь указанную запись
        {
            var formatter = new BinaryFormatter();
            var fs = new FileStream(dbPath, FileMode.Open, FileAccess.Read);
            var memoryStream = new MemoryStream();
            fs.Position = i * 255;
            var data = new byte[255];                                       // объявить массив под сериализованную запись
            fs.Read(data, 0, 255);                                          // считать в массив всю запись
            memoryStream.Write(data, 1, data[0]);                           // значимые байты записи - в ОЗУ
            memoryStream.Position = 0;
            Person person = (Person)formatter.Deserialize(memoryStream);    // десериализовать запись из байтов записи
            fs.Close();
            return person;                                                  // вернуть запись
        }
        static IndexEntry EjectEntry(int i)                                     // извлечь указанную запись
        {
            var formatter = new BinaryFormatter();
            var fs = new FileStream(indexPath, FileMode.Open, FileAccess.Read);
            var memoryStream = new MemoryStream();
            fs.Position = i * 255;
            var data = new byte[255];                                       // объявить массив под сериализованную запись
            fs.Read(data, 0, 255);                                          // считать в массив всю запись
            memoryStream.Write(data, 1, data[0]);                           // значимые байты записи - в ОЗУ
            memoryStream.Position = 0;
            IndexEntry entry = (IndexEntry)formatter.Deserialize(memoryStream);    // десериализовать запись из байтов записи
            fs.Close();
            return entry;                                                  // вернуть запись
        }
        static IndexEntry[] FindEntriesWithRequestedKeys(string request)        // создает массив найденных по ключу-ФИО записей индексов либо возврящает нулевую ссылку
        {
            IndexEntry[] array = new IndexEntry[0];
            int position = PositionOfFirstAskedEntry(ArrayOfEntries(), request);
            IndexEntry entry;
            Person person = new Person();
            if (position != -1)
            {
                entry = EjectEntry(position);
                person = EjectPerson(entry.offset / 255);
            }

            if (position != -1 && person.active)
            {
                int currentEjectNumber = position;
                while (NextEntryOK(currentEjectNumber - 1, request))
                {
                    array = AddIndexEntryToArray(array, EjectEntry(currentEjectNumber++));
                }
                return array;
            }
            else
            {
                return null;
            }
        }
        static IndexEntry[] FindEntriesWithRequestedKeys(string request, ref int[] arInt)                // создает массив найденных по ключу-ФИО записей индексов либо возврящает нулевую ссылку
        {
            arInt = new int[0];
            IndexEntry[] array = new IndexEntry[0];
            int position = PositionOfFirstAskedEntry(ArrayOfEntries(), request);
            IndexEntry entry;
            Person person = new Person();
            if (position != -1)
            {
                entry = EjectEntry(position);

                person = EjectPerson(entry.offset / 255);
            }

            if (position != -1 && person.active)
            {
                int currentEjectNumber = position;
                while (NextEntryOK(currentEjectNumber - 1, request))
                {
                    array = AddIndexEntryToArray(array, EjectEntry(currentEjectNumber));
                    arInt = AddToIntArray(arInt, currentEjectNumber++);
                }
                return array;
            }
            else
            {
                return null;
            }
        }
        /*static Person[] FindPersonsWithRequestedKeys(string request) // создает массив найденных по ФИО записей БД либо возврящает нулевую ссылку
       {
           Person[] array = new Person[0];
           var entry = new IndexEntry();
           var person = new Person();
           int firstEntryOfRequestedKey = PositionOfFirstAskedEntry(ArrayOfEntries(), request);
           if (firstEntryOfRequestedKey != -1)
           {
               int currentEjectNumber = firstEntryOfRequestedKey;
               entry = EjectEntry(currentEjectNumber);
               int position = entry.offset;
               person = EjectPerson(position / 255);
               array = AddPersonToArray(array, person);
               while (NextEntryOK(currentEjectNumber, request))
               {
                   array = AddPersonToArray(array, EjectPerson(EjectEntry(++currentEjectNumber).offset / 255));
               }
               return array;
           }
           else
           {
               return null;
           }
       }*/
        static bool NextEntryOK(int entryNumber, string request)
        {
            bool flag = false;
            var formatter = new BinaryFormatter();
            var fs = new FileStream(indexPath, FileMode.Open, FileAccess.Read);
            flag = (entryNumber + 1 != fs.Length / 255) && (EjectEntry(entryNumber + 1).key == request) && (EjectPerson(EjectEntry(entryNumber + 1).offset / 255).active == true);
            fs.Close();
            return flag;
        }
        static IndexEntry[] MarkedDeleted()                                     // создает массив индексов удаленных записей
        {
            IndexEntry[] array = new IndexEntry[0];
            var entry = new IndexEntry();
            var person = new Person();
            var fs = new FileStream(indexPath, FileMode.Open, FileAccess.Read);
            int size = (int)fs.Length / 255;
            fs.Close();
            for (int i = 0; i < size; i++)
            {
                entry = EjectEntry(i);
                int number = entry.offset / 255;
                person = EjectPerson(number);
                if (!person.active)
                {
                    array = AddIndexEntryToArray(array, entry);
                }
            }
            if (array.Length != 0)
            {
                return array;
            }
            else
            {
                return null;
            }
        }
        static void ListAllRecords() // вывести все записи БД
        {
            Console.Clear();
            var formatter = new BinaryFormatter();
            var fs = new FileStream(dbPath, FileMode.Open, FileAccess.Read);
            bool unmarkedPersonExists = false;
            for (int i = 0; i < fs.Length / 255; i++)
            {
                unmarkedPersonExists = unmarkedPersonExists | EjectPerson(i).active;
            }
            if (unmarkedPersonExists)
            {
                Console.WriteLine("{0,-42} {1,5} {2,9}", "№  ФИО", "Год", "Разряд");
                var ifs = new FileStream(indexPath, FileMode.Open, FileAccess.Read);
                int counter = 0;
                for (int i = 0; i < ifs.Length / 255; i++)
                {
                    var memoryStream = new MemoryStream();
                    var data = new byte[255];                                               // объявить массив под сериализованную запись
                    ifs.Read(data, 0, 255);                                                 // считать в массив всю запись
                    memoryStream.Write(data, 1, data[0]);                                   // значимые байты записи - в ОЗУ
                    memoryStream.Position = 0;
                    IndexEntry entry = (IndexEntry)formatter.Deserialize(memoryStream);
                    memoryStream = new MemoryStream();
                    data = new byte[255];                                                   // объявить массив под сериализованную запись
                    fs.Position = entry.offset;
                    fs.Read(data, 0, 255);                                                  // считать в массив всю запись
                    memoryStream.Write(data, 1, data[0]);                                   // значимые байты записи - в ОЗУ
                    memoryStream.Position = 0;
                    Person person = (Person)formatter.Deserialize(memoryStream);
                    if (person.active)
                    {
                        Console.Write(++counter + ". ");
                        person.Show();
                    }
                }
                ifs.Close();
            }
            else
            {
                Console.WriteLine("База данных пуста.\n");
            }
            fs.Close();

            Console.WriteLine("\nНажмите любую клавишу.");
            Console.ReadKey();
            Console.Clear();
        }
        static int ListAllDeletedRecords()
        {
            int quantity = 0;
            Console.Clear();
            IndexEntry[] array = MarkedDeleted();
            if (array != null)
            {
                Console.WriteLine("Были удалены следующие записи:\n");
                Console.WriteLine("{0,-42} {1,5} {2,8}", "№  ФИО", "Год", "Разряд");
                for (int i = 0; i < array.Length; i++)
                {
                    Console.Write(i + 1 + ". ");
                    EjectPerson(array[i].offset / 255).Show();
                    quantity++;
                }

            }
            else
            {
                Console.WriteLine("Ни одной записи не было удалено либо записи были удалены безвозвратно.\n");
            }
            return quantity;
        }
        static int PositionOfFirstAskedEntry(IndexEntry[] array, string key)    // бинарный поиск первого вхождения записи с запрошенным полем в БД
        {
            int left = 0, right = array.Length - 1;
            int middle;
            do
            {
                middle = (left + right) / 2;
                if (array[middle].key.CompareTo(key) == -1)
                {
                    left = middle + 1;
                }
                else
                {
                    right = middle;
                }
            } while (left != right);
            if (array[left].key == key)
            {
                return left;
            }
            return (-1);
        }
        static void RearrangeIndexWith(int positionOfOld, IndexEntry newEntry)
        {

            IndexEntry[] oldArray;
            oldArray = ArrayOfEntries();
            IndexEntry[] newArray = new IndexEntry[oldArray.Length-1];
            int counter = 0;
            for (int i = 0; i < oldArray.Length; i++)
            {
                if (i != positionOfOld)
                {
                    newArray[counter] = oldArray[i];
                    counter++;
                }
            }
            UpdateIndex(newArray);
            AddToIndexes(newEntry);
        }
        public static void RedLn(string str)                                    // вывести переданную строку красным цветом
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(str);
            Console.ResetColor();
        }
        static void UpdateIndex(IndexEntry[] entryArray)                        // обновить файл индексов
        {
            string path = Path.Combine(Environment.CurrentDirectory, "index.dat");
            var fs = new FileStream(path, FileMode.Truncate, FileAccess.Write);
            fs.Close();
            for (int i = 0; i < entryArray.Length; i++)
            {
                //entryArray[i].Show();
                AddToEndOfFile(entryArray[i]); // тут можно перезаписать не весь, а только обновленную часть
            }
        }

        static void Main()
        {
            int act;
            int exit = 2;
            bool ok;
            int chosenPerson;
            int chosenEntry;
            do
            {
                IndexEntry entry;
                Person person;
                Console.WriteLine("1. Добавить участника");
                if (File.Exists(dbPath))
                {
                    Console.WriteLine("2. Вывести список всех участников");
                    Console.WriteLine("3. Найти участника по ФИО");
                    Console.WriteLine("4. Редактировать запись участника");
                    Console.WriteLine("5. Удалить запись участника");
                    Console.WriteLine("6. Показать недавно удаленных участников");
                    exit = 7;
                }
                Console.WriteLine(exit + ". Выход");
                act = AskForAction(exit);

                switch (act)
                {
                    case 1:
                        person = AskForNewPerson();                                         // запрос новой записи
                        //person = new Person(false, "Анна", 1995, 5);
                        Console.Clear();
                        var fs = new FileStream(dbPath, FileMode.OpenOrCreate, FileAccess.Read);
                        int offset = (int)fs.Length;                                        // offset - номер байта, начиная с которого в файле хранится запись
                        fs.Close();
                        byte[] ar1 = ArrayOfSerialized(person);                             // ar1 - массив с сер. person [255]
                        int length = ar1[0];                                                // length - длина сер. person
                        entry = new IndexEntry(person.name, length, offset);                // entry - запись индексов
                        AddToEndOfFile(person);
                        AddToIndexes(entry);
                        break;
                    case 2:
                        ListAllRecords();
                        break;
                    case 3:
                        Console.Clear();
                        Console.Write("Введите ФИО для поиска: ");
                        string request = Console.ReadLine();
                        var arrayOfFoundEntries = FindEntriesWithRequestedKeys(request);
                        if (arrayOfFoundEntries == null)
                        {
                            Console.Clear();
                            Console.WriteLine("По запросу \"{0}\" ни одной записи не найдено.", request);
                            Console.WriteLine("\nНажмите любую клавишу.");
                            Console.ReadKey();
                            Console.Clear();
                        }
                        else
                        {
                            Console.Clear();
                            Console.WriteLine("По запросу \"{0}\" найдены записи:\n", request);
                            Console.WriteLine("{0,-42} {1,5} {2,9}", "№  ФИО", "Год", "Разряд");
                            for (int i = 0; i < arrayOfFoundEntries.Length; i++)
                            {

                                Console.Write(i + 1 + ". ");
                                EjectPerson(arrayOfFoundEntries[i].offset / 255).Show();
                            }
                            Console.WriteLine("\nНажмите любую клавишу.");
                            Console.ReadKey();
                            Console.Clear();
                        }
                        break;
                    case 4:
                        Console.Clear();
                        Console.Write("Редактировать участника с ФИО: ");
                        string key1 = Console.ReadLine();
                        int[] arrayOfPositions = new int[0];
                        IndexEntry[] array1 = FindEntriesWithRequestedKeys(key1, ref arrayOfPositions);
                        if (array1 == null)
                        {
                            Console.Clear();
                            Console.WriteLine("По запросу \"{0}\" ни одной записи не найдено.", key1);
                            Console.WriteLine("\nНажмите любую клавишу.");
                            Console.ReadKey();
                            Console.Clear();
                        }
                        else
                        {
                            Console.Clear();
                            Console.WriteLine("По запросу \"{0}\" найдены записи:\n", key1);
                            Console.WriteLine("{0,-42} {1,5} {2,9}", "№  ФИО", "Год", "Разряд");
                            for (int i = 0; i < array1.Length; i++)
                            {

                                Console.Write(i + 1 + ". ");
                                //Console.Write(arrayOfPositions[i]);
                                EjectPerson(array1[i].offset / 255).Show();
                            }
                            do
                            {
                                Console.Write("\nРедактировать запись № ");
                                string buf = Console.ReadLine();
                                ok = int.TryParse(buf, out chosenPerson) && chosenPerson > 0 && chosenPerson <= array1.Length;
                                if (!ok)
                                {
                                    RedLn("Ошибка.");
                                    Console.WriteLine("Ожидалось число {0}-{1}.", 1, array1.Length);
                                }
                            } while (!ok);
                            chosenEntry = arrayOfPositions[chosenPerson - 1];                   // получаем положение удаляемой записи в индексах(порядковый номер в файле)
                            chosenPerson = array1[chosenPerson - 1].offset / 255;               // получаем номер удаляемой записи в БД (порядковый номер в файле)
                            //Console.WriteLine("Alert 616 - " + chosenEntry + chosenPerson);
                            int action=0;
                            Person personToEdit;
                            IndexEntry entryToEdit;
                            do
                            {
                                Console.Clear();
                                string newData;
                                personToEdit = EjectPerson(chosenPerson);
                                entryToEdit = EjectEntry(chosenEntry);
                                Console.WriteLine("1. Изменить ФИО ({0})\n2. Изменить год рождения ({1})\n3. Изменить разряд ({2})\n4. В меню\n", personToEdit.name, personToEdit.year, personToEdit.rank);
                                action = AskForAction(4);
                                switch (action)
                                {
                                    case 1:
                                        Console.Clear();
                                        Console.WriteLine("Старые данные: {0}",personToEdit.name);
                                        Console.Write("Новые данные: ");
                                        newData = Console.ReadLine();
                                        personToEdit.name = newData;
                                        entryToEdit.key = newData;
                                        ChangePerson(chosenPerson, personToEdit);
                                        RearrangeIndexWith(chosenEntry, entryToEdit);
                                        //ChangeIndex(chosenEntry, entryToEdit);
                                        Console.WriteLine("\nЗапись изменена. Нажмите любую клавишу.");
                                        Console.ReadKey();
                                        Console.Clear();
                                        break;
                                    case 2:
                                        int newYear;
                                        Console.Clear();
                                        Console.WriteLine("Старые данные: {0}",personToEdit.name);
                                        do
                                        {
                                            Console.Write("Новые данные: ");
                                            newData = Console.ReadLine();
                                            ok = int.TryParse(newData, out newYear) && newYear > 1900 && newYear < 2015;
                                            if (!ok)
                                            {
                                                RedLn("Ошибка.");
                                                Console.WriteLine("Убедитесь в правильности введенного года и повторите ввод.\n");
                                            }
                                        } while (!ok);
                                        personToEdit.year = newYear;
                                        ChangePerson(chosenPerson, personToEdit);
                                        Console.WriteLine("\nЗапись изменена. Нажмите любую клавишу.");
                                        Console.ReadKey();
                                        Console.Clear();
                                        break;
                                    case 3:

                                        Console.Clear();
                                        Console.WriteLine("Старые данные: {0}",personToEdit.name);
                                        do
                                        {
                                            Console.Write("Новые данные: ");
                                            newData = Console.ReadLine();
                                            ok = int.TryParse(newData, out newYear) && newYear >=0 && newYear < 10;
                                            if (!ok)
                                            {
                                                RedLn("Ошибка.");
                                                Console.WriteLine("Убедитесь в правильности введенного разряда и повторите ввод.\n");
                                            }
                                        } while (!ok);
                                        personToEdit.rank = newYear;
                                        ChangePerson(chosenPerson, personToEdit);
                                        Console.WriteLine("\nЗапись изменена. Нажмите любую клавишу.");
                                        Console.ReadKey();
                                        Console.Clear();
                                        break;
                                    case 4:
                                        break;
                                }

                            } while (action != 4);
                            Console.Clear();
                        }

                        break;
                    case 5:
                        Console.Clear();
                        Console.Write("Удалить участника с ФИО: ");
                        string key = Console.ReadLine();
                        var array = FindEntriesWithRequestedKeys(key);
                        if (array == null)
                        {
                            Console.Clear();
                            Console.WriteLine("По запросу \"{0}\" ни одной записи не найдено.", key);
                            Console.WriteLine("\nНажмите любую клавишу.");
                            Console.ReadKey();
                            Console.Clear();
                        }
                        else
                        {
                            Console.Clear();
                            Console.WriteLine("По запросу \"{0}\" найдены записи:\n", key);
                            Console.WriteLine("{0,-42} {1,5} {2,9}", "№  ФИО", "Год", "Разряд");
                            for (int i = 0; i < array.Length; i++)
                            {

                                Console.Write(i + 1 + ". ");
                                EjectPerson(array[i].offset / 255).Show();
                            }
                            do
                            {
                                Console.Write("\nУдалить запись № ");
                                string buf = Console.ReadLine();
                                ok = int.TryParse(buf, out chosenPerson) && chosenPerson > 0 && chosenPerson <= array.Length;
                                if (!ok)
                                {
                                    RedLn("Ошибка.");
                                    Console.WriteLine("Ожидалось число {0}-{1}.", 1, array.Length);
                                }
                            } while (!ok);
                            Console.Clear();
                            chosenPerson = array[chosenPerson - 1].offset / 255; // получаем номер подлежащей удалению (пометке об удалении) записи в БД
                            Person personToMark = EjectPerson(chosenPerson);
                            personToMark.active = false;
                            ChangePerson(chosenPerson, personToMark);
                            Console.WriteLine("\nЗапись удалена. Нажмите любую клавишу.");
                            Console.ReadKey();
                            Console.Clear();
                        }

                        break;

                    case 6:
                        int quantity = ListAllDeletedRecords();                 // вывод удаленных записей и возврат их количества в quantity
                        if (quantity > 0)
                        {
                            Console.WriteLine("\n1. Очистить корзину\n2. Восстановить записи\n3. В меню");
                            int case3act = AskForAction(3);
                            switch (case3act)
                            {
                                case 1:

                                    break;
                                case 2:
                                    IndexEntry[] arrayOfDeleted = MarkedDeleted();
                                    do
                                    {
                                        Console.Write("Восстановить запись № ");
                                        string buf = Console.ReadLine();
                                        ok = int.TryParse(buf, out chosenPerson) && chosenPerson > 0 && chosenPerson <= arrayOfDeleted.Length;
                                        if (!ok)
                                        {
                                            RedLn("Ошибка.");
                                            Console.WriteLine("Ожидалось число {0}-{1}.\n", 1, arrayOfDeleted.Length);
                                        }
                                    } while (!ok);
                                    int number = arrayOfDeleted[chosenPerson - 1].offset / 255;
                                    person = EjectPerson(number);
                                    person.active = true;
                                    ChangePerson(number, person);
                                    Console.Clear();
                                    Console.Write("\nЗапись восстановлена. Нажмите любую клавишу.");
                                    Console.ReadKey();
                                    Console.Clear();
                                    break;
                                case 3:
                                    Console.Clear();
                                    break;
                            }
                        }
                        else
                        {
                            Console.WriteLine("\nНажмите любую клавишу.");
                            Console.ReadKey();
                            Console.Clear();
                        }

                        break;
                }

            } while (act != exit);
        }
    }

}