Question

I m 创建小型测试应用,通过几个测试案例来检查我们系统各个组成部分的状况。该申请是作为“NETWindows”应用程序创建的,有几套核对箱,在每一起测试案例中对通行证进行核对(如果失败,则不予检查)。

其中一项测试是检查是否有简单的网络服务。如果能够提供网络服务,测试案例就会成功,否则就会失败。我首先尝试利用该系统实现这一目标。 Net.HttpWebRequest等,规定时间为1500 ms,并援引GetResponse。现在,如果无法提供网络服务,则申请时间应予取消,试办案失败。然而,随着时间的推移,时间是根据网络服务的实际反应确定的。这就是说,从建立网络服务链接起算时间。如果网络服务根本无法提供,那么时间就不再发生,因此,在试办失败之前至少需要30秒。

为了解决这一问题,我建议用BeginGetResponse在请求完成时发出呼吁。现在,这里出现同样的问题,因为如果无法提供网络服务,则至少需要30秒,直到出现回响。

现在我想我可以使用一个系统。 Timers. 时间长,规定时间为1500米,时间过长。问题是,时间长短不取决于网络服务是否方便,因此,活动将独立于网络服务能否上网之外进行。

我现在不谈想法。我认识到,这必须是一个非常容易解决的问题。是否有任何人就我如何能够做到这一点提出建议?

我接受建议,使这一呼吁能够自食其力。因此,我现在自己照样执行这一请求。然而,如果申请方有答复,则申请在Im试图确定测试状况失败时锁定。但是,如果得到答复,我可以确定试办地位,以继承任何问题。该法典:

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();

关于我为什么会这样做的任何建议? Thanx!

Answer 1

Hmm. 真正安排时间的非常奇怪。为什么你不使用HttpWebRequest的排泄物? 之后,紧靠HttpWebRequest。 GetResponse() with Trial. Oliver(timeoutException). 它完全是同yn。

这一停职是确定工作联系所需时间的。如果你后来想控制最大的“GetResponse()”时间,你就应当使用“记忆犹新”来进行复读。这就是说。

如果你仍然希望它单独运行,那么:

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

“时间长短不取决于网络服务是否方便,因此,活动将独立于网络服务是否无障碍之外进行。”

You can stop the timer once the Web Service is reachable. If the timer call is set to 2000ms and the Web Service calls takes less than 2000ms to complete then disable the timer, otherwise the timer event will notify that there is something wrong with the Web Service

Answer 4

您还可以考虑利用背景工作组的标语,以更加友好的方式履行这些呼吁。它有能力履行阿辛特服务,并向母体表格/目标汇报。那么,你就可以在不担心表面上的例外的情况下,对网站的要求给予任何时间长度和规则。

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;

            }
             * */
        }
    }
}

友情链接