HttpWebRequest.BeginGetRequestStream(AsyncCallback, Object) Method

Definition

Démarre une requête asynchrone pour un objet Stream à utiliser pour écrire des données.Begins an asynchronous request for a Stream object to use to write data.

public:
 override IAsyncResult ^ BeginGetRequestStream(AsyncCallback ^ callback, System::Object ^ state);
public override IAsyncResult BeginGetRequestStream (AsyncCallback callback, object state);
override this.BeginGetRequestStream : AsyncCallback * obj -> IAsyncResult
Public Overrides Function BeginGetRequestStream (callback As AsyncCallback, state As Object) As IAsyncResult

Parameters

callback
AsyncCallback

Délégué AsyncCallback.The AsyncCallback delegate.

state
Object

Objet d'état de cette requête.The state object for this request.

Returns

IAsyncResult

Élément IAsyncResult qui référence la demande asynchrone.An IAsyncResult that references the asynchronous request.

Exceptions

La propriété Method est GET ou HEAD.The Method property is GET or HEAD.

-ou--or- KeepAlive est true, AllowWriteStreamBuffering est false, ContentLength a la valeur -1, SendChunked est false, et Method est POST ou PUT.KeepAlive is true, AllowWriteStreamBuffering is false, ContentLength is -1, SendChunked is false, and Method is POST or PUT.

Le flux est actuellement utilisé par un appel précédent à BeginGetRequestStream(AsyncCallback, Object)The stream is being used by a previous call to BeginGetRequestStream(AsyncCallback, Object)

-ou--or- TransferEncoding est défini sur une valeur, et SendChunked a pour valeur false.TransferEncoding is set to a value and SendChunked is false.

-ou--or- Le nombre de threads du pool de threads est insuffisant.The thread pool is running out of threads.

Le validateur du cache de demande a indiqué que la réponse à cette demande peut être obtenue à partir du cache. Toutefois, les demandes qui écrivent des données ne doivent pas utiliser le cache.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. Cette exception peut se produire si vous utilisez un validateur de cache personnalisé qui est implémenté de manière incorrecte.This exception can occur if you are using a custom cache validator that is incorrectly implemented.

Abort() a déjà été appelé.Abort() was previously called.

Dans une application .NET Compact Framework, un flux de requête avec une longueur de contenu nulle n’a pas été obtenu et s’est fermé correctement.In a .NET Compact Framework application, a request stream with zero content length was not obtained and closed correctly. Pour plus d’informations sur la gestion des requêtes avec une longueur de contenu nulle, consultez Programmation réseau dans le .NET Compact Framework.For more information about handling zero content length requests, see Network Programming in the .NET Compact Framework.

Examples

L’exemple de code suivant utilise la méthode BeginGetRequestStream pour effectuer une demande asynchrone d’une instance de flux.The following code example uses the BeginGetRequestStream method to make an asynchronous request for a stream instance.

#using <System.dll>

using namespace System;
using namespace System::Net;
using namespace System::IO;
using namespace System::Text;
using namespace System::Threading;
ref class HttpWebRequestBeginGetRequest
{
public:
   static ManualResetEvent^ allDone = gcnew ManualResetEvent( false );
   static void Main()
   {
      
      // Create a new HttpWebRequest object.
      HttpWebRequest^ request = dynamic_cast<HttpWebRequest^>(WebRequest::Create( "http://www.contoso.com/example.aspx" ));
      
      // Set the ContentType property.
      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.    
      AsyncCallback^ del = gcnew AsyncCallback(GetRequestStreamCallback);
      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. 
      allDone->WaitOne();
    }
      

private:
    static void GetRequestStreamCallback(IAsyncResult^ asynchronousResult)
    {
        HttpWebRequest^ request = dynamic_cast<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.
        array<Byte>^ByteArray = Encoding::UTF8->GetBytes(postData);

        // Write to the request stream.
        postStream->Write(ByteArray, 0, postData->Length);
        postStream->Close();

        // Start the asynchronous operation to get the response
        AsyncCallback^ del = gcnew AsyncCallback(GetResponseCallback);
        request->BeginGetResponse(del, request);
    }

   static void GetResponseCallback(IAsyncResult^ asynchronousResult)
   {
      HttpWebRequest^ request = dynamic_cast<HttpWebRequest^>(asynchronousResult->AsyncState);

      // End the operation
      HttpWebResponse^ response = dynamic_cast<HttpWebResponse^>(request->EndGetResponse(asynchronousResult));
      Stream^ streamResponse = response->GetResponseStream();
      StreamReader^ streamRead = gcnew StreamReader(streamResponse);
      String^ responseString = streamRead->ReadToEnd();
      Console::WriteLine(responseString);
      // Close the stream object
      streamResponse->Close();
      streamRead->Close();

      // Release the HttpWebResponse
      response->Close();
      allDone->Set();
   }
};

