Sockets 套接字低传输速度-Win7.Net4-CentOSx64 Mono 2.10

我创建了一个简单的客户机/服务器应用程序，当我在本地或局域网下运行时，它工作得非常好（1MB/s，这是我为服务器设置的最大发送速度）。但是当我尝试在我的专用服务器/VPS中运行它时，我的下载速度变慢了。 我在服务器上使用CentOS，运行它的是Mono，Mono版本是2.10.2，CentOS是64位版本。使用框架4创建

速度测试：

本地：1MB

局域网：1MB

在CentOS上运行服务器：0~10~20 KB

我的连接速度是2Mb或~250KB。有时它会让我全速前进。但非常罕见，我不明白为什么它有时会让我全速，有时根本没有速度，或者为什么有时只有10KB，有时只有20KB。此外，我正在Win7桌面上运行客户端。以下是服务器和客户端部分的代码：

服务器：

class Program
{
    private static BackgroundWorker _ListeningWorker;
    private static BackgroundWorker _QWorker;
    private static System.Net.Sockets.Socket _Server;
    private static List<System.Net.Sockets.Socket> ConnectedClients = new List<System.Net.Sockets.Socket>();
    static void Main(string[] args)
    {
        Program._ListeningWorker = new BackgroundWorker();
        Program._ListeningWorker.WorkerSupportsCancellation = true;
        Program._ListeningWorker.DoWork += _ListeningWorker_DoWork;
        Program._QWorker = new BackgroundWorker();
        Program._QWorker.WorkerSupportsCancellation = true;
        Program._QWorker.DoWork += _QWorker_DoWork;
        Program.Start();
        while (true)
        {
            Console.Clear();
            Console.WriteLine("1.0.0.1");
            Console.WriteLine(Program.ConnectedClients.Count.ToString());
            System.Threading.Thread.Sleep(1000);
        }
    }
    public static bool Start()
    {
        if (!Program._ListeningWorker.IsBusy)
        {
            Program._Server = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPEndPoint ipLocal = new IPEndPoint(IPAddress.Any, 8081);
            Program._Server.Bind(ipLocal);
            Program._Server.Listen(10);

            Program._ListeningWorker.RunWorkerAsync();
            Program._QWorker.RunWorkerAsync();
        }

        return true;
    }
    private static void _ListeningWorker_DoWork(object sender, DoWorkEventArgs e)
    {
        while (!Program._ListeningWorker.CancellationPending)
        {
            if (Program._Server.Poll(10, SelectMode.SelectRead))
            {
                lock (ConnectedClients)
                {
                    Program.ConnectedClients.Add(Program._Server.Accept());
                }
            }
            System.Threading.Thread.Sleep(1);
        }
        Program._Server.Close();
    }
    private static void _QWorker_DoWork(object sender, DoWorkEventArgs e)
    {
        byte[] array = new byte[1024];
        Random random = new Random();
        while (!Program._QWorker.CancellationPending)
        {
            if (ConnectedClients.Count > 0)
            {
                System.Net.Sockets.Socket[] st;
                lock (ConnectedClients)
                {
                    st = new System.Net.Sockets.Socket[Program.ConnectedClients.Count];
                    ConnectedClients.CopyTo(st);
                }

                foreach (System.Net.Sockets.Socket ser in st)
                {

                    random.NextBytes(array);
                    try
                    {
                        ser.BeginSend(array, 0, array.Length, SocketFlags.None, (AsyncCallback)delegate(IAsyncResult ar)
                        {
                            try
                            {
                                ser.EndSend(ar);
                            }
                            catch (Exception)
                            {
                                iDissconnected(ser);
                            }
                        }, null);
                    }
                    catch (Exception)
                    {
                        iDissconnected(ser);
                    }
                }
            }
            System.Threading.Thread.Sleep(1);
        }
        Program._Server.Close();
    }
    internal static void iDissconnected(System.Net.Sockets.Socket client)
    {
        lock (ConnectedClients)
            for (int i = 0; i < ConnectedClients.Count; i++)
                if (ConnectedClients[i].Equals(client))
                {
                    ConnectedClients.RemoveAt(i);
                    i--;
                }
    }
}

