如何使用异步调用检查 Web 服务是否可用

Question

我正在创建一个小型测试应用程序，它将通过几个测试用例来检查我们系统各个组件的状态。该应用程序被创建为一个带有几个复选框的 .NET Windows 窗体应用程序，这些复选框为每个通过的测试用例检查（如果失败则不检查）。

其中一项测试是检查简单 Web 服务的可用性。如果 web 服务可用，则测试用例成功，否则失败。我首先尝试通过使用 System.Net.HttpWebRequest 类来完成此操作，将超时设置为 1500 毫秒并调用 GetResponse。现在，如果 web 服务不可用，请求应该超时并且测试用例失败。然而，事实证明，超时设置在来自 web 服务的实际响应中。也就是说，超时从与webservice的连接建立起开始计时。如果 web 服务根本无法访问，则不会发生超时，因此至少需要 30 秒直到测试用例失败。

为了解决这个问题，建议我使用 BeginGetResponse 进行异步调用，并在请求完成时进行回调。现在，同样的问题出现在这里，因为如果webservice不可用，至少需要30秒才能发生回调。

现在我在想我可以使用 System.Timers.Timer，将超时设置为 1500 毫秒，并在计时器超时时设置一个事件。问题是，计时器将超时，与 Web 服务是否可访问无关，因此事件将独立于 Web 服务是否可访问而被触发。

现在我没有主意了。我意识到这一定是一个相当容易解决的问题。有人对我如何做到这一点有任何建议吗？

我得到了在自己的线程中进行调用的建议。所以现在我在它自己的线程中执行请求。但是，如果请求没有响应，当我尝试将测试状态设置为失败时，应用程序会锁定。但是，如果它有响应，我可以将测试状态设置为成功，而不会出现任何问题。代码：

private void TestWebServiceConnection()
        {
            HttpWebRequest request;
            request = (HttpWebRequest)WebRequest.Create(Url);
            request.BeginGetResponse(new AsyncCallback(FinishWebRequest), null);
            System.Threading.Thread.Sleep(1500);
            SetStatusDelegate d = new SetStatusDelegate(SetTestStatus);
            if (request.HaveResponse)
            {
                if (ConnectionTestCase.InvokeRequired)
                {
                    this.Invoke(d, new object[] { TestStatus.Success});
                }
            }
            else
            {
                if (ConnectionTestCase.InvokeRequired)
                {
                    this.Invoke(d, new object[] { TestStatus.Failure });
                }
            }

        }
        private delegate void SetStatusDelegate(TestStatus t);

        private void SetTestStatus(TestStatus t)
        {
            ConnectionTestCase.Status = t;
        }

ThreadStart ts = new ThreadStart(TestWebServiceConnection);
Thread t = new Thread(ts);
t.Start();

关于我为什么会出现这种行为的任何建议？谢谢！

Answer 1

嗯.. 设置超时的方式真的很奇怪。为什么不使用 HttpWebRequest 对象的 timeout 属性？然后用 try..catch(TimeoutException) 包围 HttpWebRequest.GetResponse()。而且它根本不应该是异步的。

此超时正是确定获得有效连接所需时间的超时。如果您以后想要控制最大 GetResponse() 时间，您应该使用 MemoryStream 来读取响应流，它也具有 readtimeout 属性。就是这样。

如果您仍然希望它在单独的线程中运行，请这样做：

Thread testThread = new Thread( () => {
    SetStatusDelegate d = new SetStatusDelegate(SetTestStatus);
    HttpWebRequest request = (HttpWebRequest)WebRequest.Create("yoururl");
    request.Timeout = new TimeSpan( 0, 1, 30 );
    try
    {
        request.GetResponse();
    }
    catch( TimeoutException )
    {
         this.Invoke(d, new object[] { TestStatus.Failure});
    }
    this.Invoke(d, new object[] { TestStatus.Success});
});

或者类似的东西:)

Answer 2

你为什么不在一个新线程中自己调用呢？

Answer 3

“计时器将超时，与 Web 服务是否可访问无关，因此事件将被触发，与 Web 服务是否可访问无关。”

一旦 Web 服务可访问，您就可以停止计时器。 如果定时器调用设置为 2000ms 并且 Web Service 调用完成时间小于 2000ms 则禁用定时器，否则定时器事件将通知 Web Service 有问题

Answer 4

您也可以考虑使用 BackgroundWorker 对象以更线程安全的方式执行这些调用。它能够执行异步服务并向父表单/对象报告。然后，您可以将任何时间长度和规则附加到您认为必要的 Web 请求中，而不必担心线程异常。

Answer 5

我尝试解决您的问题，但没有完成。也许其他人可以修复其中的错误：

using System;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;
using System.Net;
using System.Threading;

namespace winformapp
{
    public partial class Form1 : Form
    {
        private bool completedInTime = false;
        private HttpWebRequest request = null;
        public delegate void RequestCompletedDelegate(bool completedSuccessfully);
        private static AutoResetEvent resetEvent = new AutoResetEvent(false);
        private System.Threading.Timer timer = null;
        private static readonly object lockOperation = new object();
        public Form1()
        {
            InitializeComponent();
            urlTextBox.Text = "http://twitter.com";
            millisecondsTextBox.Text = "10000";
        }

        private void handleUIUpdateRequest(bool completedSuccessfully)
        {
            resultCheckbox.Checked = completedSuccessfully;
            startTestButton.Enabled = true;
            completedInTime = false;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            startTestButton.Enabled = false;
            try
            {
                TestWebServiceConnection(urlTextBox.Text,
                    Convert.ToInt32(millisecondsTextBox.Text));
                resetEvent.WaitOne();
                resultCheckbox.BeginInvoke(new RequestCompletedDelegate(handleUIUpdateRequest), completedInTime);
                timer.Change(Timeout.Infinite, Timeout.Infinite);
            }
            catch (Exception ex)
            {

            }
        }
        private void TestWebServiceConnection(string url, int timeoutMilliseconds)
        {
            request = (HttpWebRequest)WebRequest.Create(url);
            request.BeginGetResponse(new AsyncCallback(FinishWebRequest), null);
            timer = new System.Threading.Timer(new TimerCallback(abortRequest), null, timeoutMilliseconds, Timeout.Infinite);
        }
        private void FinishWebRequest(IAsyncResult iar)
        {
                lock (lockOperation)
                {
                    completedInTime = true;
                    resetEvent.Set();
                }

                /*
                if (timer != null)
                {
                    timer.Dispose();
                    try
                    {
                        if (request != null)
                        {
                            request.Abort();
                        }
                    }
                    catch { }
                }
                timer = null;
                request = null;

            }
                 * */
        }
        private void abortRequest(object state)
        {
            lock (lockOperation)
            {
                resetEvent.Set();
            }
            try
            {
                Thread.CurrentThread.Abort();
            }
            catch {}
            /*
            lock (lockOperation)
            {
                if (!completedInTime)
                {
                    resetEvent.Set();
                }
            }

            if (completedInTime == false)
            {
                lock (lockOperation)
                {
                    completedInTime = false;
                }
                try
                {
                    if (request != null)
                    {
                        request.Abort();
                    }
                }
                catch { }
                try
                {
                    if (timer != null)
                    {
                        timer.Dispose();
                    }
                }
                catch { }
                finally
                {
                    resetEvent.Set();
                }

                request = null;
                timer = null;

            }
             * */
        }
    }
}