void main()
{
   HttpWebRequestBeginGetRequest::Main();
}

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("http://www.contoso.com/example.aspx");

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

    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);
        postStream.Close();

        // 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();
        Console.WriteLine(responseString);
        // Close the stream object
        streamResponse.Close();
        streamRead.Close();

        // Release the HttpWebResponse
        response.Close();
        allDone.Set();
    }
}
Imports System.Net
Imports System.IO
Imports System.Text
Imports System.Threading

Class HttpWebRequestBeginGetRequest
    Public Shared allDone As New ManualResetEvent(False)

    Shared Sub Main()


        ' Create a new HttpWebRequest object.
        Dim request As HttpWebRequest = CType(WebRequest.Create("http://www.contoso.com/example.aspx"), _
                 HttpWebRequest)

        ' Set the ContentType property.
        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.		
        Dim result As IAsyncResult = _
            CType(request.BeginGetRequestStream(AddressOf GetRequestStreamCallback, request), _
            IAsyncResult)

        ' 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. 
        allDone.WaitOne()
    End Sub

    Private Shared Sub GetRequestStreamCallback(ByVal asynchronousResult As IAsyncResult)
        Dim request As HttpWebRequest = CType(asynchronousResult.AsyncState, HttpWebRequest)
        
        ' End the operation
        Dim postStream As Stream = request.EndGetRequestStream(asynchronousResult)
        Console.WriteLine("Please enter the input data to be posted:")
        Dim postData As [String] = Console.ReadLine()
        
        '  Convert the string into byte array.
        Dim byteArray As Byte() = Encoding.UTF8.GetBytes(postData)

        ' Write to the stream.
        postStream.Write(byteArray, 0, postData.Length)
        postStream.Close()

        ' Start the asynchronous operation to get the response
        Dim result As IAsyncResult = _
            CType(request.BeginGetResponse(AddressOf GetResponseCallback, request), _
            IAsyncResult)
    End Sub

    Private Shared Sub GetResponseCallback(ByVal asynchronousResult As IAsyncResult)
        Dim request As HttpWebRequest = CType(asynchronousResult.AsyncState, HttpWebRequest)
        
        '  Get the response.
        Dim response As HttpWebResponse = CType(request.EndGetResponse(asynchronousResult), _
           HttpWebResponse)
        
        Dim streamResponse As Stream = response.GetResponseStream()
        Dim streamRead As New StreamReader(streamResponse)
        Dim responseString As String = streamRead.ReadToEnd()
        
        Console.WriteLine(responseString)
        
        ' Close Stream object.
        streamResponse.Close()
        streamRead.Close()

        ' Release the HttpWebResponse.
        allDone.Set()
        response.Close()
    End Sub
            
End Class

Remarks

La méthode BeginGetRequestStream démarre une demande asynchrone pour un flux utilisé pour envoyer des données pour le HttpWebRequest.The BeginGetRequestStream method starts an asynchronous request for a stream used to send data for the HttpWebRequest. La méthode de rappel asynchrone utilise la méthode EndGetRequestStream pour retourner le flux réel.The asynchronous callback method uses the EndGetRequestStream method to return the actual stream.

La méthode BeginGetRequestStream nécessite des tâches de configuration synchrones (résolution DNS, détection de proxy et connexion de socket TCP, par exemple) avant que cette méthode devienne asynchrone.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. Par conséquent, cette méthode ne doit jamais être appelée sur un thread d’interface utilisateur, car elle peut prendre beaucoup de temps (jusqu’à plusieurs minutes en fonction des paramètres réseau) pour effectuer les tâches d’installation synchrones initiales avant qu’une exception ne soit levée pour une erreur ou que la méthode aboutisse.As a result, this method should never be called on a user interface (UI) thread because it might take considerable time (up to several minutes depending on network settings) to complete the initial synchronous setup tasks before an exception for an error is thrown or the method succeeds.

Pour en savoir plus sur le pool de threads, consultez pool de threads managés.To learn more about the thread pool, see The managed thread pool.

Note

Votre application ne peut pas mélanger des méthodes synchrones et asynchrones pour une requête particulière.Your application cannot mix synchronous and asynchronous methods for a particular request. Si vous appelez la méthode BeginGetRequestStream, vous devez utiliser la méthode BeginGetResponse pour récupérer la réponse.If you call the BeginGetRequestStream method, you must use the BeginGetResponse method to retrieve the response.

Note

Ce membre génère des informations de traçage lorsque vous activez le traçage réseau dans votre application.This member outputs trace information when you enable network tracing in your application. Pour plus d’informations, consultez la page traçage réseau dans le .NET Framework.For more information, see Network Tracing in the .NET Framework.

Applies to

See also