WebRequest.EndGetResponse(IAsyncResult) Metoda

Definice

Obor názvů:

System.Net

Sestavení:

netstandard.dll, System.Net.Requests.dll

Zdroj:

WebRequest.cs

Při přepsání v potomk třídy vrátí 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

Parametry

asyncResult

IAsyncResult

IAsyncResult, který odkazuje na čekající požadavek na odpověď.

Návraty

WebResponse

WebResponse, která obsahuje odpověď na požadavek na internet.

Výjimky

NotImplementedException

Jakýkoli pokus o přístup k metodě, pokud metoda není přepsána v potomk třídy.

Příklady

Následující příklad volá EndGetResponse k načtení cílového prostředku.

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

Poznámky

Opatrnost

WebRequest, HttpWebRequest, ServicePointa WebClient jsou zastaralé a neměli byste je používat pro nový vývoj. Místo toho použijte HttpClient.

Metoda EndGetResponse dokončí asynchronní požadavek na internetový prostředek, který byl spuštěn metodou BeginGetResponse.

Poznámka

Třída WebRequest je třída abstract. Skutečné chování WebRequest instancí za běhu je určeno následnou třídou vrácenou metodou WebRequest.Create. Další informace o výchozích hodnotách a výjimkách naleznete v dokumentaci pro potomky třídy, jako jsou HttpWebRequest a FileWebRequest.

Viz také

• BeginGetResponse(AsyncCallback, Object)
• vytváření asynchronních požadavků