【问题标题】：c# slow socket speedc# 套接字速度慢
【发布时间】：2011-11-30 04:44:35
【问题描述】：

我正在尝试编写一个客户端/服务器文件传输系统。目前它可以工作，并且我已经对其进行了分析，而且我似乎无法以每秒 2-4 兆字节的速度发送数据。我已经调整了我的代码，以便我可以以每秒数百兆字节的速度从磁盘读取数据，并且性能向导在我的磁盘读取和我的套接字写入之间没有显示超过 1-3，所以我的代码已设置（它似乎）以尽可能快的速度推出数据，只要 nic/cpu/motherboard 可以处理它。

我想问题是，为什么不是这样？

这是一些代码，以便您了解我在这里设置了什么。

套接字代码（尽可能精简）

namespace Skylabs.Net.Sockets
{
    public abstract class SwiftSocket
    {
        public TcpClient Sock { get; set; }

        public NetworkStream Stream { get; set; }

        public const int BufferSize = 1024;

        public byte[] Buffer = new byte[BufferSize];

        public bool Connected { get; private set; }

        private Thread _thread;

        private bool _kill = false;

        protected SwiftSocket()
        {
            Connected = false;
            Sock = null;
            _thread = new Thread(Run);
        }
        protected SwiftSocket(TcpClient client)
        {
            _Connect(client);
        }
        public bool Connect(string host, int port)
        {
            if (!Connected)
            {
                TcpClient c = new TcpClient();
                try
                {
                    c.Connect(host, port);
                    _Connect(c);
                    return true;
                }
                catch (SocketException e)
                {
                    return false;
                }
            }
            return false;
        }
        public void Close()
        {
            _kill = true;
        }
        private void _Connect(TcpClient c)
        {
            Connected = true;
            Sock = c;
            Stream = Sock.GetStream();
            _thread = new Thread(Run);
            _thread.Name = "SwiftSocketReader: " + c.Client.RemoteEndPoint.ToString();
            _thread.Start();
        }
        private void Run()
        {
            int Header = -1;
            int PCount = -1;
            List<byte[]> Parts = null;
            byte[] sizeBuff = new byte[8];
            while (!_kill)
            {
                try
                {
                    Header = Stream.ReadByte();
                    PCount = Stream.ReadByte();
                    if (PCount > 0)
                        Parts = new List<byte[]>(PCount);
                    for (int i = 0; i < PCount; i++)
                    {
                        int count = Stream.Read(sizeBuff, 0, 8);
                        while (count < 8)
                        {
                            sizeBuff[count - 1] = (byte)Stream.ReadByte();
                            count++;
                        }
                        long pieceSize = BitConverter.ToInt64(sizeBuff, 0);
                        byte[] part = new byte[pieceSize];
                        count = Stream.Read(part, 0, (int)pieceSize);
                        while (count < pieceSize)
                        {
                            part[count - 1] = (byte)Stream.ReadByte();
                        }
                        Parts.Add(part);
                    }
                    HandleMessage(Header, Parts);
                    Thread.Sleep(10);
                }
                catch (IOException)
                {
                    Connected = false;
                    if(System.Diagnostics.Debugger.IsAttached)System.Diagnostics.Debugger.Break();
                    break;                    
                }
                catch (SocketException)
                {
                    Connected = false;
                    if (System.Diagnostics.Debugger.IsAttached) System.Diagnostics.Debugger.Break();
                    break;
                }
            }
            HandleDisconnect();
        }
        public void WriteMessage(int header, List<byte[]> parts)
        {
            try
            {
                byte[] sizeBuffer = new byte[8];
                //Write header byte
                Stream.WriteByte((byte)header);
                if (parts == null)
                    Stream.WriteByte((byte)0);
                else
                {
                    Stream.WriteByte((byte)parts.Count);

                    foreach (byte[] p in parts)
                    {
                        sizeBuffer = BitConverter.GetBytes(p.LongLength);
                        //Write the length of the part being sent
                        Stream.Write(sizeBuffer, 0, 8);
                        Stream.Write(p, 0, p.Length);
                        //Sock.Client.Send(p, 0, p.Length, SocketFlags.None);
                    }
                }
            }
            catch (IOException)
            {
                if (System.Diagnostics.Debugger.IsAttached) System.Diagnostics.Debugger.Break();
                _kill = true;
            }
            catch (SocketException)
            {
                if (System.Diagnostics.Debugger.IsAttached) System.Diagnostics.Debugger.Break();
                _kill = true;
            }
        }
        protected void WriteMessage(int header)
        {
            WriteMessage(header,null);
        }
        public abstract void HandleMessage(int header, List<byte[]> parts);
        public abstract void HandleDisconnect();

    }
}

文件传输器代码（设置套接字、加载文件等的类）

