Comment utiliser HttpWebRequest (.NET) de manière asynchrone ?

Question

Comment utiliser HttpWebRequest (.NET, C#) de manière asynchrone ?

Answer 1

Utilisez HttpWebRequest.BeginGetResponse()

HttpWebRequest webRequest;

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

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

La fonction de rappel est appelée lorsque l'opération asynchrone est terminée. Vous devez au moins appeler EndGetResponse() de cette fonction.

Answer 2

Le moyen le plus simple, et de loin, est d'utiliser TaskFactory.FromAsync de la TPL . Il s'agit littéralement de quelques lignes de code lorsqu'elles sont utilisées en conjonction avec la nouvelle fonction async/await mots-clés :

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

Si vous ne pouvez pas utiliser le compilateur C#5, ce qui précède peut être accompli en utilisant la fonction Task.ContinueWith méthode :

Task.Factory.FromAsync<WebResponse>(request.BeginGetResponse,
                                    request.EndGetResponse,
                                    null)
    .ContinueWith(task =>
    {
        var response = (HttpWebResponse) task.Result;
        Debug.Assert(response.StatusCode == HttpStatusCode.OK);
    });

Answer 3

En considérant la réponse :

HttpWebRequest webRequest;

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

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

Vous pouvez envoyer le pointeur de la demande ou tout autre objet comme ceci :

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

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

Salutations

Answer 4

Tout le monde a eu tort jusqu'à présent, parce que BeginGetResponse() effectue un travail sur le fil actuel. Du documentation :

La méthode BeginGetResponse nécessite quelques tâches de configuration synchrones pour (résolution DNS, détection de proxy et connexion de socket TCP, par exemple) avant que cette méthode ne devienne asynchrone. Par conséquent cette méthode ne doit jamais être appelée sur un thread d'interface utilisateur (IU) car cela pourrait prendre un temps considérable (jusqu'à plusieurs minutes (jusqu'à plusieurs minutes, selon les paramètres du réseau) pour effectuer les synchrones avant qu'une exception soit levée ou que la méthode réussisse. ne réussisse.

Donc pour faire ça bien :

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

Vous pouvez ensuite faire ce que vous voulez de la réponse. Par exemple :

HttpWebRequest request;
// init your request...then:
DoWithResponse(request, (response) => {
    var body = new StreamReader(response.GetResponseStream()).ReadToEnd();
    Console.Write(body);
});

Answer 5

J'ai fini par utiliser BackgroundWorker, il est définitivement asynchrone contrairement à certaines des solutions ci-dessus, il gère le retour au thread de l'interface graphique pour vous, et il est très facile à comprendre.

Il est également très facile de gérer les exceptions, car elles aboutissent dans la méthode RunWorkerCompleted, mais assurez-vous de lire ceci : Exceptions non gérées dans BackgroundWorker

J'ai utilisé WebClient mais vous pouvez évidemment utiliser HttpWebRequest.GetResponse si vous le souhaitez.

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