Export (0) Print
Expand All

HttpWebRequest.BeginGetResponse Method

Begins an asynchronous request to an Internet resource.

Namespace:  System.Net
Assembly:  System (in System.dll)

[HostProtectionAttribute(SecurityAction.LinkDemand, ExternalThreading = true)]
public override IAsyncResult BeginGetResponse(
	AsyncCallback callback,
	Object state
)

Parameters

callback
Type: System.AsyncCallback

The AsyncCallback delegate

state
Type: System.Object

The state object for this request.

Return Value

Type: System.IAsyncResult
An IAsyncResult that references the asynchronous request for a response.

ExceptionCondition
InvalidOperationException

The stream is already in use by a previous call to BeginGetResponse

-or-

TransferEncoding is set to a value and SendChunked is false.

-or-

The thread pool is running out of threads.

ProtocolViolationException

Method is GET or HEAD, and either ContentLength is greater than zero or SendChunked is true.

-or-

KeepAlive is true, AllowWriteStreamBuffering is false, and either ContentLength is -1, SendChunked is false and Method is POST or PUT.

WebException

Abort was previously called.

NoteNote:

The HostProtectionAttribute attribute applied to this type or member has the following Resources property value: ExternalThreading. The HostProtectionAttribute does not affect desktop applications (which are typically started by double-clicking an icon, typing a command, or entering a URL in a browser). For more information, see the HostProtectionAttribute class or SQL Server Programming and Host Protection Attributes.

The BeginGetResponse method starts an asynchronous request for a response from the Internet resource. The asynchronous callback method uses the EndGetResponse method to return the actual WebResponse.

A ProtocolViolationException is thrown in several cases when the properties set on the HttpWebRequest class are conflicting. This exception occurs if an application sets the ContentLength property and the SendChunked property to true, and then sends an HTTP GET request. This exception occurs if an application tries to send chunked to a server that only supports HTTP 1.0 protocol, where this is not supported. This exception occurs if an application tries to send data without setting the ContentLength property or the SendChunked is false when buffering is disabled and on a keepalive connection (the KeepAlive property is true).

If a WebException is thrown, use the Response and Status properties of the exception to determine the response from the server.

The BeginGetResponse method requires some synchronous setup tasks to complete (DNS resolution, proxy detection, and TCP socket connection, for example) before this method becomes asynchronous. As a result, this method should never be called on a user interface (UI) thread because it might take some time, typically several seconds. In some environments where the webproxy scripts are not configured properly, this can take 60 seconds or more. The default value for the downloadTime attribute on the <webProxyScipt> config file element is one minute which accounts for most of the potential time delay.

To learn more about the thread pool, see The Managed Thread Pool.

NoteNote:

Your application cannot mix synchronous and asynchronous methods for a particular request. If you call the BeginGetRequestStream method, you must use the BeginGetResponse method to retrieve the response.

NoteNote:

This member outputs trace information when you enable network tracing in your application. For more information, see Network Tracing.

The following code example uses the BeginGetResponse method to make an asynchronous request for an Internet resource.

NoteNote:

In the case of asynchronous requests, it is the responsibility of the client application to implement its own time-out mechanism. The following code example shows how to do it.

using System;
using System.Net;
using System.IO;
using System.Text;
using System.Threading;


public class RequestState
{
  // This class stores the State of the request. 
  const int BUFFER_SIZE = 1024;
  public StringBuilder requestData;
  public byte[] BufferRead;
  public HttpWebRequest request;
  public HttpWebResponse response;
  public Stream streamResponse;
  public RequestState()
  {
    BufferRead = new byte[BUFFER_SIZE];
    requestData = new StringBuilder("");
    request = null;
    streamResponse = null;
  }
}

class HttpWebRequest_BeginGetResponse
{
  public static ManualResetEvent allDone= new ManualResetEvent(false);
  const int BUFFER_SIZE = 1024;
  const int DefaultTimeout = 2 * 60 * 1000; // 2 minutes timeout 

  // Abort the request if the timer fires. 
  private static void TimeoutCallback(object state, bool timedOut) { 
      if (timedOut) {
          HttpWebRequest request = state as HttpWebRequest;
          if (request != null) {
              request.Abort();
          }
      }
  }