namespace Skylabs.Breeze
{
    public class FileTransferer
    {
        public String Host { get; set; }
        public string FileName { get; set; }
        public string FilePath { get; set; }
        public string Hash { get; set; }
        public FileStream File { get; set; }
        public List<TransferClient> Clients { get; set; }
        public const int BufferSize = 1024;
        public int TotalPacketsSent = 0;
        public long FileSize{get; private set; }
        public long TotalBytesSent{get; set; }
        private int clientNum = 0;
        public int Progress
        {
            get
            {
                return (int)(((double)TotalBytesSent / (double)FileSize) * 100d);
            }
        }
        public event EventHandler OnComplete;
        public FileTransferer()
        {

        }
        public FileTransferer(string fileName, string host)
        {
            FilePath = fileName;
            FileInfo f = new FileInfo(fileName);
            FileName = f.Name;
            Host = host;
            TotalBytesSent = 0;
            try
            {
                File = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read, BufferSize, FileOptions.SequentialScan);
                File.Lock(0,File.Length);
            }
            catch (Exception e)
            {
                ErrorWindow er = new ErrorWindow(e);
                er.ShowDialog();
            }

        }
        public bool Grab_Next_Data_Chunk(ref byte[] buffer, out int size, out long pos)
        {
            lock (File)
            {
                pos = File.Position;
                size = 0;
                if (pos >= FileSize - 1)
                    return false;
                int count = File.Read(buffer, 0, (FileSize - pos) >= FileTransferer.BufferSize ? FileTransferer.BufferSize : (int)(FileSize - pos));
                //TotalBytesSent += count;
                size = count;
                TotalPacketsSent++;
                return true;
            }
        }
        public bool Start(int ConnectionCount)
        {
            Program.ServerTrace.TraceInformation("Creating Connections.");
            if (Create_Connections(ConnectionCount) == false)
            {
                return false;
            }
            File.Seek(0, SeekOrigin.Begin);
            FileSize = File.Length;
            Clients[0].Start(this,0);

            List<byte[]> parts = new List<byte[]>(1);
            parts.Add(BitConverter.GetBytes(FileSize));
            Clients[0].WriteMessage((int)Program.Message.CFileStart, parts);

            Program.ServerTrace.TraceInformation("Sent start packet");

            for (clientNum = 1; clientNum < ConnectionCount; clientNum++)
            {
                Clients[clientNum].Start(this, clientNum);
            }
            return true;

        }
        private bool Create_Connections(int count)
        {
            Clients = new List<TransferClient>();
            for (int i = 0; i < count; i++)
            {
                TransferClient tc = new TransferClient();
                if (tc.Connect(Host, 7678) == false)
                    return false;
                Clients.Add(tc);
            }
            return true;
        }
        public void AddClient()
        {
            TransferClient tc = new TransferClient();
            tc.Connect(Host, 7678);
            tc.Start(this, clientNum);
            clientNum++;
            Clients.Add(tc);
        }
        public void RemoveClient()
        {
            Clients.Last().Kill();
        }
        public void AdjustClientCount(int newCount)
        {
            int dif = newCount - Clients.Count;
            if (dif > 0)
            {
                for(int i=0;i<dif;i++)
                    AddClient();
            }
            else
            {
                for(int i=0;i<Math.Abs(dif);i++)
                    RemoveClient();
            }
        }
        public void ClientDone(TransferClient tc)
        {
            List<byte[]> parts = new List<byte[]>(1);
            parts.Add(ASCIIEncoding.ASCII.GetBytes(FileName));
            tc.WriteMessage((int)Program.Message.CPartDone,parts);

            tc.Close();
            Clients.Remove(tc);
            if (Clients.Count == 0)
            {
                Program.ServerTrace.TraceInformation("File '{0}' Transfered.\nTotal Packets Sent: {1}", FilePath,
                                                     TotalPacketsSent);
                File.Unlock(0,File.Length);
                File.Close();
                File.Dispose();
                if(OnComplete != null)
                    OnComplete.Invoke(this,null);
            }

        }

    }
    public class TransferClient : Skylabs.Net.Sockets.SwiftSocket,IEquatable<TransferClient>
    {
        public FileTransferer Parent;
        public int ID;
        private bool KeepRunning = true;
        public Thread Runner;
        public void Start(FileTransferer parent, int id)
        {
            this.Sock.Client.
            Parent = parent;
            ID = id;
            List<byte[]> p = new List<byte[]>(1);
            p.Add(Encoding.ASCII.GetBytes(Parent.FileName));
            WriteMessage((int)Program.Message.CHello, p);
        }
        public void Kill()
        {
            KeepRunning = false;
        }
        private void run()
        {
            while (KeepRunning)
            {
                List<Byte[]> p = new List<byte[]>(3);
                byte[] data = new byte[FileTransferer.BufferSize];
                int size = 0;
                long pos = 0;
                if (Parent.Grab_Next_Data_Chunk(ref data,out size,out pos))
                {
                    p.Add(data);
                    p.Add(BitConverter.GetBytes(size));
                    p.Add(BitConverter.GetBytes(pos));
                    WriteMessage((int)Program.Message.CData, p);
                    Parent.TotalBytesSent += size;
                }
                else
                {
                    break;
                }
                Thread.Sleep(10);
            }
            Parent.ClientDone(this);
        }
        public bool Equals(TransferClient other)
        {
            return this.ID == other.ID;
        }

        public override void HandleMessage(int header, List<byte[]> parts)
        {
            switch (header)
            {
                case (int)Program.Message.SStart:
                    {
                        Runner = new Thread(run);
                        Runner.Start();
                        break;
                    }
            }
        }

        public override void HandleDisconnect()
        {
            //throw new NotImplementedException();
        }
    }
}

