// Протокол отправки файла.
        public void Sending()
        {
            // Сообщение для коммуникации с клиентом.
            Message file_part = new FilePartMessage(string.Empty);
            // Сообщение для обработки подтверждения.
            Message response = new ResponseMessage("resp");
            // Уведомление о типе трансляции хаба.
            Inform_of_Down_Message down = new Inform_of_Down_Message(Path.GetFileName(flname));
            // Поток общения с хабом.
            NetworkStream Cur_Hub;
            Files.TryGetValue(flname, out Cur_Hub);

            NW.Send(down, Cur_Hub);

            using (NetworkStream stream = new NetworkStream(client))
            {
                NW.Send(response, Cur_Hub);
                do
                {
                    mes = NW.Recieve(Cur_Hub);
                    if (mes != null)
                    {
                        if (!(mes is EndMessage))
                        {
                            // Отправка сообщения клиенту.
                            NW.Send(mes, stream);

                            // Ожидание ответа.
                            do
                            {
                                response = NW.Recieve(stream);
                            }
                            while (response.Get_Data() == string.Empty);

                            // Отправка уведомления хабу.
                            NW.Send(response, Cur_Hub);
                        }
                        else
                        {
                            mes = new EndMessage("End of file.");
                            NW.Send(mes, stream);
                        }
                    }
                } while (!(mes is EndMessage));

                // Уведомление об окончании операции.
                Console.WriteLine("Downloading is complete!");
            }
        }
        // Отправка файла.
        public void Send_File(string s)
        {
            // Сообщение содержащее часть файла.
            Messages.Message mes;
            // Сообщение содержащее имя файла.
            RequestMessage name = new RequestMessage(s);
            // Сообщение содержащее подтверждение получения.
            Messages.Message resp;
            // Размер буффера считываемых данных.
            const int buffersz = 1022;
            // Буффер для частей файла.
            byte[] buffer = new byte[buffersz];
            // Размер считанных данных.
            int btscpd = 0;

            // Выделение пути к запрашиваемому файлу.
            string path = Path.Combine(cl_path, s);

            // Проверка существования файла.
            if (File.Exists(path))
            {
                // Выделение потоков для отправки файла.
                using (FileStream inFile = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read))
                using (NetworkStream stream = clnt.GetStream())
                {
                    // Отправка имени файла.
                    NW.Send(name, stream);

                    // Ожидание ответа.
                    do
                    {
                        resp = NW.Recieve(stream);
                    }
                    while (resp.Get_Data() == string.Empty);

                    do
                    {
                        // Считывание данных с файла.
                        btscpd = inFile.Read(buffer, 0, buffersz);
                        // Проверка на пустоту считанных данных.
                        if (btscpd > 0)
                        {
                            mes = new FilePartMessage(Encoding.ASCII.GetString(buffer));
                            // Отправка пакета.
                            NW.Send(mes, stream);

                            // Получение подтверждения.
                            while (true)
                            {
                                resp = NW.Recieve(stream);

                                if (resp.Get_Data() != "")
                                {
                                    resp = new ResponseMessage(string.Empty);
                                    break;
                                }
                            }
                        }
                    } while (btscpd > 0);

                    // Для устранения ошибки преждевременного обрывания.
                    Thread.Sleep(50);

                    // Отправка уведомления о конце файла.
                    mes = new EndMessage("End of file");
                    NW.Send(mes, stream);
                }

            }
            else
            {
                using (NetworkStream stream = clnt.GetStream())
                {
                    mes = new ErrorMessage("File is not exsiting");
                    NW.Send(mes, stream);
                }
            }
        }
 // Раскрыть пакет.
 public Message Decrypt(byte[] b)
 {
     // Возвращаемое значение.
     Message mes;
     // Строка, полученная из полученного массива байт.
     string str = Encoding.ASCII.GetString(b);
     // Тип сообщений.
     if (str[0] != '\0')
     {
         int type = int.Parse(str[0].ToString());
         int border = str.IndexOf('\0');
         if (border==(-1))
         {
             border = str.Length;
         }
         if (type != -1)
         {
             // Строка данных.
             string assis = str.Substring(1, border - 1);
             // Определение типа сообщения.
             switch (type)
             {
                 case 0:
                     mes = new Inform_of_Down_Message(assis);
                     break;
                 case 1:
                     mes = new Inform_of_Rec_Message(assis);
                     break;
                 case 2:
                     mes = new ListMessage(assis);
                     break;
                 case 3:
                     mes = new RequestMessage(assis);
                     break;
                 case 4:
                     mes = new FilePartMessage(assis);
                     break;
                 case 5:
                     mes = new EndMessage(assis);
                     break;
                 case 6:
                     mes = new ResponseMessage(assis);
                     break;
                 case 7:
                     mes = new ErrorMessage(assis);
                     break;
                 case 8:
                     mes = new HubInformMessage(assis);
                     break;
                 default:
                     mes = new Message(assis);
                     break;
             }
         }
         else
             mes = new Message(string.Empty);
         return mes;
     }
     else
         return new Message(string.Empty);
 }
        // Протокол получения файла.
        public void Receiving(string s)
        {
            // Обработанное входящее сообщение.
            Messages.Message mess = new FilePartMessage(string.Empty);
            // Сообщение содержащее имя.
            RequestMessage name;
            // Уведомительное сообщение.
            ResponseMessage response = new ResponseMessage("Response");
            // Буффер для получения ответа.
            byte[] pack = new byte[1024];

            // Выделение пути к файлу.
            string path = Path.Combine(cl_path, s);
            // Выделение потоков для получения файла.
            using (FileStream outFile = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.None))
            using (NetworkStream stream = clnt.GetStream())
            {
                name = new RequestMessage(s);
                // Отправка имени.
                NW.Send(name, stream);
                do
                {
                    // Получение части файла.
                    mess = NW.Recieve(stream);

                    // Проверка на завершение скачивания.
                    if (!(mess is EndMessage))
                    {
                        // Запись в файл.
                        outFile.Write(mess.Get_Info(), 0, mess.Get_Info().Length);
                        // Отправка уведомления.
                        NW.Send(response, stream);
                    }

                } while (!(mess is EndMessage));

                // Отчет об успешном скачивании.
                MessageBox.Show("Downloading is complete!", "Complete", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
        // Отправка файла.
        public void Send(object income)
        {
            stream = (NetworkStream)income;
            // Строка для хранения необработанного ответа.
            string assis = string.Empty;
            // Строка для хранения обработанного ответа.
            string decrypted = string.Empty;
            // Буффер для хранения полученного ответа.
            byte[] bytes = new byte[1024];
            // Объем буффера передаваемых данных.
            const int buffersz = 1022;
            // Буффер содержащий передаваемый пакет данных.
            byte[] buffer = new byte[buffersz];
            //Количество считанных байт.
            int btscpd = 0;
            // Строка для отправки уведомлений.
            byte[] message = new byte[1024];
            // Сообщение для коммуникации с клиентом.
            Message file_part = new FilePartMessage(string.Empty);
            // Сообщение для обработки подтверждения.
            Message response = new ResponseMessage(string.Empty);

            // Выделение пути к запрашиваемому файлу.
            string path = Path.Combine(@"D:\DFS", name);

            // Провека существования запрашиваемого файла.
            if (File.Exists(path))
            {
                // Начало передачи.
                using (FileStream inFile = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    // Ожидание ответа.
                    do
                    {
                        response = NW.Recieve(stream);
                    }
                    while (response.Get_Data() == string.Empty);

                    do
                    {

                        // Считывание данных из файла.
                        btscpd = inFile.Read(buffer, 0, buffersz);
                        file_part = new FilePartMessage(Encoding.ASCII.GetString(buffer));

                        // Проверка на наличие неотправленных данных.
                        if (btscpd > 0)
                        {
                            // Отправка пакета.
                            NW.Send(file_part, stream);

                            // Получение подтверждения.
                            while (true)
                            {
                                response = NW.Recieve(stream);

                                if (response.Get_Data() != string.Empty)
                                {
                                    response = new ResponseMessage(string.Empty);
                                    break;
                                }
                            }
                        }
                    } while (btscpd > 0);

                    // Отправка уведомления о конце файла.
                    file_part = new EndMessage("End of file");
                    NW.Send(file_part, stream);

                    // Уведомление о завершении процесса.
                    Console.WriteLine("Translation thread: File has been sent.");
                }
            }
        }