HttpWebRequest.BeginGetResponse(AsyncCallback, Object) Méthode

Définition

Espace de noms:

System.Net

Assemblys:

netstandard.dll, System.Net.Requests.dll

Source:

HttpWebRequest.cs

Commence une requête asynchrone vers une ressource Internet.

C#

public override IAsyncResult BeginGetResponse(AsyncCallback? callback, object? state);

Paramètres

callback

AsyncCallback

Délégué AsyncCallback.

state

Object

Objet d’état pour cette requête.

Retours

IAsyncResult

Un IAsyncResult qui fait référence à la demande asynchrone d’une réponse.

Exceptions

InvalidOperationException

Le flux est déjà utilisé par un appel précédent à BeginGetResponse(AsyncCallback, Object)

-ou-

TransferEncoding est défini sur une valeur et SendChunked est false.

-ou-

Le pool de threads manque de threads.

ProtocolViolationException

Method est GET ou HEAD, et ContentLength est supérieur à zéro ou SendChunked est true.

-ou-

KeepAlive est true, AllowWriteStreamBuffering est falseet ContentLength est -1, SendChunked est false et Method est POST ou PUT.

-ou-

Le HttpWebRequest a un corps d’entité, mais la méthode BeginGetResponse(AsyncCallback, Object) est appelée sans appeler la méthode BeginGetRequestStream(AsyncCallback, Object).

-ou-

La ContentLength est supérieure à zéro, mais l’application n’écrit pas toutes les données promises.

WebException

Abort() a été appelée précédemment.

Exemples

L’exemple de code suivant utilise la méthode BeginGetResponse pour effectuer une requête asynchrone pour une ressource Internet.

Remarque

Dans le cas de requêtes asynchrones, il incombe à l’application cliente d’implémenter son propre mécanisme de délai d’attente. L’exemple de code suivant montre comment le faire.

C#

using System;
using System.Net;
using System.IO;
using System.Text;
using System.Threading;

public static class WebRequestAPMSample
{
    private const int BufferSize = 1024;

    private class RequestState
    {
        public StringBuilder ResponseBuilder { get; }
        public byte[] ReadBuffer { get; }
        public WebRequest Request { get; }
        public WebResponse Response { get; set; }
        public Stream ResponseStream { get; set; }
        public RequestState(WebRequest request)
        {
            ReadBuffer = new byte[BufferSize];
            ResponseBuilder = new StringBuilder();
            Request = request;
        }
        public void OnResponseBytesRead(int read) => ResponseBuilder.Append(Encoding.UTF8.GetString(ReadBuffer, 0, read));
    }

    public static ManualResetEvent allDone = new ManualResetEvent(false);
    

    public static void Main()
    {
        try
        {
            // Create a WebRequest object to the desired URL.
            WebRequest webRequest = WebRequest.Create("http://www.contoso.com");
            webRequest.Timeout = 10_000; // Set 10sec timeout.

            // Create an instance of the RequestState and assign the previous myHttpWebRequest
            // object to its request field.
            RequestState requestState = new RequestState(webRequest);

            // Start the asynchronous request.
            IAsyncResult result = webRequest.BeginGetResponse(new AsyncCallback(ResponseCallback), requestState);

            // Wait for the response or for failure. The processing happens in the callback.
            allDone.WaitOne();

            // Release the WebResponse resources.
            requestState.Response?.Close();
        }
        catch (WebException e)
        {
            Console.WriteLine("\nMain(): WebException raised!");
            Console.WriteLine("\nMessage:{0}", e.Message);
            Console.WriteLine("\nStatus:{0}", e.Status);
            Console.WriteLine("Press any key to continue..........");
            Console.Read();
        }
        catch (Exception e)
        {
            Console.WriteLine("\nMain(): Exception raised!");
            Console.WriteLine("Source :{0} ", e.Source);
            Console.WriteLine("Message :{0} ", e.Message);
            Console.WriteLine("Press any key to continue..........");
            Console.Read();
        }
    }

    private static void HandleSyncResponseReadCompletion(IAsyncResult asyncResult)
    {
        RequestState requestState = (RequestState)asyncResult.AsyncState;
        Stream responseStream = requestState.ResponseStream;

        bool readComplete = false;
        while (asyncResult.CompletedSynchronously && !readComplete)
        {
            int read = responseStream.EndRead(asyncResult);
            if (read > 0)
            {
                requestState.OnResponseBytesRead(read);
                asyncResult = responseStream.BeginRead(requestState.ReadBuffer, 0, BufferSize, new AsyncCallback(ReadCallBack), requestState);
            }
            else
            {
                readComplete = true;
                HandleReadCompletion(requestState);
            }
        }
    }