我想强调的是，在 FileTransferer.Get_Next_Data_Chunk 中几乎没有延迟，它的读取速度非常快，每秒 100 兆字节。此外，我相信套接字的 WriteMessage 是流线型和快速的。

也许有一个设置或什么？还是不同的协议？

欢迎提出任何想法。

我忘了提一下，这个程序是专门为 LAN 环境构建的，它的最大速度为 1000Mbps（或字节，我不确定，如果有人能澄清这一点，那也很好。）

【问题讨论】：

嗯，有一个显而易见的问题：您的网络有多快？发布一些 iperf 结果，因为它们代表了您应该希望接近的上限。
您忘记删除Thread.Sleep(10); ？如果您只是想让其他线程有机会运行，请执行Thread.Sleep(0)。
我会重新考虑其中一些公共可变属性。
另外，如果你真的希望它尽可能快，请使用 UDP 而不是 TCP，但你必须确认接收到的数据确实是正确的。通常一个 MD5 或其他一些哈希是可以的。阅读 bittorrent 协议。
您也可以尝试在发送前将List<byte[]> 转换为单个byte[]，否则您最终可能会发送小数据包。

标签： c# performance sockets networking

【解决方案1】：

首先，您的网络速度将是每秒比特数，几乎不是每秒字节数。

其次，您可能会因为必须不断地使用 IO 阅读器打开和关闭文件而受到限制。除非您在 SSD 上运行，否则由于驱动器寻道时间，这将导致开销显着增加。

要解决这个问题，请尝试将缓冲区大小增加到更大的值，因为 1024 非常小。我通常使用 262144 (256K) 左右的缓冲区大小。

除此之外，您还需要像这样流水线化文件 IO：

ReadBlock1
loop while block length > 0
    TransmitBlock1 in separate thread
    ReadBlock2
    Join transmit thread
end loop

使用上述管道，您通常可以将传输速度提高一倍。

当您实现流水线文件 IO 时，您不再需要担心缓冲区大小过大的问题，除非您的文件总是大小为 < 2 * BufferSize，因为您说您正在处理超过 100mb 的文件，您不必担心这种情况。

您可以做的其他改进是使用 .

还要记住，在 .NET 文件中，尽管使用了线程，但 IO 通常是同步的。

编辑：如果您认为问题是网络而不是文件 IO，只需添加，然后只需将网络部分注释掉以使其显示为即时，那么您获得的速度是多少？反过来呢，如果你让你的文件读取总是返回一个空的new byte[BufferSize] 会怎样影响你的复制速度？

【讨论】：

另外，别忘了有3个瓶颈：1）阅读文件； 2）网络IO； 3) 写入文件。检查所有三个，看看哪个实际上导致了您的瓶颈，它可能不是您所期望的。
是的，它是同步的，这就是为什么我在它周围添加了一个锁，这样每个线程就不会移动文件指针并搞砸我的传输。我还消除了作为瓶颈的读取。
另外，传输一个块，读取，然后加入，然后重新传输听起来像是一个等待发生的瓶颈。这个想法是同时使用多个线程，因为读取速度远高于网络速度。
我曾经在 Get_Next_Data_Chunk 中增加发送的字节数，它会给我每秒超过 100MegaBytes 的数字。这意味着，在它发送之前它的读取速度很快，然后速度会下降，因为所有线程都命中 Stream.Write。
另外，我读取文件的方式是通过 Visual Studio 预执行测试运行它，并且 0.01%-.1% 的应用程序时间花费在该方法上。大约 1-3% 用于我的发送。我没有流量瓶颈，我选择的从文件和套接字中获取文件数据的方法几乎是最快的，我对此相当有信心。

【解决方案2】：

尝试分布式文件系统示例here，在networkComms.net，一个开源网络通信库。如果您为测试数据包输入较大的内容，例如 200mb，它应该会在传输过程中最大化您的连接。测试完成后，它将为您提供平均传输速率。如果这仍然只有每秒几 MB，那么您的连接可能有问题。

【讨论】：