c＃.net 3.5中的多线程异步Web服务调用

Question

我有2个ASP.net 3.5 asmx Web服务，ws2和ws3。它们分别包含操作op21和op31。 op21睡觉2秒和op31睡3秒。我想在异步情况下在网络服务中调用op11中的op21和op31，同时调用ws1。这样，当我同步地从客户端呼叫op11时，所花费的时间将是总共3秒。我目前得到5秒与此代码：

WS2SoapClient ws2 = new WS2SoapClient(); 
WS3SoapClient ws3 = new WS3SoapClient(); 

//capture time 
DateTime now = DateTime.Now;    
//make calls 

IAsyncResult result1 = ws3.BeginOP31(null,null); 
IAsyncResult result2 = ws2.BeginOP21(null,null); 
WaitHandle[] handles = { result1.AsyncWaitHandle, result2.AsyncWaitHandle }; 

WaitHandle.WaitAll(handles); 

//calculate time difference 
TimeSpan ts = DateTime.Now.Subtract(now); 
return "Asynchronous Execution Time (h:m:s:ms): " + String.Format("{0}:{1}:{2}:{3}", 
ts.Hours, 
ts.Minutes, 
ts.Seconds, 
ts.Milliseconds); 

预期的结果是，两个请求的总时间应等于花费执行较慢的请求的时间。

请注意，这与我用Visual Studio进行调试时的预期方式一样，但是在IIS上运行时，时间为5秒，这似乎表明请求未被同时处理。

我的问题是，是否有IIS和ASMX Web服务的特定配置，可能需要正确设置才能按预期工作？

Answer 1

系统中有一些节流。可能该服务仅配置为一个并发调用程序，这是常见原因（WCF ConcurrencyMode）。服务器上可能存在HTTP级连接限制（ServicePointManager.DefaultConnectionLimit）或WCF限制。

使用Fiddler来确定两个请求是否被同时发送。使用调试器中断服务器并查看两个调用是否同时运行。

Answer 2

原来的答案：

我试图与google.com和bing.com我得到同样的事情，线性执行。问题在于你正在同一个线程上启动BeginOP（）调用，并且在调用完成之前不会返回AsyncResult（无论出于何种原因）。有点无用。

我的TPL之前的多线程有点生疏，但是我在测试结束时测试了代码并且它异步执行：这是一个.NET 3.5控制台应用程序。注意我显然阻碍了你的一些代码，但是让这些类看起来是一样的。

---

更新：

我开始第二猜测自己，因为我的执行时间是如此接近对方，这是令人困惑的。所以我重新编写了测试，使用Thread.Start（）来包含您的原始代码和我的建议代码。此外，我在WebRequest方法中添加了Thread.Sleep（N），以便它可以模拟请求的大量不同的执行时间。

测试结果确实显示您发布的代码是按照上面我在原始答案中所述的顺序执行的。

注的总时间是在两种情况下不是因为Thread.sleep代码的实际web请求时间（）长得多。我还添加了Thread.Sleep（）来抵消第一个到任何站点的Web请求需要很长时间才能启动（9秒）的事实，如上所述。无论采取哪种方式，都可以对其进行分割，很明显，时代在“旧”情况下是连续的，在新情况下是真正的“异步”。

---

测试了这一点，该更新程序：

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

