FtpWebRequest.BeginGetResponse(AsyncCallback, Object) Méthode

Définition

Espace de noms:

System.Net

Assembly:

System.Net.Requests.dll

Source:

FtpWebRequest.cs

Commence à envoyer une demande et à recevoir une réponse d'un serveur FTP de façon asynchrone.

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

Paramètres

callback

AsyncCallback

Délégué AsyncCallback qui fait référence à la méthode à appeler quand l'opération est terminée.

state

Object

Objet défini par l'utilisateur qui comporte des informations sur l'opération. Cet objet est passé au délégué callback quand l'opération se termine.

Retours

IAsyncResult

Instance de IAsyncResult indiquant l'état de l'opération.

Exceptions

InvalidOperationException

GetResponse() ou BeginGetResponse(AsyncCallback, Object) a déjà été appelé pour cette instance.

Exemples

L’exemple de code suivant illustre la fin d’une opération asynchrone pour obtenir le flux d’une requête, puis le démarrage d’une demande pour obtenir la réponse. Cet exemple de code fait partie d’un exemple plus large fourni pour la vue d’ensemble de la 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;
    }
}

Remarques

Vous devez terminer l’opération asynchrone en appelant la EndGetResponse méthode . Généralement, EndGetResponse est appelé par la méthode référencée par callback. Pour déterminer l’état de l’opération, vérifiez les propriétés de l’objet IAsyncResult retourné par la BeginGetResponse méthode .

Si la Proxy propriété est définie, directement ou dans un fichier de configuration, les communications avec le serveur FTP sont effectuées via le proxy spécifié.

BeginGetResponse ne bloque pas en attendant la réponse du serveur. Pour bloquer, appelez la méthode à la GetResponse place de BeginGetResponse.

Pour plus d’informations sur l’utilisation du modèle de programmation asynchrone, consultez Appel de méthodes synchrones de manière asynchrone.

Ce membre génère des informations de traçage lorsque vous activez le traçage réseau dans votre application. Pour plus d’informations, consultez Suivi réseau dans .NET Framework.

Notes

Si un WebException est levée, utilisez les Response propriétés et Status de l’exception pour déterminer la réponse du serveur.

Notes pour les appelants

Cette méthode génère du trafic réseau.

Voir aussi

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