FtpWebRequest.BeginGetResponse(AsyncCallback, Object) Methode

Referenz

Definition

Namespace:: System.Net

Assembly:: System.Net.Requests.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Quelle:: FtpWebRequest.cs

Quelle:: FtpWebRequest.cs

Quelle:: FtpWebRequest.cs

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Beginnt mit dem asynchronen Senden einer Anforderung und Empfangen einer Antwort von einem FTP-Server.

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

Parameter

callback: AsyncCallback

Ein AsyncCallback-Delegat, der auf die Methode verweist, die bei Abschluss des Vorgangs aufgerufen werden soll.

state: Object

Ein benutzerdefiniertes Objekt, das Informationen über den Vorgang enthält. Dieses Objekt wird bei Abschluss des Vorgangs an den callback-Delegaten übergeben.

Gibt zurück

IAsyncResult

Eine IAsyncResult-Instanz, die den Status des Vorgangs angibt.

Ausnahmen

InvalidOperationException

GetResponse() oder BeginGetResponse(AsyncCallback, Object) wurde bereits für diese Instanz aufgerufen.

Beispiele

Das folgende Codebeispiel veranschaulicht das Beenden eines asynchronen Vorgangs zum Abrufen des Datenstroms einer Anforderung und anschließendes Starten einer Anforderung zum Abrufen der Antwort. Dieses Codebeispiel ist Teil eines größeren Beispiels für die FtpWebRequest Klassenübersicht.

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

Hinweise

Sie müssen den asynchronen Vorgang abschließen, indem Sie die EndGetResponse -Methode aufrufen. Wird in der Regel von der -Methode aufgerufen, EndGetResponse auf die von verwiesen wird callback. Um den Status des Vorgangs zu bestimmen, überprüfen Sie die Eigenschaften im Objekt, das IAsyncResult von der BeginGetResponse -Methode zurückgegeben wird.

Wenn die Proxy Eigenschaft entweder direkt oder in einer Konfigurationsdatei festgelegt ist, erfolgt die Kommunikation mit dem FTP-Server über den angegebenen Proxy.

BeginGetResponse blockiert nicht, während auf die Antwort vom Server gewartet wird. Rufen Sie zum Blockieren die GetResponse -Methode anstelle von auf BeginGetResponse.

Weitere Informationen zur Verwendung des asynchronen Programmiermodells finden Sie unter Asynchrones Aufrufen synchroner Methoden.

Dieser Member gibt Ablaufverfolgungsinformationen aus, wenn Sie die Netzwerkablaufverfolgung in der Anwendung aktivieren. Weitere Informationen finden Sie unter Netzwerkablaufverfolgung in .NET Framework.

Hinweis

Wenn ein WebException ausgelöst wird, verwenden Sie die Response Eigenschaften und Status der Ausnahme, um die Antwort vom Server zu bestimmen.

Hinweise für Aufrufer

Diese Methode generiert Netzwerkdatenverkehr.

Gilt für:

Freigeben über