    private static void ResponseCallback(IAsyncResult asynchronousResult)
    {
        try
        {
            // AsyncState is an instance of RequestState.
            RequestState requestState = (RequestState)asynchronousResult.AsyncState;
            WebRequest request = requestState.Request;
            requestState.Response = request.EndGetResponse(asynchronousResult);

            // Read the response into a Stream.
            Stream responseStream = requestState.Response.GetResponseStream();
            requestState.ResponseStream = responseStream;

            // Begin the Reading of the contents of the HTML page and print it to the console.
            IAsyncResult asynchronousReadResult = responseStream.BeginRead(requestState.ReadBuffer, 0, BufferSize, new AsyncCallback(ReadCallBack), requestState);
            HandleSyncResponseReadCompletion(asynchronousReadResult);
        }
        catch (WebException e)
        {
            Console.WriteLine("\nRespCallback(): Exception raised!");
            Console.WriteLine("\nMessage:{0}", e.Message);
            Console.WriteLine("\nStatus:{0}", e.Status);
            allDone.Set();
        }   
    }

    // Print the webpage to the standard output, close the stream and signal completion.
    private static void HandleReadCompletion(RequestState requestState)
    {
        Console.WriteLine("\nThe contents of the Html page are : ");
        if (requestState.ResponseBuilder.Length > 1)
        {
            string stringContent;
            stringContent = requestState.ResponseBuilder.ToString();
            Console.WriteLine(stringContent);
        }
        Console.WriteLine("Press any key to continue..........");
        Console.ReadLine();

        requestState.ResponseStream.Close();
        allDone.Set();
    }

    private static void ReadCallBack(IAsyncResult asyncResult)
    {
        if (asyncResult.CompletedSynchronously)
        {
            // To avoid recursive synchronous calls into ReadCallBack,
            // synchronous completion is handled at the BeginRead call-site.
            return;
        }

        try
        {
            RequestState requestState = (RequestState)asyncResult.AsyncState;
            Stream responseStream = requestState.ResponseStream;
            int read = responseStream.EndRead(asyncResult);
            // Read the HTML page and then print it to the console.
            if (read > 0)
            {
                requestState.OnResponseBytesRead(read);
                IAsyncResult asynchronousResult = responseStream.BeginRead(requestState.ReadBuffer, 0, BufferSize, new AsyncCallback(ReadCallBack), requestState);
                HandleSyncResponseReadCompletion(asynchronousResult);
            }
            else
            {
                HandleReadCompletion(requestState);
            }
        }
        catch (WebException e)
        {
            Console.WriteLine("\nReadCallBack(): Exception raised!");
            Console.WriteLine("\nMessage:{0}", e.Message);
            Console.WriteLine("\nStatus:{0}", e.Status);
            allDone.Set();
        }
    }
}

Remarques

Précaution

WebRequest, HttpWebRequest, ServicePointet WebClient sont obsolètes et vous ne devez pas les utiliser pour le nouveau développement. Utilisez HttpClient à la place.

La méthode BeginGetResponse démarre une requête asynchrone pour une réponse de la ressource Internet. La méthode de rappel asynchrone utilise la méthode EndGetResponse pour retourner le WebResponseréel.

Une ProtocolViolationException est levée dans plusieurs cas lorsque les propriétés définies sur la classe HttpWebRequest sont en conflit. Cette exception se produit si une application définit la propriété ContentLength et la propriété SendChunked à true, puis envoie une requête HTTP GET. Cette exception se produit si une application tente d’envoyer un bloc à un serveur qui prend uniquement en charge le protocole HTTP 1.0, où cela n’est pas pris en charge. Cette exception se produit si une application tente d’envoyer des données sans définir la propriété ContentLength ou si l'SendChunked est false lorsque la mise en mémoire tampon est désactivée et sur une connexion keepalive (la propriété KeepAlive est true).

Si une WebException est levée, utilisez les propriétés Response et Status de l’exception pour déterminer la réponse du serveur.

La méthode BeginGetResponse nécessite des tâches d’installation synchrones à effectuer (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, car il peut prendre beaucoup de temps (jusqu’à plusieurs minutes en fonction des paramètres réseau) pour effectuer les tâches d’installation synchrones initiales avant qu’une exception pour une erreur soit levée ou que la méthode réussit.

Pour en savoir plus sur le pool de threads, consultez Le pool de threads managés.

Remarque

Votre application ne peut pas combiner de méthodes synchrones et asynchrones pour une requête particulière. Si vous appelez la méthode BeginGetRequestStream, vous devez utiliser la méthode BeginGetResponse pour récupérer la réponse.

Remarque

Ce membre génère des informations de suivi lorsque vous activez le suivi réseau dans votre application. Pour plus d’informations, consultez suivi réseau dans le .NET Framework.

S’applique à

Voir aussi

• Élément DefaultProxy (Paramètres réseau)