  static void Main()
  {  

    try
    {
      // Create a HttpWebrequest object to the desired URL. 
      HttpWebRequest myHttpWebRequest= (HttpWebRequest)WebRequest.Create("http://www.contoso.com");


  /**
    * If you are behind a firewall and you do not have your browser proxy setup
    * you need to use the following proxy creation code.

      // Create a proxy object.
      WebProxy myProxy = new WebProxy();

      // Associate a new Uri object to the _wProxy object, using the proxy address
      // selected by the user.
      myProxy.Address = new Uri("http://myproxy");


      // Finally, initialize the Web request object proxy property with the _wProxy
      // object.
      myHttpWebRequest.Proxy=myProxy;
    ***/ 

      // Create an instance of the RequestState and assign the previous myHttpWebRequest 
      // object to its request field.  
      RequestState myRequestState = new RequestState();  
      myRequestState.request = myHttpWebRequest;


      // Start the asynchronous request.
      IAsyncResult result=
        (IAsyncResult) myHttpWebRequest.BeginGetResponse(new AsyncCallback(RespCallback),myRequestState);

      // this line implements the timeout, if there is a timeout, the callback fires and the request becomes aborted
      ThreadPool.RegisterWaitForSingleObject (result.AsyncWaitHandle, new WaitOrTimerCallback(TimeoutCallback), myHttpWebRequest, DefaultTimeout, true);

      // The response came in the allowed time. The work processing will happen in the  
      // callback function.
      allDone.WaitOne();

      // Release the HttpWebResponse resource.
      myRequestState.response.Close();
    }
    catch(WebException e)
    {
      Console.WriteLine("\nMain Exception raised!");
      Console.WriteLine("\nMessage:{0}",e.Message);
      Console.WriteLine("\nStatus:{0}",e.Status);
      Console.WriteLine("Press any key to continue..........");
    }
    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 RespCallback(IAsyncResult asynchronousResult)
  {  
    try
    {
      // State of request is asynchronous.
      RequestState myRequestState=(RequestState) asynchronousResult.AsyncState;
      HttpWebRequest  myHttpWebRequest=myRequestState.request;
      myRequestState.response = (HttpWebResponse) myHttpWebRequest.EndGetResponse(asynchronousResult);

      // Read the response into a Stream object.
      Stream responseStream = myRequestState.response.GetResponseStream();
      myRequestState.streamResponse=responseStream;

      // Begin the Reading of the contents of the HTML page and print it to the console.
      IAsyncResult asynchronousInputRead = responseStream.BeginRead(myRequestState.BufferRead, 0, BUFFER_SIZE, new AsyncCallback(ReadCallBack), myRequestState);
      return;
    }
    catch(WebException e)
    {
      Console.WriteLine("\nRespCallback Exception raised!");
      Console.WriteLine("\nMessage:{0}",e.Message);
      Console.WriteLine("\nStatus:{0}",e.Status);
    }
    allDone.Set();
  }
  private static   void ReadCallBack(IAsyncResult asyncResult)
  {
    try
    {

    RequestState myRequestState = (RequestState)asyncResult.AsyncState;
    Stream responseStream = myRequestState.streamResponse;
    int read = responseStream.EndRead( asyncResult );
    // Read the HTML page and then print it to the console. 
    if (read > 0)
    {
      myRequestState.requestData.Append(Encoding.ASCII.GetString(myRequestState.BufferRead, 0, read));
      IAsyncResult asynchronousResult = responseStream.BeginRead( myRequestState.BufferRead, 0, BUFFER_SIZE, new AsyncCallback(ReadCallBack), myRequestState);
      return;
    }
    else
    {
      Console.WriteLine("\nThe contents of the Html page are : ");
      if(myRequestState.requestData.Length>1)
      {
        string stringContent;
        stringContent = myRequestState.requestData.ToString();
        Console.WriteLine(stringContent);
      }
      Console.WriteLine("Press any key to continue..........");
      Console.ReadLine();

      responseStream.Close();
    }

    }
    catch(WebException e)
    {
      Console.WriteLine("\nReadCallBack Exception raised!");
      Console.WriteLine("\nMessage:{0}",e.Message);
      Console.WriteLine("\nStatus:{0}",e.Status);
    }
    allDone.Set();

  }
#using <mscorlib.dll>
#using <System.dll>
using namespace System;
using namespace System::Net;
using namespace System::IO;
using namespace System::Text;
using namespace System::Threading;

public __gc class RequestState {
   // This class stores the State of the request.
   const int BUFFER_SIZE;
public:
   StringBuilder* requestData;
   Byte BufferRead[];
   HttpWebRequest* request;
   HttpWebResponse* response;
   Stream* streamResponse;

   RequestState() : BUFFER_SIZE(1024){
      BufferRead = new Byte[BUFFER_SIZE];
      requestData = new StringBuilder(S"");
      request = 0;
      streamResponse = 0;
   }
};

__gc class HttpWebRequest_BeginGetResponse {
public:
   static ManualResetEvent* allDone = new ManualResetEvent(false);
   static const int BUFFER_SIZE = 1024;
   static const int DefaultTimeOut = 120000;   // 2 minute timeout 

   // Abort the request if the timer fires.
   static void TimeoutCallback(Object* state, bool timedOut) {
      if (timedOut) {
         HttpWebRequest* request = dynamic_cast<HttpWebRequest*>(state);
         if (request != 0) {
            request->Abort();
         }
      }
   }

   static void RespCallback(IAsyncResult* asynchronousResult) {
      try {
         // State of request is asynchronous.
         RequestState* myRequestState=dynamic_cast<RequestState*> (asynchronousResult->AsyncState);
         HttpWebRequest*  myHttpWebRequest=myRequestState->request;
         myRequestState->response = dynamic_cast<HttpWebResponse*> 
            (myHttpWebRequest->EndGetResponse(asynchronousResult));

         // Read the response into a Stream object.
         Stream* responseStream = myRequestState->response->GetResponseStream();
         myRequestState->streamResponse=responseStream;

         // Begin the Reading of the contents of the HTML page and print it to the console.
         IAsyncResult* asynchronousInputRead = responseStream->BeginRead(
            myRequestState->BufferRead,
            0,
            BUFFER_SIZE,
            new AsyncCallback(0, ReadCallBack),
            myRequestState);
         return;
      } catch (WebException* e) {
         Console::WriteLine(S"\nRespCallback Exception raised!");
         Console::WriteLine(S"\nMessage: {0}", e->Message);
         Console::WriteLine(S"\nStatus: {0}", __box(e->Status));
      }
      allDone->Set();
   }

   static  void ReadCallBack(IAsyncResult* asyncResult) {
      try {

         RequestState * myRequestState = dynamic_cast<RequestState*>(asyncResult->AsyncState);
         Stream * responseStream = myRequestState->streamResponse;
         int read = responseStream->EndRead(asyncResult);
         // Read the HTML page and then print it to the console.
         if (read > 0) {
            myRequestState->requestData->Append(
               Encoding::ASCII->GetString(myRequestState->BufferRead, 0, read));
            IAsyncResult* asynchronousResult = responseStream->BeginRead(
               myRequestState->BufferRead,
               0,
               BUFFER_SIZE,
               new AsyncCallback(0, ReadCallBack),
               myRequestState);
            return;
         } else {
            Console::WriteLine(S"\nThe contents of the Html page are : ");
            if (myRequestState->requestData->Length>1) {
               String* stringContent;
               stringContent = myRequestState->requestData->ToString();
               Console::WriteLine(stringContent);
            }
            Console::WriteLine(S"Press any key to continue..........");
            Console::ReadLine();

            responseStream->Close();
         }

      } catch (WebException* e) {
         Console::WriteLine(S"\nReadCallBack Exception raised!");
         Console::WriteLine(S"\nMessage: {0}", e->Message);
         Console::WriteLine(S"\nStatus: {0}", __box(e->Status));
      }
      allDone->Set();
   }
};

int main() {

   try {
      // Create a HttpWebrequest object to the desired URL.
      HttpWebRequest * myHttpWebRequest= dynamic_cast<HttpWebRequest*>
         (WebRequest::Create(S"http://www.contoso.com"));

      /**
      * If you are behind a firewall and you do not have your browser proxy setup
      * you need to use the following proxy creation code.

      // Create a proxy object.
      WebProxy* myProxy = new WebProxy();

      // Associate a new Uri object to the _wProxy object, using the proxy address
      // selected by the user.
      myProxy.Address = new Uri(S"http://myproxy");

      // Finally, initialize the Web request object proxy property with the _wProxy
      // object.
      myHttpWebRequest.Proxy=myProxy;
      ***/

      // Create an instance of the RequestState and assign the previous myHttpWebRequest
      // object to its request field.
      RequestState* myRequestState = new RequestState();
      myRequestState->request = myHttpWebRequest;

      // Start the asynchronous request.
      IAsyncResult* result= dynamic_cast<IAsyncResult*>(myHttpWebRequest->BeginGetResponse(
         new AsyncCallback(0, HttpWebRequest_BeginGetResponse::RespCallback),
         myRequestState));

      // this line impliments the timeout, if there is a timeout, the callback fires and the request becomes aborted
      ThreadPool::RegisterWaitForSingleObject (
         result->AsyncWaitHandle,
         new WaitOrTimerCallback(0, HttpWebRequest_BeginGetResponse::TimeoutCallback),
         myHttpWebRequest,
         HttpWebRequest_BeginGetResponse::DefaultTimeOut,
         true);

      // The response came in the allowed time. The work processing will happen in the
      // callback function.
      HttpWebRequest_BeginGetResponse::allDone->WaitOne();

      // Release the HttpWebResponse resource.
      myRequestState->response->Close();
   } catch (WebException* e) {
      Console::WriteLine(S"\nMain Exception raised!");
      Console::WriteLine(S"\nMessage: {0}", e->Message);
      Console::WriteLine(S"\nStatus: {0}", __box(e->Status));
      Console::WriteLine(S"Press any key to continue..........");
   } catch (Exception* e) {
      Console::WriteLine(S"\nMain Exception raised!");
      Console::WriteLine(S"Source : {0} " , e->Source);
      Console::WriteLine(S"Message : {0} " , e->Message);
      Console::WriteLine(S"Press any key to continue..........");
      Console::Read();
   }
}

Windows 7, Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2008 R2, Windows Server 2008, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile for Smartphone, Windows Mobile for Pocket PC

The .NET Framework and .NET Compact Framework do not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

.NET Framework

Supported in: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Supported in: 3.5, 2.0, 1.0

Community Additions

ADD
Show:
© 2014 Microsoft