每台服务器的连接数？C#，网络

我正在连接到第三方服务器。我知道现在他们允许来自同一个远程用户的8个连接。但是我不知道他们是否会提高或降低连接限制。因此，我希望我的应用程序能够动态地找到答案。我该怎么做

我用的是C#，MSVS2008 我开始悬赏任何能给我工作机会的人。如果没有人这么做，我会给出最好的答案

---

我发现这很难做到，并且有几次尝试都失败了：（

这不是服务器默认向客户端提供的信息。唯一知道的方法是一直打开连接，直到连接失败为止（坏主意），或者让服务器所有者提供一个您可以轮询的服务，返回此信息

编辑：在进一步思考这个问题后，我不确定是否可以通过“探测”以任何真实的准确度来确定。如果服务器在达到连接限制时返回

503服务器忙

（我在提出最初建议时假设会发生这种情况），这将更容易测试。但通常，当服务器超过其连接限制时，它们只是在新连接可用之前不响应。客户端只是等待响应。没有什么困难的方法来区分由于已达到连接限制而需要10秒响应的服务器和需要10秒响应的服务器10秒以响应任何其他原因

此外，即使您仍试图以这种方式对其进行测试，您向服务器发出的请求也需要保持足够长的打开时间，以确保您创建的第一个连接（以及所有后续连接）能够正常运行当第n个请求超时时仍处于打开状态。这意味着调用需要花费任意长时间才能返回的服务—长时间运行的进程或线程.Sleep（）；或者下载一个不方便的大文件。这两种方法都是极为低效的。

此处有一些伪代码：

connection = MakeNewConnection("ServerAddress");
while (connection.connected)
{
connectionCounter++;
connection = MakeNewConnection("ServerAddress");
}

最后，你的connectionCounter应该包含你能建立的全部连接。如果你愿意，我可以看看这需要什么样的C代码

---

另外，这对服务器不是一件很好的事情，它可能会在一天内让你被禁止：p.

如果你连接的服务器是一个Windows box并且正在运行WMI，你只需找出此信息存储在哪个注册表项中，然后在那里获取信息。也就是说，如果你连接的用户具有WMI权限幻觉

int counter = 0;
while(true) {

     try{
            Open New Connection
            counter++;

        }
        catch()
        {
           Trace.WriteLine(counter);
        }
}

---

必须喜欢使用异常来控制流；）

穷人的做法是向netstat发送shell，获取标准输出并检查它。它为您提供与其他计算机的当前连接的快照。从中可以确定连接到特定服务器的次数

-不要

我不能评论：）但答案是可靠的。根据您需要监控服务的时间长短，您可以安排netstat以管道形式输出到一个文件，并在时间段结束时查看数据

要清理输出数据以查看所需内容，可能需要结合使用logparser和或excel

netstat的好处在于，您可以消除“喋喋不休”，只需查看连接到感兴趣的进程的连接（通过pid）

---

否则，您可以通过tcpv4（或v6）perfmon计数器使用tcp监视到服务器的连接数。此连接将包括到服务器的所有连接，但您可能能够大致了解您要查找的内容。

在您的情况下，更好的方法可能是不真正关心。我会尝试逐个打开连接并检查应用程序的性能。只要通过打开另一个连接来提高性能，就可以继续打开新的连接。当性能停止增加时，您的连接数已接近最佳连接数。

我将接受这笔奖金，好先生。不太清楚你为什么要这样做，为什么有人允许8个连接

1999年定义（RFC 2616）“客户 使用持久连接的 限制同时发生的事件的数量 它们维护的与服务器的连接 给定服务器。单用户客户端 不应保持超过2个 与任何服务器或代理的连接。 代理最多应使用2*N 与另一台服务器或服务器的连接 proxy，其中N是 同时活跃的用户 指导方针旨在改进 HTTP响应时间和避免 因为开发商 使用AJAX或类似AJAX的请求 更新网页http限制为 讨论越来越多

