FtpWebRequest.BeginGetResponse(AsyncCallback, Object) Method

Reference

Definition

Namespace:: System.Net

Assembly:: System.Net.Requests.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Source:: FtpWebRequest.cs

Source:: FtpWebRequest.cs

Source:: FtpWebRequest.cs

Important

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

Begins sending a request and receiving a response from an FTP server asynchronously.

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

Parameters

callback: AsyncCallback

An AsyncCallback delegate that references the method to invoke when the operation is complete.

state: Object

A user-defined object that contains information about the operation. This object is passed to the callback delegate when the operation completes.

Returns

IAsyncResult

An IAsyncResult instance that indicates the status of the operation.

Exceptions

InvalidOperationException

GetResponse() or BeginGetResponse(AsyncCallback, Object) has already been called for this instance.

Examples

The following code example demonstrates ending an asynchronous operation to get a request's stream, and then starting a request to get the response. This code example is part of a larger example provided for the FtpWebRequest class overview.

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

Remarks

You must complete the asynchronous operation by calling the EndGetResponse method. Typically, EndGetResponse is called by the method referenced by callback. To determine the state of the operation, check the properties in the IAsyncResult object returned by the BeginGetResponse method.

If the Proxy property is set, either directly or in a configuration file, communications with the FTP server are made through the specified proxy.

BeginGetResponse does not block while waiting for the response from the server. To block, call the GetResponse method in place of BeginGetResponse.

For more information about using the asynchronous programming model, see Calling Synchronous Methods Asynchronously.

This member outputs trace information when you enable network tracing in your application. For more information, see Network Tracing in the .NET Framework.

Note

If a WebException is thrown, use the Response and Status properties of the exception to determine the response from the server.

Notes to Callers

This method generates network traffic.

Applies to

Jaa