FtpWebRequest.BeginGetResponse(AsyncCallback, Object) Método

Definición

Espacio de nombres:

System.Net

Ensamblado:

System.Net.Requests.dll

Source:

FtpWebRequest.cs

Empieza enviando una solicitud y recibiendo de forma asincrónica una respuesta de un servidor FTP.

public:
 override IAsyncResult ^ BeginGetResponse(AsyncCallback ^ callback, System::Object ^ state);

public override IAsyncResult BeginGetResponse (AsyncCallback? callback, object? state);

override this.BeginGetResponse : AsyncCallback * obj -> IAsyncResult

Public Overrides Function BeginGetResponse (callback As AsyncCallback, state As Object) As IAsyncResult

Parámetros

callback

AsyncCallback

Delegado de AsyncCallback que hace referencia al método que se invocará cuando la operación se complete.

state

Object

Objeto definido por el usuario que contiene información sobre la operación. Este objeto se pasa al delegado de callback cuando la operación ha terminado.

Devoluciones

IAsyncResult

Instancia IAsyncResult que indica el estado de la operación.

Excepciones

InvalidOperationException

Ya se ha llamado a GetResponse() o BeginGetResponse(AsyncCallback, Object) para esta instancia.

Ejemplos

En el ejemplo de código siguiente se muestra cómo finalizar una operación asincrónica para obtener la secuencia de una solicitud y, a continuación, iniciar una solicitud para obtener la respuesta. Este ejemplo de código forma parte de un ejemplo más grande proporcionado para la información general de la FtpWebRequest clase.

private:
   static void EndGetStreamCallback( IAsyncResult^ ar )
   {
      FtpState^ state = dynamic_cast<FtpState^>(ar->AsyncState);
      Stream^ requestStream = nullptr;

      // End the asynchronous call to get the request stream.
      try
      {
         requestStream = state->Request->EndGetRequestStream( ar );

         // Copy the file contents to the request stream.
         const int bufferLength = 2048;
         array<Byte>^buffer = gcnew array<Byte>(bufferLength);
         int count = 0;
         int readBytes = 0;
         FileStream^ stream = File::OpenRead( state->FileName );
         do
         {
            readBytes = stream->Read( buffer, 0, bufferLength );
            requestStream->Write( buffer, 0, bufferLength );
            count += readBytes;
         }
         while ( readBytes != 0 );
         Console::WriteLine( "Writing {0} bytes to the stream.", count );

         // IMPORTANT: Close the request stream before sending the request.
         requestStream->Close();

         // Asynchronously get the response to the upload request.
         state->Request->BeginGetResponse( gcnew AsyncCallback( EndGetResponseCallback ), state );
      }
      // Return exceptions to the main application thread.
      catch ( Exception^ e ) 
      {
         Console::WriteLine( "Could not get the request stream." );
         state->OperationException = e;
         state->OperationComplete->Set();
         return;
      }
   }

private static void EndGetStreamCallback(IAsyncResult ar)
{
    FtpState state = (FtpState) ar.AsyncState;

    Stream requestStream = null;
    // End the asynchronous call to get the request stream.
    try
    {
        requestStream = state.Request.EndGetRequestStream(ar);
        // Copy the file contents to the request stream.
        const int bufferLength = 2048;
        byte[] buffer = new byte[bufferLength];
        int count = 0;
        int readBytes = 0;
        FileStream stream = File.OpenRead(state.FileName);
        do
        {
            readBytes = stream.Read(buffer, 0, bufferLength);
            requestStream.Write(buffer, 0, readBytes);
            count += readBytes;
        }
        while (readBytes != 0);
        Console.WriteLine ("Writing {0} bytes to the stream.", count);
        // IMPORTANT: Close the request stream before sending the request.
        requestStream.Close();
        // Asynchronously get the response to the upload request.
        state.Request.BeginGetResponse(
            new AsyncCallback (EndGetResponseCallback),
            state
        );
    }
    // Return exceptions to the main application thread.
    catch (Exception e)
    {
        Console.WriteLine("Could not get the request stream.");
        state.OperationException = e;
        state.OperationComplete.Set();
        return;
    }
}

Comentarios

Debe completar la operación asincrónica llamando al EndGetResponse método . Normalmente, EndGetResponse se llama mediante el método al que callbackhace referencia . Para determinar el estado de la operación, compruebe las propiedades del IAsyncResult objeto devuelto por el BeginGetResponse método .

Si se establece la Proxy propiedad, ya sea directamente o en un archivo de configuración, las comunicaciones con el servidor FTP se realizan a través del proxy especificado.

BeginGetResponse no se bloquea mientras espera la respuesta del servidor. Para bloquear, llame al GetResponse método en lugar de BeginGetResponse.

Para obtener más información sobre el uso del modelo de programación asincrónica, vea Llamar a métodos sincrónicos de forma asincrónica.

Este miembro genera información de seguimiento cuando se habilita el seguimiento de red en la aplicación. Para obtener más información, vea Seguimiento de red en .NET Framework.

Nota

Si se produce una WebException excepción , use las Response propiedades y Status de la excepción para determinar la respuesta del servidor.

Notas a los autores de las llamadas

Este método genera tráfico de red.

Consulte también

• FtpWebResponse
• FtpStatusCode
• WebRequestMethods.Ftp
• WebRequest
• WebResponse
• WebClient