WebRequest.EndGetResponse(IAsyncResult) Metodo

Definizione

Spazio dei nomi:

System.Net

Assembly:

netstandard.dll, System.Net.Requests.dll

Origine:

WebRequest.cs

Quando sottoposto a override in una classe discendente, restituisce un WebResponse.

public:
 virtual System::Net::WebResponse ^ EndGetResponse(IAsyncResult ^ asyncResult);

public virtual System.Net.WebResponse EndGetResponse(IAsyncResult asyncResult);

abstract member EndGetResponse : IAsyncResult -> System.Net.WebResponse
override this.EndGetResponse : IAsyncResult -> System.Net.WebResponse

Public Overridable Function EndGetResponse (asyncResult As IAsyncResult) As WebResponse

Parametri

asyncResult

IAsyncResult

Un IAsyncResult che fa riferimento a una richiesta in sospeso per una risposta.

Restituisce

WebResponse

Oggetto WebResponse che contiene una risposta alla richiesta Internet.

Eccezioni

NotImplementedException

Qualsiasi tentativo viene effettuato per accedere al metodo, quando il metodo non viene sottoposto a override in una classe discendente.

Esempio

Nell'esempio seguente viene chiamato il EndGetResponse per recuperare la risorsa di destinazione.

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

Commenti

Cautela

WebRequest, HttpWebRequest, ServicePointe WebClient sono obsoleti e non è consigliabile usarli per nuovi sviluppi. Usare invece HttpClient.

Il metodo EndGetResponse completa una richiesta asincrona per una risorsa Internet avviata con il metodo BeginGetResponse.

Nota

La classe WebRequest è una classe abstract. Il comportamento effettivo delle istanze di WebRequest in fase di esecuzione è determinato dalla classe discendente restituita dal metodo WebRequest.Create. Per altre informazioni sui valori predefiniti e sulle eccezioni, vedere la documentazione per le classi discendenti, ad esempio HttpWebRequest e FileWebRequest.

Vedi anche

• BeginGetResponse(AsyncCallback, Object)
• effettuare richieste asincrone