我有一个接收器和发送器客户端几乎传输文件.这是我到目前为止接收器上的内容：

    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"});           
    }

我想要实现的是能够在传输过程中取消传输.我想到的是将布尔“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;


            } 
        }

有什么想法吗？

最佳答案 我认为很难为你正在进行的那种批量传输强制执行中断,并且只需使用TCP即可完全关闭.如果您将块大小设置为1024,并且在每次转换大小写之后,从接收方向发送方发送快速ack或nack字节,该怎么办？表示转移的Nack将被中断,ack表示继续.

不幸的是,这需要接收器/发送器的全双工,并且要小心！即使它是异步IO,如果您计划并从同一个套接字读取和写入,也需要在不同的线程上调用BeginReceive和BeginSend.