HttpWebRequest.BeginGetResponse(AsyncCallback, Object) Método
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Inicia uma solicitação assíncrona para um recurso da Internet.
public:
override IAsyncResult ^ BeginGetResponse(AsyncCallback ^ callback, System::Object ^ state);public override IAsyncResult BeginGetResponse(AsyncCallback callback, object state);public override IAsyncResult BeginGetResponse(AsyncCallback? callback, object? state);override this.BeginGetResponse : AsyncCallback * obj -> IAsyncResultPublic Overrides Function BeginGetResponse (callback As AsyncCallback, state As Object) As IAsyncResultParâmetros
- callback
- AsyncCallback
O delegado AsyncCallback.
- state
- Object
O objeto de estado dessa solicitação.
Retornos
Um IAsyncResult que faz referência à solicitação assíncrona de uma resposta.
Exceções
O fluxo já está em uso por uma chamada anterior para BeginGetResponse(AsyncCallback, Object)
-ou-
TransferEncoding é definido como um valor e SendChunked é false.
-ou-
O pool de threads está ficando sem threads.
Method é GET ou HEAD e ContentLength é maior que zero ou SendChunked é true.
-ou-
KeepAlive é true, AllowWriteStreamBuffering é falsee ContentLength é -1, SendChunked é false e Method é POST ou PUT.
-ou-
O HttpWebRequest tem um corpo de entidade, mas o método BeginGetResponse(AsyncCallback, Object) é chamado sem chamar o método BeginGetRequestStream(AsyncCallback, Object).
-ou-
O ContentLength é maior que zero, mas o aplicativo não grava todos os dados prometidos.
Abort() foi chamado anteriormente.
Exemplos
O exemplo de código a seguir usa o método BeginGetResponse para fazer uma solicitação assíncrona para um recurso da Internet.
Nota
No caso de solicitações assíncronas, é responsabilidade do aplicativo cliente implementar seu próprio mecanismo de tempo limite. O exemplo de código a seguir mostra como fazer isso.
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();
}
}
}
Comentários
Cuidado
WebRequest, HttpWebRequest, ServicePointe WebClient estão obsoletos e você não deve usá-los para um novo desenvolvimento. Em vez disso, use HttpClient.
O método BeginGetResponse inicia uma solicitação assíncrona para uma resposta do recurso da Internet. O método de retorno de chamada assíncrono usa o método EndGetResponse para retornar o WebResponsereal.
Um ProtocolViolationException é gerado em vários casos em que as propriedades definidas na classe HttpWebRequest são conflitantes. Essa exceção ocorrerá se um aplicativo definir a propriedade ContentLength e a propriedade SendChunked para truee, em seguida, enviar uma solicitação HTTP GET. Essa exceção ocorrerá se um aplicativo tentar enviar em partes para um servidor que dá suporte apenas ao protocolo HTTP 1.0, em que não há suporte para isso. Essa exceção ocorre se um aplicativo tenta enviar dados sem definir a propriedade ContentLength ou se o SendChunked é false quando o buffer é desabilitado e em uma conexão keepalive (a propriedade KeepAlive é true).
Se um WebException for gerado, use as propriedades Response e Status da exceção para determinar a resposta do servidor.
O método BeginGetResponse requer algumas tarefas de instalação síncronas a serem concluídas (resolução DNS, detecção de proxy e conexão de soquete TCP, por exemplo) antes que esse método se torne assíncrono. Como resultado, esse método nunca deve ser chamado em um thread de interface do usuário porque pode levar um tempo considerável (até vários minutos dependendo das configurações de rede) para concluir as tarefas de instalação síncronas iniciais antes que uma exceção para um erro seja gerada ou o método seja bem-sucedido.
Para saber mais sobre o pool de threads, consulte O pool de threads gerenciado.
Nota
Seu aplicativo não pode misturar métodos síncronos e assíncronos para uma solicitação específica. Se você chamar o método BeginGetRequestStream, deverá usar o método BeginGetResponse para recuperar a resposta.
Nota
Esse membro gera informações de rastreamento quando você habilita o rastreamento de rede em seu aplicativo. Para obter mais informações, consulte Rastreamento de Rede no .NET Framework.