namespace MultiThreadedTest 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      // Test both ways of executing IAsyncResult web calls 

      ExecuteUsingWaitHandles(); 
      Console.WriteLine(); 

      ExecuteUsingThreadStart(); 
      Console.ReadKey(); 
     } 

     private static void ExecuteUsingWaitHandles() 
     { 
      Console.WriteLine("Starting to execute using wait handles (old way) "); 

      WS2SoapClient ws2 = new WS2SoapClient(); 
      WS3SoapClient ws3 = new WS3SoapClient(); 

      IAsyncResult result1 = null; 
      IAsyncResult result2 = null; 

      // Time the threadas 
      var stopWatchBoth = System.Diagnostics.Stopwatch.StartNew(); 
      result1 = ws3.BeginOP31(); 
      result2 = ws2.BeginOP21(); 

      WaitHandle[] handles = { result1.AsyncWaitHandle, result2.AsyncWaitHandle }; 
      WaitHandle.WaitAll(handles); 

      stopWatchBoth.Stop(); 

      // Display execution time of individual calls 
      Console.WriteLine((result1.AsyncState as StateObject)); 
      Console.WriteLine((result2.AsyncState as StateObject)); 

      // Display time for both calls together 
      Console.WriteLine("Asynchronous Execution Time for both is {0}", stopWatchBoth.Elapsed.TotalSeconds); 
     } 

     private static void ExecuteUsingThreadStart() 
     { 
      Console.WriteLine("Starting to execute using thread start (new way) "); 

      WS2SoapClient ws2 = new WS2SoapClient(); 
      WS3SoapClient ws3 = new WS3SoapClient(); 

      IAsyncResult result1 = null; 
      IAsyncResult result2 = null; 

      // Create threads to execute the methods asynchronously 
      Thread startOp3 = new Thread(() => result1 = ws3.BeginOP31()); 
      Thread startOp2 = new Thread(() => result2 = ws2.BeginOP21()); 

      // Time the threadas 
      var stopWatchBoth = System.Diagnostics.Stopwatch.StartNew(); 

      // Start the threads 
      startOp2.Start(); 
      startOp3.Start(); 

      // Make this thread wait until both of those threads are complete 
      startOp2.Join(); 
      startOp3.Join(); 

      stopWatchBoth.Stop(); 

      // Display execution time of individual calls 
      Console.WriteLine((result1.AsyncState as StateObject)); 
      Console.WriteLine((result2.AsyncState as StateObject)); 

      // Display time for both calls together 
      Console.WriteLine("Asynchronous Execution Time for both is {0}", stopWatchBoth.Elapsed.TotalSeconds); 
     } 
    } 

    // Class representing your WS2 client 
    internal class WS2SoapClient : TestWebRequestAsyncBase 
    { 
     public WS2SoapClient() : base("http://www.msn.com/") { } 

     public IAsyncResult BeginOP21() 
     { 
      Thread.Sleep(TimeSpan.FromSeconds(10D)); 
      return BeginWebRequest(); 
     } 
    } 

    // Class representing your WS3 client 
    internal class WS3SoapClient : TestWebRequestAsyncBase 
    { 
     public WS3SoapClient() : base("http://www.google.com/") { } 

     public IAsyncResult BeginOP31() 
     { 
      // Added sleep here to simulate a much longer request, which should make it obvious if the times are overlapping or sequential 
      Thread.Sleep(TimeSpan.FromSeconds(20D)); 
      return BeginWebRequest(); 
     } 
    } 

    // Base class that makes the web request 
    internal abstract class TestWebRequestAsyncBase 
    { 
     public StateObject AsyncStateObject; 
     protected string UriToCall; 

     public TestWebRequestAsyncBase(string uri) 
     { 
      AsyncStateObject = new StateObject() 
      { 
       UriToCall = uri 
      }; 

      this.UriToCall = uri; 
     } 

     protected IAsyncResult BeginWebRequest() 
     { 
      WebRequest request = 
       WebRequest.Create(this.UriToCall); 

      AsyncCallback callBack = new AsyncCallback(onCompleted); 

      AsyncStateObject.WebRequest = request; 
      AsyncStateObject.Stopwatch = System.Diagnostics.Stopwatch.StartNew(); 

      return request.BeginGetResponse(callBack, AsyncStateObject); 
     } 

     void onCompleted(IAsyncResult result) 
     { 
      this.AsyncStateObject = (StateObject)result.AsyncState; 
      this.AsyncStateObject.Stopwatch.Stop(); 

      var webResponse = this.AsyncStateObject.WebRequest.EndGetResponse(result); 
      Console.WriteLine(webResponse.ContentType, webResponse.ResponseUri); 
     } 
    } 

    // Keep stopwatch on state object for illustration of individual execution time 
    internal class StateObject 
    { 
     public System.Diagnostics.Stopwatch Stopwatch { get; set; } 
     public WebRequest WebRequest { get; set; } 
     public string UriToCall; 

     public override string ToString() 
     { 
      return string.Format("Request to {0} executed in {1} seconds", this.UriToCall, Stopwatch.Elapsed.TotalSeconds); 
     } 
    } 
}