This documentation is archived and is not being maintained.

HttpWebRequest.BeginGetRequestStream Method

Begins an asynchronous request for a Stream object to use to write data.

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

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


Type: System.AsyncCallback

The AsyncCallback delegate.

Type: System.Object

The state object for this request.

Return Value

Type: System.IAsyncResult
An IAsyncResult that references the asynchronous request.


The Method property is GET or HEAD.


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


The stream is being used by a previous call to BeginGetRequestStream


TransferEncoding is set to a value and SendChunked is false.


The thread pool is running out of threads.


The request cache validator indicated that the response for this request can be served from the cache; however, requests that write data must not use the cache. This exception can occur if you are using a custom cache validator that is incorrectly implemented.


Abort was previously called.


In a .NET Compact Framework application, a request stream with zero content length was not obtained and closed correctly. For more information about handling zero content length requests, see Network Programming in the .NET Compact Framework.


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 BeginGetRequestStream method starts an asynchronous request for a stream used to send data for the HttpWebRequest. The asynchronous callback method uses the EndGetRequestStream method to return the actual stream.

The BeginGetRequestStream 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.


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.


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 BeginGetRequestStream method to make an asynchronous request for a stream instance.

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

class HttpWebRequestBeginGetRequest
    private static ManualResetEvent allDone = new ManualResetEvent(false);

    public static void Main(string[] args)

        // Create a new HttpWebRequest object.
        HttpWebRequest request = (HttpWebRequest)WebRequest.Create("");

        request.ContentType = "application/x-www-form-urlencoded";

        // Set the Method property to 'POST' to post data to the URI.
        request.Method = "POST";

        // start the asynchronous operation
        request.BeginGetRequestStream(new AsyncCallback(GetRequestStreamCallback), request);

        // Keep the main thread from continuing while the asynchronous 
        // operation completes. A real world application 
        // could do something useful such as updating its user interface. 

    private static void GetRequestStreamCallback(IAsyncResult asynchronousResult)
        HttpWebRequest request = (HttpWebRequest)asynchronousResult.AsyncState;

        // End the operation
        Stream postStream = request.EndGetRequestStream(asynchronousResult);

        Console.WriteLine("Please enter the input data to be posted:");
        string postData = Console.ReadLine();

        // Convert the string into a byte array.
        byte[] byteArray = Encoding.UTF8.GetBytes(postData);

        // Write to the request stream.
        postStream.Write(byteArray, 0, postData.Length);

        // Start the asynchronous operation to get the response
        request.BeginGetResponse(new AsyncCallback(GetResponseCallback), request);

    private static void GetResponseCallback(IAsyncResult asynchronousResult)
        HttpWebRequest request = (HttpWebRequest)asynchronousResult.AsyncState;

        // End the operation
        HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(asynchronousResult);
        Stream streamResponse = response.GetResponseStream();
        StreamReader streamRead = new StreamReader(streamResponse);
        string responseString = streamRead.ReadToEnd();
        // Close the stream object

        // Release the HttpWebResponse
#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;

__gc class HttpWebRequestBeginGetRequest {
   static ManualResetEvent* allDone = new ManualResetEvent(false);

	static void Main() {

        // Create a new HttpWebRequest object.
        HttpWebRequest* request =
    dynamic_cast<HttpWebRequest*> (WebRequest::Create(S""));
        // Set the ContentType property.
        // Set the Method property to 'POST' to post data to the Uri.

        // Start the asynchronous operation.    
		AsyncCallback* del = 	new AsyncCallback(0,ReadCallback);
        request->BeginGetRequestStream(del, request);

        // Keep the main thread from continuing while the asynchronous
        // operation completes. A real world application
        // could do something useful such as updating its user interface. 
        HttpWebResponse* response =
        Stream* streamResponse =
        StreamReader* streamRead = new StreamReader(streamResponse);
        String *responseString = streamRead->ReadToEnd();
        // Close Stream object.

        // Release the HttpWebResponse.
   static void ReadCallback(IAsyncResult* asynchronousResult) 
         HttpWebRequest * request =
            dynamic_cast<HttpWebRequest*> (asynchronousResult->AsyncState);
		 // End the operation.
         Stream* postStream = request->EndGetRequestStream(asynchronousResult);
         Console::WriteLine(S"Please enter the input data to be posted:");
         String * postData = Console::ReadLine();

         // Convert the string into Byte array.
		 Byte ByteArray[] = Encoding::UTF8->GetBytes(postData);
         // Write to the request stream.
         postStream->Write(ByteArray, 0, postData->Length);


void main()

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