类程序
{
私有静态后台工作人员_listingworker；
私人静态后台工作人员；
专用静态System.Net.Sockets.Socket\u服务器；
private static List ConnectedClients=new List（）；
静态void Main（字符串[]参数）
{
程序。_listengWorker=新的BackgroundWorker（）；
程序。_listingworker.WorkerSupportsCancellation=true；
程序._listingworker.DoWork+=\u listingworker\u DoWork；
程序。QWorker=newbackgroundworker（）；
程序.QWorker.workerSupportsScanCellation=true；
程序._QWorker.DoWork+=\u QWorker\u DoWork；
Program.Start（）；
while（true）
{
Console.Clear（）；
Console.WriteLine（“1.0.0.1”）；
Console.WriteLine（Program.ConnectedClients.Count.ToString（））；
系统线程线程睡眠（1000）；
}
}
公共静态boolstart（）
{
如果（！Program.\u listingworker.IsBusy）
{
Program._Server=new System.Net.Sockets.Socket（AddressFamily.InterNetwork，SocketType.Stream，ProtocolType.Tcp）；
IPEndPoint ipLocal=新的IPEndPoint（IPAddress.Any，8081）；
程序_Server.Bind（ipLocal）；
程序。_服务器。侦听（10）；
程序。_listingworker.RunWorkerAsync（）；
程序.QWorker.RunWorkerAsync（）；
}
返回true；
}
私有静态void _listingworker _DoWork（对象发送方，DoWorkEventArgs e）
{
而（！Program.\u ListingWorker.CancellationPending）
{
if（程序\服务器轮询（10，选择模式。选择读取））
{
锁定（已连接客户端）
{
Program.ConnectedClients.Add（Program._Server.Accept（））；
}
}
系统线程线程睡眠（1）；
}
程序。_Server.Close（）；
}
私有静态void\u QWorker\u DoWork（对象发送方，DoWorkEventArgs e）
{
字节[]数组=新字节[1024]；
随机=新随机（）；
while（！Program.\u QWorker.CancellationPending）
{
如果（ConnectedClients.Count>0）
{
System.Net.Sockets.Socket[]st；
锁定（已连接客户端）
{
st=新系统.Net.Sockets.Socket[Program.ConnectedClients.Count]；
已连接的客户端。复制到（st）；
}
foreach（st中的System.Net.Sockets.Socket ser）
{
随机。下一个字节（数组）；
尝试
{
ser.BeginSend（数组，0，数组.Length，SocketFlags.None，（异步回调）委托（IAsyncResult ar）
{
尝试
{
服务端发送（ar）；
}
捕获（例外）
{
IDisconnected（ser）；
}
}，空）；
}
捕获（例外）
{
IDisconnected（ser）；
}
}
}
系统线程线程睡眠（1）；
}
程序。_Server.Close（）；
}
内部静态无效IDisconnected（System.Net.Sockets.Socket客户端）
{
锁定（已连接客户端）
对于（int i=0；i

客户：

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Enter IP Address: ");
        string Address = Console.ReadLine();
        Console.WriteLine();
        ushort Port = 8081;
        System.Net.Sockets.Socket Client;
        Client = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        Client.Connect(Address, (int)Port);
        Console.WriteLine("Connected");
        int p = 0;
        int t = Environment.TickCount;
        while (true)
        {
            if (Client.Available > 0)
            {
                byte[] z = new byte[1024];
                int r = Client.Receive(z); ;
                p += r;
            }
            else
            {
                System.Threading.Thread.Sleep(10);
            }
            if (Environment.TickCount - t >= 1000)
            {
                t = Environment.TickCount;
                Console.WriteLine(Program.FormatFileSizeAsString(p) + " Readed,");
                p = 0;
            }
        }
    }
    public static string FormatFileSizeAsString(int len)
    {
        if (len < 750 && len > 0)
            return "0.0 B ~";
        string[] Suffix = { "B", "KB", "MB", "GB", "TB" };
        int i;
        double dblSByte = len;
        for (i = 0; (int)(len / 1024) > 0; i++, len /= 1024)
            dblSByte = len / 1024.0;
        return String.Format("{0:0.0} {1}", dblSByte, Suffix[i]);
    }
}

类程序
{
静态void Main（字符串[]参数）
{
Console.WriteLine（“输入IP地址：”）；
字符串地址=Console.ReadLine（）；
Console.WriteLine（）；
ushort端口=8081；
System.Net.Sockets.Socket客户端；
Client=new System.Net.Sockets.Socket（AddressFamily.InterNetwork，SocketType.Stream，ProtocolType.Tcp）；
Client.Connect（地址，（int）端口）；
控制台。写入线（“连接”）；
int p=0；
int t=Environment.TickCount；
while（true）
{
如果（Client.Available>0）
{
字节[]z=新字节[1024]；
int r=客户端接收（z）；
p+=r；
}
其他的
{
系统线程线程睡眠（10）；
}
如果（Environment.TickCount-t>=1000）
{
t=Environment.TickCount；
Console.WriteLine（Program.FormatFileSizeAsString（p）+“Readed”）；
p=0；
}
}
}
公共静态字符串格式filesizeasstring（int len）
{
如果（len<750&&len>0）
返回“0.0b~”；
字符串[]后缀={“B”、“KB”、“MB”、“GB”、“TB”}；
int i；
双dblSByte=len；
对于（i=0；（int）（len/1024）>0；i++，len/=1024）
dbl