c# - 如何取消TCP文件传输c#

Question

我有一个几乎可以传输文件的接收方和发送方客户端。这是我目前在接收器上的内容:

    Thread t1;
    int flag = 0;
    string receivedPath;
    public delegate void MyDelegate(string s);
    int bytesRead = 0;
    bool endReceive = false;
        public Form1()
        {
            t1 = new Thread(new ThreadStart(StartListening));
            t1.Start();
            InitializeComponent();
        }

        public class StateObject
        {
             // Client socket.
             public Socket workSocket = null;

             public const int BufferSize = 1024*100;

             // Receive buffer.
             public byte[] buffer = new byte[BufferSize];
        }

    public static ManualResetEvent allDone = new ManualResetEvent(false);

    public void StartListening()
    {
        byte[] bytes = new Byte[1024*1000];
        IPEndPoint ipEnd = new IPEndPoint(IPAddress.Any, 9050);
        Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        try
        {
            listener.Bind(ipEnd);
            listener.Listen(100);
            while (true)
            {
                allDone.Reset();
                listener.BeginAccept(new AsyncCallback(AcceptCallback), listener);
                allDone.WaitOne();

                if (endReceive)
                {
                    listener.Disconnect(true);
                }
            }
        }           
        catch (Exception ex)
        {

        }

   }
   public void AcceptCallback(IAsyncResult ar)
   {

        allDone.Set();
        Socket listener = (Socket)ar.AsyncState;
        Socket handler = listener.EndAccept(ar);
        StateObject state = new StateObject();
        state.workSocket = handler;
        handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
        new AsyncCallback(ReadCallback), state);            
        flag = 0;
   }

   public void ReadCallback(IAsyncResult ar)
    {
        int fileNameLen = 1;
        String content = String.Empty;
        StateObject state = (StateObject)ar.AsyncState;
        Socket handler = state.workSocket;

        try
        {
             bytesRead= handler.EndReceive(ar);

        }
        catch (SocketException x)
        {
            MessageBox.Show("File Transfer was cancelled");
            Invoke(new MyDelegate(LabelWriter), new object[] { "Waiting for connections" });
            if (File.Exists(receivedPath))
            {                    
                File.Delete(receivedPath);
                return;
            }
        }
        if (endReceive)
        {
            handler.Disconnect(true);
            if (File.Exists(receivedPath))
            {
                File.Delete(receivedPath);
            }
            return;
        }

        if (bytesRead > 0)
        {
            if (flag == 0)
            {                    
                fileNameLen = BitConverter.ToInt32(state.buffer, 0);
                string fileName = Encoding.UTF8.GetString(state.buffer, 4, fileNameLen);                     
                receivedPath = fileName;                    
                Invoke(new MyDelegate(LabelWriter), new object[] { "Receiving File: " + fileName });
                flag++;
            }
                if (flag >= 1)
                {

                    BinaryWriter writer = new BinaryWriter(File.Open(receivedPath, FileMode.Append));
                    if (flag == 1)
                    {
                        writer.Write(state.buffer, 4 + fileNameLen, bytesRead - (4 + fileNameLen));
                        flag++;
                        ReleaseMemory();
                    }
                    else
                        writer.Write(state.buffer, 0, bytesRead);
                        writer.Close();
                        try
                        {
                            handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                                                new AsyncCallback(ReadCallback), state);
                        }
                        catch (SocketException exc)
                        {
                            MessageBox.Show("File Transfer was cancelled");
                            Invoke(new MyDelegate(LabelWriter), new object[] { "Waiting for connections" });
                            if (File.Exists(receivedPath))
                            {                                    
                                File.Delete(receivedPath);
                                return;
                            }
                        }                                                  
                }
        }
        else            
           Invoke(new MyDelegate(LabelWriter), new object[] {"Data Received"});           
    }

我想要实现的是在传输发生时取消传输的能力。我想到的是将 bool 值“EndReceive”设置为 false，每次调用 ReadCallBack 方法时，都会检查 EndReceive。如果它是假的，我断开套接字。它可以停止接收文件，但是，发件人应用程序只是卡住。这基本上是我发送的方式:

 while (true)
        {
            int index = 0;
            while (index < fs.Length)
            {
                int bytesRead = fs.Read(fileData, index, fileData.Length - index);
                if (bytesRead == 0)
                {
                    break;
                }

                index += bytesRead;
            }
            if (index != 0)
            {
                try
                {
                    clientSock.Send(fileData, index, SocketFlags.None);
                }
                catch (Exception sexc)
                {
                    MessageBox.Show("Transfer Cancelled");
                    return;
                }
                ReleaseMemory();
                if ((progressBar1.Value + (1024 * 1000)) > fs.Length)
                {
                    progressBar1.Value += ((int)fs.Length - progressBar1.Value);
                }
                else
                    progressBar1.Value += (1024 * 1000);

                lblSent.Text = index.ToString();
            }

            if (index != fileData.Length)
            {
                ReleaseMemory();
                progressBar1.Value = 0;
                clientSock.Close();
                fs.Close();                   
                break;


            } 
        }

有什么想法吗？

Answer 1

我认为很难强制中断您正在执行的那种批量传输并仅使用 TCP 干净地关闭它。如果您采用 1024 的 block 大小，并且在每传输 kB 之后，从接收方向发送方发送一个快速确认或否定字节会怎么样？ Nack表示要中断传输，ack表示继续。

不幸的是，这需要接收方/发送方的全双工，并且要小心!尽管它是异步 IO，但如果您计划从同一个套接字读取和写入，则确实需要在不同的线程上调用 BeginReceive 和 BeginSend。