HttpWebRequest.BeginGetRequestStream(AsyncCallback, Object) Método

Definición

Inicia una solicitud asincrónica de un objeto Stream que se va a utilizar para escribir datos.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

Parámetros

callback
AsyncCallback

Delegado AsyncCallback.The AsyncCallback delegate.

state
Object

Objeto de estado de esta solicitud.The state object for this request.

Devoluciones

IAsyncResult que hace referencia a la solicitud asincrónica.An IAsyncResult that references the asynchronous request.

Excepciones

La propiedad Method es GET o HEAD.The Method property is GET or HEAD.

O bien-or- KeepAlive es true, AllowWriteStreamBuffering es false, ContentLength es -1, SendChunked es false y Method es POST o PUT.KeepAlive is true, AllowWriteStreamBuffering is false, ContentLength is -1, SendChunked is false, and Method is POST or PUT.

La secuencia ya la está usando una llamada anterior a BeginGetRequestStream(AsyncCallback, Object).The stream is being used by a previous call to BeginGetRequestStream(AsyncCallback, Object)

O bien-or- TransferEncoding se establece en un valor y SendChunked es false.TransferEncoding is set to a value and SendChunked is false.

O bien-or- El grupo de subprocesos se está quedando sin subprocesos.The thread pool is running out of threads.

El validador de caché de solicitud indicó que la respuesta para esta solicitud se puede atender desde la memoria caché; sin embargo, las solicitudes que escriben datos no deben usar la caché.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. Esta excepción puede producirse si usa un validador de caché personalizado que se implementa incorrectamente.This exception can occur if you are using a custom cache validator that is incorrectly implemented.

Se llamó a Abort() anteriormente.Abort() was previously called.

En una aplicación de .NET Compact Framework, no se obtuvo una secuencia de solicitud con longitud de contenido cero y se cerró correctamente.In a .NET Compact Framework application, a request stream with zero content length was not obtained and closed correctly. Para más información sobre cómo controlar solicitudes de longitud de contenido cero, vea Programación para redes en .NET Compact Framework.For more information about handling zero content length requests, see Network Programming in the .NET Compact Framework.

Ejemplos

En el ejemplo de código siguiente se usa el método BeginGetRequestStream para hacer una solicitud asincrónica de una instancia de Stream.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

Comentarios

El método BeginGetRequestStream inicia una solicitud asincrónica de una secuencia que se usa para enviar datos para el HttpWebRequest.The BeginGetRequestStream method starts an asynchronous request for a stream used to send data for the HttpWebRequest. El método de devolución de llamada asincrónico usa el método EndGetRequestStream para devolver el flujo real.The asynchronous callback method uses the EndGetRequestStream method to return the actual stream.

El método BeginGetRequestStream requiere que se completen algunas tareas de instalación sincrónica (por ejemplo, la resolución de DNS, la detección de proxy y la conexión de socket TCP) antes de que este método se vuelva asíncrono.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. Como resultado, nunca se debe llamar a este método en un subproceso de la interfaz de usuario, ya que puede tardar un tiempo considerable (hasta varios minutos según la configuración de red) para completar las tareas de instalación sincrónica inicial antes de que se produzca una excepción para un error. el método se ejecuta correctamente.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.

Para obtener más información sobre el grupo de subprocesos, vea el grupo de subprocesos administrados.To learn more about the thread pool, see The managed thread pool.

Nota

La aplicación no puede mezclar métodos sincrónicos y asincrónicos para una solicitud determinada.Your application cannot mix synchronous and asynchronous methods for a particular request. Si llama al método BeginGetRequestStream, debe utilizar el método BeginGetResponse para recuperar la respuesta.If you call the BeginGetRequestStream method, you must use the BeginGetResponse method to retrieve the response.

Nota

Este miembro genera información de seguimiento cuando se habilita el seguimiento de red en la aplicación.This member outputs trace information when you enable network tracing in your application. Para obtener más información, consulte seguimiento de red en el .NET Framework.For more information, see Network Tracing in the .NET Framework.

Se aplica a

Consulte también: