FtpWebRequest.BeginGetResponse(AsyncCallback, Object) Método

Referência

Definição

Namespace:: System.Net

Assembly:: System.Net.Requests.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Origem:: FtpWebRequest.cs

Origem:: FtpWebRequest.cs

Origem:: FtpWebRequest.cs

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Começa a enviar uma solicitação e receber uma resposta de um servidor FTP de maneira assíncrona.

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

public override IAsyncResult BeginGetResponse (AsyncCallback? callback, 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

Um delegado AsyncCallback que faz referência ao método a ser invocado quando a operação é concluída.

state: Object

Um objeto definido pelo usuário que contém informações sobre a operação. Esse objeto é passado para o representante callback quando a operação é concluída.

Retornos

IAsyncResult

Um instância de IAsyncResult que indica o status da operação.

Exceções

InvalidOperationException

GetResponse() ou BeginGetResponse(AsyncCallback, Object) já foi chamado para essa instância.

Exemplos

O exemplo de código a seguir demonstra o fim de uma operação assíncrona para obter o fluxo de uma solicitação e, em seguida, iniciar uma solicitação para obter a resposta. Este exemplo de código faz parte de um exemplo maior fornecido para a visão geral da FtpWebRequest classe.

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;
    }
}

Comentários

Você deve concluir a operação assíncrona chamando o EndGetResponse método . Normalmente, EndGetResponse é chamado pelo método referenciado por callback. Para determinar o estado da operação, verifique as propriedades no IAsyncResult objeto retornado pelo BeginGetResponse método .

Se a Proxy propriedade estiver definida, diretamente ou em um arquivo de configuração, as comunicações com o servidor FTP serão feitas por meio do proxy especificado.

BeginGetResponse não bloqueia enquanto aguarda a resposta do servidor. Para bloquear, chame o GetResponse método no lugar de BeginGetResponse.

Para obter mais informações sobre como usar o modelo de programação assíncrona, consulte Chamando métodos síncronos de forma assíncrona.

Esse membro emite o rastreamento de informações quando você ativa o rastreamento de rede em seu aplicativo. Para obter mais informações, consulte Rastreamento de rede no .NET Framework.

Observação

Se um WebException for gerado, use as Response propriedades e Status da exceção para determinar a resposta do servidor.

Notas aos Chamadores

Esse método gera tráfego de rede.

Aplica-se a

Partilhar via