HttpWebRequest.BeginGetResponse(AsyncCallback, Object) Metódus

Definíció

Névtér:

System.Net

Szerelvények:

netstandard.dll, System.Net.Requests.dll

Forrás:

HttpWebRequest.cs

Aszinkron kérést indít egy internetes erőforráshoz.

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

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

override this.BeginGetResponse : AsyncCallback * obj -> IAsyncResult

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

Paraméterek

callback

AsyncCallback

A AsyncCallback meghatalmazott.

state

Object

A kérés állapotobjektuma.

Válaszok

IAsyncResult

A IAsyncResult válasz aszinkron kérésére hivatkozik.

Kivételek

InvalidOperationException

A streamet már használatban van egy korábbi hívás, amely BeginGetResponse(AsyncCallback, Object)

-vagy-

TransferEncoding értékre van állítva, és SendChunked az false.

-vagy-

A szálkészlet elfogy a szálakból.

ProtocolViolationException

Method a GET vagy a HEAD érték, és vagy ContentLength nagyobb nullánál, vagy SendChunked az true.

-vagy-

KeepAliveistrue, AllowWriteStreamBuffering isfalse, and or ContentLength is -1, SendChunked is and false is Method POST or PUT.

-vagy-

A HttpWebRequest metódusnak van egy entitástörzse, de a BeginGetResponse(AsyncCallback, Object) metódus meghívása nélkül hívjuk meg a metódust BeginGetRequestStream(AsyncCallback, Object) .

-vagy-

Ez ContentLength nagyobb, mint nulla, de az alkalmazás nem írja meg az összes ígért adatot.

WebException

Abort() korábban meghívták.

Példák

Az alábbi példakód egy internetes erőforrás aszinkron kérésének végrehajtására használja a BeginGetResponse metódust.

Note

Aszinkron kérések esetén az ügyfélalkalmazás feladata saját időtúllépési mechanizmus implementálása. Az alábbi példakód bemutatja, hogyan teheti meg.

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

Megjegyzések

Figyelmeztetés

WebRequest, HttpWebRequest, ServicePointés WebClient elavultak, és nem szabad új fejlesztésre használni őket. A HttpClient használható helyette.

A BeginGetResponse metódus elindít egy aszinkron kérést az internetes erőforrás válaszára. Az aszinkron visszahívási metódus a EndGetResponse metódussal adja vissza a tényleges WebResponseértéket.

Az A ProtocolViolationException több esetben is megjelenik, ha az osztályon HttpWebRequest beállított tulajdonságok ütköznek. Ez a kivétel akkor fordul elő, ha egy alkalmazás beállítja a ContentLength tulajdonságot és a SendChunked tulajdonságot true, majd HTTP GET kérést küld. Ez a kivétel akkor fordul elő, ha egy alkalmazás olyan kiszolgálóra próbál adattömböket küldeni, amely csak a HTTP 1.0 protokollt támogatja, ahol ez nem támogatott. Ez a kivétel akkor fordul elő, ha egy alkalmazás a tulajdonság beállítása ContentLength nélkül próbál adatokat küldeni, vagy ha SendChunked a false pufferelés le van tiltva, és egy megőrzési kapcsolaton (a KeepAlive tulajdonság true).

Ha egy WebException dobás történik, használja a Response kivétel tulajdonságait és Status tulajdonságait a kiszolgáló válaszának meghatározásához.

A BeginGetResponse metódushoz szinkron beállítási feladatok (például DNS-feloldás, proxyészlelés és TCP-szoftvercsatorna-kapcsolat) elvégzése szükséges, mielőtt ez a módszer aszinkronná válik. Ennek eredményeképpen ezt a metódust soha nem szabad felhasználói felületi (felhasználói felületi) szálra meghívni, mert a kezdeti szinkron beállítási feladatok végrehajtása (a hálózati beállításoktól függően akár több percig is) eltarthat, mielőtt kivételt okozna egy hiba miatt, vagy a metódus sikeres lesz.

A szálkészlettel kapcsolatos további információkért tekintse meg a felügyelt szálkészletet.

Note

Az alkalmazás nem tudja keverni egy adott kérés szinkron és aszinkron metódusait. Ha meghívja a metódust BeginGetRequestStream , a válasz lekéréséhez a BeginGetResponse metódust kell használnia.

Note

Ez a tag nyomkövetési adatokat ad ki, amikor engedélyezi a hálózati nyomkövetést az alkalmazásban. További információ: Network Tracing a .NET-keretrendszerben.

Lásd még

• DefaultProxy elem (hálózati beállítások)