C # TCP асинхронная отправка нескольких файлов с сервера на клиент, нам нужно подтверждение?

Question

мой код используется для отправки нескольких файлов с сервера на клиент:

Сервер:

    public void SendFiles(string filePath)
    {
        try
        {
            Debug.WriteImportant("SendFiles() - " + filePath);
            byte[] fileBuff = File.ReadAllBytes(filePath);
            byte[] fileSize = BitConverter.GetBytes(fileBuff.Length);
            byte[] dir = Encoding.ASCII.GetBytes(Path.GetFileName(Path.GetDirectoryName(filePath)) + "\\" + Path.GetFileName(filePath));
            byte[] fileHeader = new byte[fileSize.Length + dir.Length];

            fileSize.CopyTo(fileHeader, 0);
            dir.CopyTo(fileHeader, fileSize.Length);

            Send(fileHeader);
            Send(fileBuff);
        }
        catch (Exception e)
        {
            Debug.WriteImportant(e.ToString());
        }
    }

    public void Send(byte[] byteData)
    {
        try
        {
            // Begin sending the data to the remote device.
            pMySocket.BeginSend(byteData, 0, byteData.Length, 0,
            new AsyncCallback(SendCallback), pMySocket);
        }
        catch (Exception e)
        {
            Debug.WriteImportant(e.ToString());
        }
    }

    private void SendCallback(IAsyncResult ar)
    {
        try
        {
            // Retrieve the socket from the state object.
            Socket client = (Socket)ar.AsyncState;

            // Complete sending the data to the remote device.
            int bytesSent = client.EndSend(ar);
            Debug.WriteImportant("Sent" + bytesSent + "bytes to client @." + strConstID);

            pMySocket.BeginReceive(byRxBuffer, 0, byRxBuffer.Length, 0, ReceiveCallback, pMySocket);
        }
        catch (Exception e)
        {
            Debug.WriteImportant(e.ToString());
        }
    }

Клиент:

        private static void Receive(Socket client)
    {
        try
        {
            StateObject state = new StateObject();
            state.workSocket = client;

            client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                new AsyncCallback(ReceiveHeaderCallback), state);
        }
        catch (Exception e)
        {
            Debug.WriteLine(e.ToString());
        }
    }

    public static void ReceiveHeaderCallback(IAsyncResult ar)
    {
        try
        {
            Debug.WriteLine("## Begin ReceiveHeaderCallback");
            String content = String.Empty;
            StateObject state = (StateObject)ar.AsyncState;
            Socket handler = state.workSocket;

            int bytesRead = handler.EndReceive(ar);

            state.fileSize = BitConverter.ToInt32(state.buffer, 0);
            byte[] bFileName = new byte[state.buffer.Length - 4];
            Array.Copy(state.buffer, 4, bFileName, 0, bFileName.Length);
            _Buff = new byte[state.fileSize];
            fileName = Encoding.UTF8.GetString(bFileName).TrimEnd('\0'); 
            _totBytesRead = 0;
            Debug.WriteLine("## File size = " + state.fileSize);
            Debug.WriteLine("## File name = " + fileName);

            Array.Clear(state.buffer, 0, state.buffer.Length);
            handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
               new AsyncCallback(ReceiveCallback), state);
        }
        catch (Exception e)
        {
            Debug.WriteLine(e.ToString());
        }
    }

    private static void ReceiveCallback(IAsyncResult ar)
    {
        try
        {
            String content = String.Empty;
            StateObject state = (StateObject)ar.AsyncState;
            Socket client = state.workSocket;

            int bytesRead = client.EndReceive(ar);

            if (bytesRead > 0)
            {
                // There  might be more data, so store the data received so far.
                Buffer.BlockCopy(state.buffer, 0, _Buff, _totBytesRead, bytesRead);

                _totBytesRead += bytesRead;

                if (_totBytesRead < state.fileSize)
                {
                    // Not all data received. Get more.
                    client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                    new AsyncCallback(ReceiveCallback), state);
                }
                else
                {                            File.WriteAllBytes(AppDomain.CurrentDomain.BaseDirectory + fileName, _Buff);
                    Debug.WriteLine("## File receiving complete. File created = " + fileName);

                    Array.Clear(state.buffer, 0, state.buffer.Length);
                    client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveHeaderCallback), state);
                }
            }
        }
        catch (Exception e)
        {
            Debug.WriteLine(e.ToString());
        }
    }

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

Могу ли я спросить, нужно ли клиенту сделать какое-то подтверждение, сообщающее серверу, что он завершил получение файла, и вы можете отправить другой файл?

Или мы можем каким-то образом очистить или закрыть поток отправки после отправки файла и снова открыть его при отправке другого файла?

Что необходимо добавить в мою кодировку?