WebRequest.BeginGetResponse(AsyncCallback, Object) 메서드

정의

네임스페이스:

System.Net

어셈블리:

netstandard.dll, System.Net.Requests.dll

Source:

WebRequest.cs

하위 클래스에서 재정의되는 경우 인터넷 리소스에 대한 비동기 요청을 시작합니다.

public:
 virtual IAsyncResult ^ BeginGetResponse(AsyncCallback ^ callback, System::Object ^ state);

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

abstract member BeginGetResponse : AsyncCallback * obj -> IAsyncResult
override this.BeginGetResponse : AsyncCallback * obj -> IAsyncResult

Public Overridable Function BeginGetResponse (callback As AsyncCallback, state As Object) As IAsyncResult

매개 변수

callback

AsyncCallback

AsyncCallback 대리자입니다.

state

Object

이 비동기 요청에 대한 상태 정보를 포함하는 개체입니다.

반환

IAsyncResult

비동기 요청을 참조하는 IAsyncResult.

예외

NotImplementedException

메서드가 하위 클래스에서 재정의되지 않은 경우 메서드에 액세스하려고 시도합니다.

예제

다음 예제에서는 BeginGetResponse 사용하여 대상 리소스를 비동기적으로 요청합니다. 리소스를 가져오면 지정된 콜백 메서드가 실행됩니다.

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

설명

주의

WebRequest, HttpWebRequest, ServicePoint및 WebClient 사용되지 않으므로 새 개발에 사용하면 안 됩니다. 대신 HttpClient 사용합니다.

BeginGetResponse 메서드는 응답에 대한 비동기 요청을 시작합니다. AsyncCallback 대리자를 구현하는 콜백 메서드는 EndGetResponse 메서드를 사용하여 인터넷 리소스에서 WebResponse 반환합니다.

메모

WebRequest 클래스는 abstract 클래스입니다. 런타임에 WebRequest 인스턴스의 실제 동작은 WebRequest.Create 메서드에서 반환된 하위 클래스에 의해 결정됩니다. 기본값 및 예외에 대한 자세한 내용은 HttpWebRequest 및 FileWebRequest같은 하위 클래스에 대한 설명서를 참조하세요.

메모

WebException이 throw되는 경우 예외의 Response 및 Status 속성을 사용하여 서버의 응답을 확인합니다.

추가 정보

• EndGetResponse(IAsyncResult)
• GetResponse()
• 비동기 요청 만들기