161

如何异步使用 HttpWebRequest (.NET, C#)？

4

10 回答 10

128

采用HttpWebRequest.BeginGetResponse()

HttpWebRequest webRequest;

void StartWebRequest()
{
    webRequest.BeginGetResponse(new AsyncCallback(FinishWebRequest), null);
}

void FinishWebRequest(IAsyncResult result)
{
    webRequest.EndGetResponse(result);
}

异步操作完成时调用回调函数。您至少需要EndGetResponse()从此函数调用。

于 2008-10-14T21:17:56.263 回答
69

到目前为止，最简单的方法是使用TPL中的TaskFactory.FromAsync。当与新的async/await关键字结合使用时，它实际上是几行代码：

var request = WebRequest.Create("http://www.stackoverflow.com");
var response = (HttpWebResponse) await Task.Factory
    .FromAsync<WebResponse>(request.BeginGetResponse,
                            request.EndGetResponse,
                            null);
Debug.Assert(response.StatusCode == HttpStatusCode.OK);

如果您不能使用 C#5 编译器，则可以使用Task.ContinueWith方法完成上述操作：

Task.Factory.FromAsync<WebResponse>(request.BeginGetResponse,
                                    request.EndGetResponse,
                                    null)
    .ContinueWith(task =>
    {
        var response = (HttpWebResponse) task.Result;
        Debug.Assert(response.StatusCode == HttpStatusCode.OK);
    });
于 2014-04-11T05:15:07.530 回答
67

考虑答案：

HttpWebRequest webRequest;

void StartWebRequest()
{
    webRequest.BeginGetResponse(new AsyncCallback(FinishWebRequest), null);
}

void FinishWebRequest(IAsyncResult result)
{
    webRequest.EndGetResponse(result);
}

您可以发送请求指针或任何其他对象，如下所示：

void StartWebRequest()
{
    HttpWebRequest webRequest = ...;
    webRequest.BeginGetResponse(new AsyncCallback(FinishWebRequest), webRequest);
}

void FinishWebRequest(IAsyncResult result)
{
    HttpWebResponse response = (result.AsyncState as HttpWebRequest).EndGetResponse(result) as HttpWebResponse;
}

问候

于 2010-12-13T22:31:56.520 回答
64

到目前为止，每个人都错了，因为BeginGetResponse()在当前线程上做了一些工作。从文档中：

BeginGetResponse 方法需要在此方法变为异步之前完成一些同步设置任务（例如 DNS 解析、代理检测和 TCP 套接字连接）。因此，永远不应在用户界面 (UI) 线程上调用此方法，因为在引发错误异常之前完成初始同步设置任务可能需要相当长的时间（长达几分钟，具体取决于网络设置）或该方法成功。

所以要做到这一点：

void DoWithResponse(HttpWebRequest request, Action<HttpWebResponse> responseAction)
{
    Action wrapperAction = () =>
    {
        request.BeginGetResponse(new AsyncCallback((iar) =>
        {
            var response = (HttpWebResponse)((HttpWebRequest)iar.AsyncState).EndGetResponse(iar);
            responseAction(response);
        }), request);
    };
    wrapperAction.BeginInvoke(new AsyncCallback((iar) =>
    {
        var action = (Action)iar.AsyncState;
        action.EndInvoke(iar);
    }), wrapperAction);
}

然后，您可以对响应做您需要做的事情。例如：

HttpWebRequest request;
// init your request...then:
DoWithResponse(request, (response) => {
    var body = new StreamReader(response.GetResponseStream()).ReadToEnd();
    Console.Write(body);
});
于 2012-12-20T00:03:00.093 回答
9 
public static async Task<byte[]> GetBytesAsync(string url) {
    var request = (HttpWebRequest)WebRequest.Create(url);
    using (var response = await request.GetResponseAsync())
    using (var content = new MemoryStream())
    using (var responseStream = response.GetResponseStream()) {
        await responseStream.CopyToAsync(content);
        return content.ToArray();
    }
}

public static async Task<string> GetStringAsync(string url) {
    var bytes = await GetBytesAsync(url);
    return Encoding.UTF8.GetString(bytes, 0, bytes.Length);
}
于 2018-03-11T21:44:54.530 回答
7

我最终使用了BackgroundWorker，它与上面的一些解决方案不同，它绝对是异步的，它为您处理返回GUI线程，并且非常容易理解。

处理异常也很容易，因为它们最终会出现在 RunWorkerCompleted 方法中，但请确保您阅读了以下内容：Unhandled exceptions in BackgroundWorker

我使用了 WebClient，但显然你可以根据需要使用 HttpWebRequest.GetResponse。

var worker = new BackgroundWorker();

worker.DoWork += (sender, args) => {
    args.Result = new WebClient().DownloadString(settings.test_url);
};

worker.RunWorkerCompleted += (sender, e) => {
    if (e.Error != null) {
        connectivityLabel.Text = "Error: " + e.Error.Message;
    } else {
        connectivityLabel.Text = "Connectivity OK";
        Log.d("result:" + e.Result);
    }
};

connectivityLabel.Text = "Testing Connectivity";
worker.RunWorkerAsync();
于 2013-03-06T18:10:07.707 回答
6

自从发布了许多这些答案以来，.NET 已经发生了变化，我想提供一个更新的答案。使用异步方法启动Task将在后台线程上运行的：

private async Task<String> MakeRequestAsync(String url)
{    
    String responseText = await Task.Run(() =>
    {
        try
        {
            HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
            WebResponse response = request.GetResponse();            
            Stream responseStream = response.GetResponseStream();
            return new StreamReader(responseStream).ReadToEnd();            
        }
        catch (Exception e)
        {
            Console.WriteLine("Error: " + e.Message);
        }
        return null;
    });

    return responseText;
}

要使用异步方法：

String response = await MakeRequestAsync("http://example.com/");

更新：

此解决方案不适用于使用WebRequest.GetResponseAsync()代替的UWP 应用程序WebRequest.GetResponse()，并且它不会Dispose()在适当的情况下调用方法。@dragansr 有一个很好的替代解决方案来解决这些问题。

于 2017-10-19T15:39:35.497 回答
3 
public void GetResponseAsync (HttpWebRequest request, Action<HttpWebResponse> gotResponse)
    {
        if (request != null) { 
            request.BeginGetRequestStream ((r) => {
                try { // there's a try/catch here because execution path is different from invokation one, exception here may cause a crash
                    HttpWebResponse response = request.EndGetResponse (r);
                    if (gotResponse != null) 
                        gotResponse (response);
                } catch (Exception x) {
                    Console.WriteLine ("Unable to get response for '" + request.RequestUri + "' Err: " + x);
                }
            }, null);
        } 
    }
于 2012-10-08T06:02:34.883 回答
0

跟进@Isak 的回答，非常好。尽管如此，它最大的缺陷是它只会在响应状态为 200-299 时调用 responseAction。解决此问题的最佳方法是：

private void DoWithResponseAsync(HttpWebRequest request, Action<HttpWebResponse> responseAction)
{
    Action wrapperAction = () =>
    {
        request.BeginGetResponse(new AsyncCallback((iar) =>
        {
            HttpWebResponse response;
            try
            {
                response = (HttpWebResponse)((HttpWebRequest)iar.AsyncState).EndGetResponse(iar);
            }
            catch (WebException ex)
            {
                // It needs to be done like this in order to read responses with error status:
                response = ex.Response as HttpWebResponse;
            }
            responseAction(response);
        }), request);
    };
    wrapperAction.BeginInvoke(new AsyncCallback((iar) =>
    {
        var action = (Action)iar.AsyncState;
        action.EndInvoke(iar);
    }), wrapperAction);
}

然后@Isak 如下：

HttpWebRequest request;
// init your request...then:
DoWithResponse(request, (response) => {
    var body = new StreamReader(response.GetResponseStream()).ReadToEnd();
    Console.Write(body);
});
于 2021-12-23T11:07:52.227 回答
-1

我一直在将它用于异步 UWR，希望它可以帮助某人

    string uri = "http://some.place.online";

    using (UnityWebRequest uwr = UnityWebRequest.Get(uri))
    {
        var asyncOp = uwr.SendWebRequest();
        while (asyncOp.isDone == false) await Task.Delay(1000 / 30); // 30 hertz

        if(uwr.result == UnityWebRequest.Result.Success) return uwr.downloadHandler.text;
        Debug.LogError(uwr.error);
    }
于 2022-01-17T18:44:57.873 回答