正如RFC所说，我只能获得两个到web服务器的开放连接

但代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Threading;

namespace ConnectionTest
{
    public class RequestCounter
    {
        public int Counter = 0;
        public void Increment()
        {
            Interlocked.Increment(ref Counter);
        }
    }

    public class RequestThread
    {
        public AutoResetEvent AsyncWaitHandle { get; private set; }
        public RequestCounter RequestCounter;
        public String Url;
        public HttpWebRequest Request;
        public HttpWebResponse Response;

        public RequestThread(AutoResetEvent r, String u, RequestCounter rc)
        {
            Url = u;
            AsyncWaitHandle = r;
            RequestCounter = rc;
        }

        public void Close()
        {
            if (Response != null)
                Response.Close();

            if (Request != null)
                Request.Abort();
        }
    }

    public class ConnectionTest
    {
        static void Main()
        {
            string url = "http://www.google.com/";
            int max = GetMaxConnections(25, url);
            Console.WriteLine(String.Format("{0} Max Connections to {1}",max,url));
            Console.ReadLine();
        }

        private static int GetMaxConnections(int maxThreads, string url)
        {
            RequestCounter requestCounter = new RequestCounter();

            List<RequestThread> threadState = new List<RequestThread>();
            for (int i = 0; i < maxThreads; i++)
                threadState.Add(new RequestThread(new AutoResetEvent(false), url, requestCounter));

            List<Thread> threads = new List<Thread>();
            foreach (RequestThread state in threadState)
            {
                Thread t = new Thread(StartRequest);
                t.Start(state);
                threads.Add(t);
            }

            WaitHandle[] handles = (from state in threadState select state.AsyncWaitHandle).ToArray();
            WaitHandle.WaitAll(handles, 5000); // waits seconds

            foreach (Thread t in threads)
                t.Abort();

            foreach(RequestThread rs in threadState)
                rs.Close();

            return requestCounter.Counter;
        }

        public static void StartRequest(object rt)
        {
            RequestThread state = (RequestThread) rt;
            try
            {
                state.Request = (HttpWebRequest)WebRequest.Create(state.Url);
                state.Request.ReadWriteTimeout = 4000; //Waits 4 seconds

                state.Response = (HttpWebResponse)state.Request.GetResponse();
                if (state.Response.StatusDescription.Equals("OK", StringComparison.InvariantCultureIgnoreCase))
                    state.RequestCounter.Increment();

                //Do not close, or you will free a connection. Close Later
                //response.Close(); 
            }
            catch (WebException e)
            {
                //Console.WriteLine("Message:{0}", e.Message);
                state.Close();
            }
            catch (ThreadAbortException e)
            {
                //Console.WriteLine("Thread Aborted");
                state.Close();
            }
            catch(Exception e)
            {
                //Console.WriteLine("Real Exception");    
                state.Close();
            }
            finally
            {
                state.AsyncWaitHandle.Set();
            }
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
Net系统；
使用系统线程；
名称空间连接测试
{
公共类请求计数器
{
公共整数计数器=0；
公共空间增量（）
{
联锁增量（参考计数器）；
}
}
公共类请求线程
{
公共自动resetEvent AsyncWaitHandle{get；private set；}
公共请求计数器请求计数器；
公共字符串Url；
公共HttpWebRequest请求；
公共HttpWebResponse；
公共请求线程（自动resetEvent r、字符串u、请求计数器rc）
{
Url=u；
AsyncWaitHandle=r；
RequestCounter=rc；
}
公众假期结束（）
{
if（响应！=null）
Response.Close（）；
if（请求！=null）
Request.Abort（）；
}
}
公共类连接测试
{
静态void Main（）
{
字符串url=”http://www.google.com/";
int max=GetMaxConnections（25，url）；
WriteLine（String.Format（“{0}Max连接到{1}”，Max，url））；
Console.ReadLine（）；
}
私有的