缓慢的下载超过插座

Question

我已经写在C＃中，从客户端发送文件到服务器，反之亦然TCP之上的专有协议（客户端和服务器）。

因为它是在概念全双工，接收和发送的方法适用于客户端和服务器一样。

该协议允许client1将文件上载到server，一旦文件被缓冲（在服务器上），client1可以决定client2和/或client3是否获得该文件。 （该server可以通过client1唯一发送到client2，只client3，或两者同时根据请求）。

的问题是，我见证服务器慢的数据传输 - >客户端，约140 KB时的实际带宽为在客户端要高得多，并且显然对服务器以及/秒。

起初我还以为它只是为这个特定的连接（在我的家，服务器在远程地点的客户端）的最大带宽，但后来我看到传输速率双打，当我打开client2和client3我PC并让服务器同时发送它们两个文件;它对每个客户端都是一样的，但由于它们都在同一台PC上，所以本地网络的总吞吐​​量翻了一番。

1. 在哪里我的问题能有什么想法？如何将服务器 - >客户端传输速率提高到最大？
2. 关于我的代码任何改善的基本点，将不胜感激。

这里是我的代码：

struct ReceiveBuffer 
{ 
    public const int BUFFER_SIZE = 1024 * 16; 
    public byte[] BUFFER; 
    public int ToReceive; 
    public MemoryStream BufStream; 

    public ReceiveBuffer(int toRec) 
    { 
     BUFFER = new byte[BUFFER_SIZE]; 
     ToReceive = toRec; 
     BufStream = new MemoryStream(toRec); 
    } 
} 

struct SendBuffer 
{ 
    public const int BUFFER_SIZE = 1024 * 16; 
    public byte[] BUFFER; 
    public int sent; 

    public SendBuffer(byte[] data) 
    { 
     BUFFER = new byte[data.Length]; 
     Buffer.BlockCopy(data, 0, BUFFER, 0, data.Length); 
     sent = 0; 
    } 
} 

public void ReceiveAsync() 
{ 
    try 
    { 
     socket.BeginReceive(lenBuffer, 0, 4, SocketFlags.None, 
          receiveCallback, null);     
    } 
    catch (SocketException se) 
    { 
     //handle disconnection 
    } 

} 

void receiveCallback(IAsyncResult ar) 
{ 
    try 
    { 
     int rec = socket.EndReceive(ar); 
     if (rec == 0) 
     { 
      if (Disconnected != null) 
      { 
       Disconnected(this); 
       return; 
      } 
     } 

     if (rec != 4) 
     { 
      //less than 4 bytes received...error 
      return; 
     } 

     receiveBuffer = new ReceiveBuffer(BitConverter.ToInt32(lenBuffer, 0)); 
     socket.BeginReceive(receiveBuffer.BUFFER, 0, 
          receiveBuffer.BUFFER.Length, 
          SocketFlags.None, receivePacketCallback, null); 
    } 
    catch (SocketException se) 
    { 
     //raise disconnection event 
    } 
} 

void receivePacketCallback(IAsyncResult ar) 
{ 
    try 
    { 
     int rec = socket.EndReceive(ar); 
     if (rec <= 0) 
     { 
      return; 
     } 
     receiveBuffer.BufStream.Write(receiveBuffer.BUFFER, 0, rec); 
     receiveBuffer.ToReceive -= rec; 
     if (receiveBuffer.ToReceive > 0) 
     { 
      Array.Clear(receiveBuffer.BUFFER, 0, receiveBuffer.BUFFER.Length); 
      socket.BeginReceive(receiveBuffer.BUFFER, 0, 
           receiveBuffer.BUFFER.Length, 
           SocketFlags.None, receivePacketCallback, null); 
      return; 
     } 

     if (DataReceived != null) 
     { 
      //raise dataReceived event 
     } 
     receiveBuffer.Dispose(); 
     if (socket !=null) 
      ReceiveAsync(); 

    } 
    catch (SocketException se) 
    { 
     //handle disconnection 
    } 

} 

// Send Async 
public void SendAsyncString(string str, CommandsToClient cmd) 
{ 
    BinaryWriter bw = new BinaryWriter(new MemoryStream()); 
    bw.Write((int)cmd); 
    bw.Write((int)str.Length); 
    bw.Write(Encoding.ASCII.GetBytes(str)); 
    bw.Close(); 
    byte[] data = ((MemoryStream)(bw.BaseStream)).ToArray(); 
    bw.BaseStream.Dispose(); 
    SendAsync(data); 
} 

public void SendAsync(byte[] data) 
{ 
    int toSend; 
    byte[] dataWithHeader = Combine(BitConverter.GetBytes(data.Length), data); 
    sendBuffer = new SendBuffer(dataWithHeader); 
    if (sendBuffer.BUFFER.Length - sendBuffer.sent > SendBuffer.BUFFER_SIZE) 
     toSend = SendBuffer.BUFFER_SIZE; 
    else 
     toSend = sendBuffer.BUFFER.Length - sendBuffer.sent; 
    socket.BeginSend(sendBuffer.BUFFER, 0,toSend, SocketFlags.None, 
        sendCallback, null); 
} 

void sendCallback(IAsyncResult ar) 
{ 
    try 
    { 
     int bytesSent = socket.EndSend(ar); 
     if (bytesSent == 0) 
     { 
      //raise disconnection event 
     } 
     sendBuffer.sent += bytesSent; 
     if (sendBuffer.sent==sendBuffer.BUFFER.Length) 
     { 
      sendBuffer.Dispose(); 
      return; 
     } 
     int toSend; 
     if (sendBuffer.BUFFER.Length - sendBuffer.sent > SendBuffer.BUFFER_SIZE) 
      toSend = SendBuffer.BUFFER_SIZE; 
     else 
      toSend = sendBuffer.BUFFER.Length - sendBuffer.sent; 

     socket.BeginSend(sendBuffer.BUFFER, sendBuffer.sent,toSend, 
         SocketFlags.None, sendCallback, null); 
    } 
    catch (SocketException se) 
    { 
     //hande disconnection 
    } 
} 

Answer 1

似乎有什么正在放缓我失望是缓冲区的大小。

在我的电脑： 我可以上传@约50千字节/秒
我可以下载@约600千字节/秒 （这些值明显变化，这取决于在远程主机上，但是它确实给一个很好的估计）

在服务器上： 上传和下载更高的带宽

这里（兆字节的十位）现在我用这让我高传输速率的设置：

在客户端（我PC）

Receive Buffer = 128 Kbytes 
Send Buffer = 32 Kbytes 

在服务器端：

Receive Buffer = 64 Kbytes 
Send Buffer = 256 Kbytes