FtpWebRequest Klasa

Definicja

Implementuje klienta protokół transferu plików (FTP).Implements a File Transfer Protocol (FTP) client.

public ref class FtpWebRequest sealed : System::Net::WebRequest
public sealed class FtpWebRequest : System.Net.WebRequest
type FtpWebRequest = class
    inherit WebRequest
Public NotInheritable Class FtpWebRequest
Inherits WebRequest
Dziedziczenie
FtpWebRequest
Dziedziczenie

Przykłady

Poniższy przykład kodu demonstruje usunięcie pliku z serwera FTP.The following code example demonstrates deleting a file from an FTP server.

static bool DeleteFileOnServer( Uri^ serverUri )
{
   // The serverUri parameter should use the ftp:// scheme.
   // It contains the name of the server file that is to be deleted.
   // Example: ftp://contoso.com/someFile.txt.
   // 
   if ( serverUri->Scheme != Uri::UriSchemeFtp )
   {
      return false;
   }

   // Get the object used to communicate with the server.
   FtpWebRequest^ request = dynamic_cast<FtpWebRequest^>(WebRequest::Create( serverUri ));
   request->Method = WebRequestMethods::Ftp::DeleteFile;
   FtpWebResponse^ response = dynamic_cast<FtpWebResponse^>(request->GetResponse());
   Console::WriteLine( "Delete status: {0}", response->StatusDescription );
   response->Close();
   return true;
}
public static bool DeleteFileOnServer(Uri serverUri)
{
    // The serverUri parameter should use the ftp:// scheme.
    // It contains the name of the server file that is to be deleted.
    // Example: ftp://contoso.com/someFile.txt.
    //

    if (serverUri.Scheme != Uri.UriSchemeFtp)
    {
        return false;
    }
    // Get the object used to communicate with the server.
    FtpWebRequest request = (FtpWebRequest)WebRequest.Create(serverUri);
    request.Method = WebRequestMethods.Ftp.DeleteFile;

    FtpWebResponse response = (FtpWebResponse) request.GetResponse();
    Console.WriteLine("Delete status: {0}",response.StatusDescription);
    response.Close();
    return true;
}

Poniższy przykład kodu demonstruje pobieranie pliku z serwera FTP przy użyciu WebClient klasy.The following code example demonstrates downloading a file from an FTP server by using the WebClient class.

static bool DisplayFileFromServer( Uri^ serverUri )
{
   // The serverUri parameter should start with the ftp:// scheme.
   if ( serverUri->Scheme != Uri::UriSchemeFtp )
   {
      return false;
   }

   // Get the object used to communicate with the server.
   WebClient^ request = gcnew WebClient;

   // This example assumes the FTP site uses anonymous logon.
   request->Credentials = gcnew NetworkCredential( "anonymous","janeDoe@contoso.com" );
   try
   {
      array<Byte>^newFileData = request->DownloadData( serverUri->ToString() );
      String^ fileString = System::Text::Encoding::UTF8->GetString( newFileData );
      Console::WriteLine( fileString );
   }
   catch ( WebException^ e ) 
   {
      Console::WriteLine( e );
   }

   return true;
}
public static bool DisplayFileFromServer(Uri serverUri)
{
    // The serverUri parameter should start with the ftp:// scheme.
    if (serverUri.Scheme != Uri.UriSchemeFtp)
    {
        return false;
    }
    // Get the object used to communicate with the server.
    WebClient request = new WebClient();

    // This example assumes the FTP site uses anonymous logon.
    request.Credentials = new NetworkCredential ("anonymous","janeDoe@contoso.com");
    try
    {
        byte [] newFileData = request.DownloadData (serverUri.ToString());
        string fileString = System.Text.Encoding.UTF8.GetString(newFileData);
        Console.WriteLine(fileString);
    }
    catch (WebException e)
    {
        Console.WriteLine(e.ToString());
    }
    return true;
}

Poniższy przykład kodu demonstruje użycie operacji asynchronicznych w celu przekazania pliku do serwera FTP.The following code example demonstrates using asynchronous operations to upload a file to an FTP server.

#using <System.dll>

using namespace System;
using namespace System::Net;
using namespace System::Threading;
using namespace System::IO;

public ref class FtpState
{
private:
   ManualResetEvent^ wait;
   FtpWebRequest^ request;
   String^ fileName;
   Exception^ operationException;
   String^ status;

public:
   FtpState()
   {
      wait = gcnew ManualResetEvent( false );
   }

   property ManualResetEvent^ OperationComplete 
   {
      ManualResetEvent^ get()
      {
         return wait;
      }

   }

   property FtpWebRequest^ Request 
   {
      FtpWebRequest^ get()
      {
         return request;
      }

      void set( FtpWebRequest^ value )
      {
         request = value;
      }

   }

   property String^ FileName 
   {
      String^ get()
      {
         return fileName;
      }

      void set( String^ value )
      {
         fileName = value;
      }

   }

   property Exception^ OperationException 
   {
      Exception^ get()
      {
         return operationException;
      }

      void set( Exception^ value )
      {
         operationException = value;
      }

   }

   property String^ StatusDescription 
   {
      String^ get()
      {
         return status;
      }

      void set( String^ value )
      {
         status = value;
      }

   }
};

public ref class AsynchronousFtpUpLoader
{
public:

   // Command line arguments are two strings:
   // 1. The url that is the name of the file being uploaded to the server.
   // 2. The name of the file on the local machine.
   //
   static void Main()
   {
      array<String^>^args = Environment::GetCommandLineArgs();

      // Create a Uri instance with the specified URI string.
      // If the URI is not correctly formed, the Uri constructor
      // will throw an exception.
      ManualResetEvent^ waitObject;
      Uri^ target = gcnew Uri( args[ 1 ] );
      String^ fileName = args[ 2 ];
      FtpState^ state = gcnew FtpState;
      FtpWebRequest ^ request = dynamic_cast<FtpWebRequest^>(WebRequest::Create( target ));
      request->Method = WebRequestMethods::Ftp::UploadFile;

      // This example uses anonymous logon.
      // The request is anonymous by default; the credential does not have to be specified. 
      // The example specifies the credential only to
      // control how actions are logged on the server.
      request->Credentials = gcnew NetworkCredential( "anonymous","janeDoe@contoso.com" );

      // Store the request in the object that we pass into the
      // asynchronous operations.
      state->Request = request;
      state->FileName = fileName;

      // Get the event to wait on.
      waitObject = state->OperationComplete;

      // Asynchronously get the stream for the file contents.
      request->BeginGetRequestStream( gcnew AsyncCallback( EndGetStreamCallback ), state );

      // Block the current thread until all operations are complete.
      waitObject->WaitOne();

      // The operations either completed or threw an exception.
      if ( state->OperationException != nullptr )
      {
         throw state->OperationException;
      }
      else
      {
         Console::WriteLine( "The operation completed - {0}", state->StatusDescription );
      }
   }

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

   // The EndGetResponseCallback method  
   // completes a call to BeginGetResponse.
   static void EndGetResponseCallback( IAsyncResult^ ar )
   {
      FtpState^ state = dynamic_cast<FtpState^>(ar->AsyncState);
      FtpWebResponse ^ response = nullptr;
      try
      {
         response = dynamic_cast<FtpWebResponse^>(state->Request->EndGetResponse( ar ));
         response->Close();
         state->StatusDescription = response->StatusDescription;

         // Signal the main application thread that 
         // the operation is complete.
         state->OperationComplete->Set();
      }
      // Return exceptions to the main application thread.
      catch ( Exception^ e ) 
      {
         Console::WriteLine( "Error getting response." );
         state->OperationException = e;
         state->OperationComplete->Set();
      }
   }
};

int main()
{
   AsynchronousFtpUpLoader::Main();
}
using System;
using System.Net;
using System.Threading;

using System.IO;
namespace Examples.System.Net
{
    public class FtpState
    {
        private ManualResetEvent wait;
        private FtpWebRequest request;
        private string fileName;
        private Exception operationException = null;
        string status;

        public FtpState()
        {
            wait = new ManualResetEvent(false);
        }

        public ManualResetEvent OperationComplete
        {
            get {return wait;}
        }

        public FtpWebRequest Request
        {
            get {return request;}
            set {request = value;}
        }

        public string FileName
        {
            get {return fileName;}
            set {fileName = value;}
        }
        public Exception OperationException
        {
            get {return operationException;}
            set {operationException = value;}
        }
        public string StatusDescription
        {
            get {return status;}
            set {status = value;}
        }
    }
    public class AsynchronousFtpUpLoader
    {
        // Command line arguments are two strings:
        // 1. The url that is the name of the file being uploaded to the server.
        // 2. The name of the file on the local machine.
        //
        public static void Main(string[] args)
        {
            // Create a Uri instance with the specified URI string.
            // If the URI is not correctly formed, the Uri constructor
            // will throw an exception.
            ManualResetEvent waitObject;

            Uri target = new Uri (args[0]);
            string fileName = args[1];
            FtpState state = new FtpState();
            FtpWebRequest request = (FtpWebRequest)WebRequest.Create(target);
            request.Method = WebRequestMethods.Ftp.UploadFile;

            // This example uses anonymous logon.
            // The request is anonymous by default; the credential does not have to be specified.
            // The example specifies the credential only to
            // control how actions are logged on the server.

            request.Credentials = new NetworkCredential ("anonymous","janeDoe@contoso.com");

            // Store the request in the object that we pass into the
            // asynchronous operations.
            state.Request = request;
            state.FileName = fileName;

            // Get the event to wait on.
            waitObject = state.OperationComplete;

            // Asynchronously get the stream for the file contents.
            request.BeginGetRequestStream(
                new AsyncCallback (EndGetStreamCallback),
                state
            );

            // Block the current thread until all operations are complete.
            waitObject.WaitOne();

            // The operations either completed or threw an exception.
            if (state.OperationException != null)
            {
                throw state.OperationException;
            }
            else
            {
                Console.WriteLine("The operation completed - {0}", state.StatusDescription);
            }
        }
        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;
            }
        }

        // The EndGetResponseCallback method
        // completes a call to BeginGetResponse.
        private static void EndGetResponseCallback(IAsyncResult ar)
        {
            FtpState state = (FtpState) ar.AsyncState;
            FtpWebResponse response = null;
            try
            {
                response = (FtpWebResponse) state.Request.EndGetResponse(ar);
                response.Close();
                state.StatusDescription = response.StatusDescription;
                // Signal the main application thread that
                // the operation is complete.
                state.OperationComplete.Set();
            }
            // Return exceptions to the main application thread.
            catch (Exception e)
            {
                Console.WriteLine ("Error getting response.");
                state.OperationException = e;
                state.OperationComplete.Set();
            }
        }
    }
}

Uwagi

Ważne

Nie zalecamy używania FtpWebRequest klasy do nowych celów programistycznych.We don't recommend that you use the FtpWebRequest class for new development. Aby uzyskać więcej informacji i dowiedzieć się więcej na FtpWebRequest temat, zobacz WebRequest nie należy używać w serwisie GitHub.For more information and alternatives to FtpWebRequest, see WebRequest shouldn't be used on GitHub.

Aby uzyskać wystąpienie klasy FtpWebRequest , należy użyć Create metody.To obtain an instance of FtpWebRequest, use the Create method. Można również użyć WebClient klasy do przekazywania i pobierania informacji z serwera FTP.You can also use the WebClient class to upload and download information from an FTP server. Przy użyciu jednej z tych metod, gdy określisz zasób sieciowy korzystający ze schematu FTP (na przykład "ftp://contoso.com" ), FtpWebRequest Klasa zapewnia możliwość programowego współdziałania z serwerami FTP.Using either of these approaches, when you specify a network resource that uses the FTP scheme (for example, "ftp://contoso.com") the FtpWebRequest class provides the ability to programmatically interact with FTP servers.

Identyfikator URI może być względny lub bezwzględny.The URI may be relative or absolute. Jeśli identyfikator URI ma postać "ftp://contoso.com/%2fpath" (% 2F jest znakiem ucieczki "/"), identyfikator URI jest bezwzględny i bieżącym katalogiem jest /path .If the URI is of the form "ftp://contoso.com/%2fpath" (%2f is an escaped '/'), then the URI is absolute, and the current directory is /path. Jeśli jednak identyfikator URI ma postać "ftp://contoso.com/path" , najpierw usługa .NET Framework loguje się do serwera FTP (przy użyciu nazwy użytkownika i hasła ustawionej przez Credentials Właściwość), a następnie bieżący katalog jest ustawiony na <UserLoginDirectory>/path .If, however, the URI is of the form "ftp://contoso.com/path", first the .NET Framework logs into the FTP server (using the user name and password set by the Credentials property), then the current directory is set to <UserLoginDirectory>/path.

Wymagana jest prawidłowa nazwa użytkownika i hasło dla serwera lub serwer musi zezwalać na Logowanie anonimowe.You must have a valid user name and password for the server or the server must allow anonymous logon. Możesz określić poświadczenia używane do nawiązania połączenia z serwerem przez ustawienie Credentials właściwości lub można je uwzględnić w UserInfo części identyfikatora URI przesłanej do Create metody.You can specify the credentials used to connect to the server by setting the Credentials property or you can include them in the UserInfo portion of the URI passed to the Create method. W przypadku uwzględnienia UserInfo informacji w identyfikatorze URI Credentials Właściwość jest ustawiana na nowe poświadczenie sieci przy użyciu określonej nazwy użytkownika i hasła.If you include UserInfo information in the URI, the Credentials property is set to a new network credential with the specified user name and password information.

Przestroga

O ile EnableSsl Właściwość nie jest true , wszystkie dane i polecenia, w tym informacje o nazwie użytkownika i haśle, są wysyłane do serwera w postaci zwykłego tekstu.Unless the EnableSsl property is true, all data and commands, including your user name and password information, are sent to the server in clear text. Każdy może monitorować ruch sieciowy i używać ich do łączenia się z serwerem.Anyone monitoring network traffic can view your credentials and use them to connect to the server. W przypadku łączenia się z serwerem FTP, który wymaga poświadczeń i obsługuje Secure Sockets Layer (SSL), należy ustawić EnableSsl na wartość true .If you are connecting to an FTP server that requires credentials and supports Secure Sockets Layer (SSL), you should set EnableSsl to true.

Musisz mieć WebPermission dostęp do zasobu FTP; w przeciwnym razie SecurityException jest zgłaszany wyjątek.You must have WebPermission to access the FTP resource; otherwise, a SecurityException exception is thrown.

Określ polecenie FTP do wysłania do serwera przez ustawienie Method właściwości na wartość zdefiniowaną w WebRequestMethods.Ftp strukturze.Specify the FTP command to send to the server by setting the Method property to a value defined in the WebRequestMethods.Ftp structure. Aby przesłać dane tekstowe, należy zmienić UseBinary wartość domyślną właściwości ( true ) na false .To transmit text data, change the UseBinary property from its default value (true) to false. Aby uzyskać szczegółowe informacje i ograniczenia, zobacz Method .For details and restrictions, see Method.

W przypadku użycia FtpWebRequest obiektu do przekazania pliku na serwer należy napisać zawartość pliku do strumienia żądania uzyskanego przez wywołanie GetRequestStream metody lub jej odpowiedników asynchronicznych, BeginGetRequestStream EndGetRequestStream metod i.When using an FtpWebRequest object to upload a file to a server, you must write the file content to the request stream obtained by calling the GetRequestStream method or its asynchronous counterparts, the BeginGetRequestStream and EndGetRequestStream methods. Musisz zapisać w strumieniu i zamknąć strumień przed wysłaniem żądania.You must write to the stream and close the stream before sending the request.

Żądania są wysyłane do serwera przez wywołanie GetResponse metody lub jej odpowiedników asynchronicznych, BeginGetResponse EndGetResponse metod i.Requests are sent to the server by calling the GetResponse method or its asynchronous counterparts, the BeginGetResponse and EndGetResponse methods. Gdy żądana operacja zostanie ukończona, FtpWebResponse zwracany jest obiekt.When the requested operation completes, an FtpWebResponse object is returned. FtpWebResponseObiekt zawiera stan operacji i wszystkie dane pobrane z serwera.The FtpWebResponse object provides the status of the operation and any data downloaded from the server.

Możesz ustawić wartość limitu czasu dla odczytu lub zapisu na serwerze przy użyciu ReadWriteTimeout właściwości.You can set a time-out value for reading or writing to the server by using the ReadWriteTimeout property. W przypadku przekroczenia limitu czasu Metoda wywołująca generuje element WebException z WebExceptionStatus ustawionym na Timeout .If the time-out period is exceeded, the calling method throws a WebException with WebExceptionStatus set to Timeout.

W przypadku pobierania pliku z serwera FTP, jeśli polecenie zakończyło się pomyślnie, zawartość żądanego pliku jest dostępna w strumieniu obiektu odpowiedzi.When downloading a file from an FTP server, if the command was successful, the contents of the requested file are available in the response object's stream. Możesz uzyskać dostęp do tego strumienia, wywołując GetResponseStream metodę.You can access this stream by calling the GetResponseStream method. Aby uzyskać więcej informacji, zobacz FtpWebResponse.For more information, see FtpWebResponse.

Jeśli Proxy Właściwość jest ustawiona, bezpośrednio lub w pliku konfiguracji, komunikacja z serwerem FTP odbywa się za pośrednictwem określonego serwera proxy.If the Proxy property is set, either directly or in a configuration file, communications with the FTP server are made through the specified proxy. Jeśli określony serwer proxy jest serwerem proxy HTTP, DownloadFile ListDirectory ListDirectoryDetails obsługiwane są tylko polecenia, i.If the specified proxy is an HTTP proxy, only the DownloadFile, ListDirectory, and ListDirectoryDetails commands are supported.

Tylko pobrana zawartość binarna jest buforowana; oznacza to, że zawartość odebrana przy użyciu DownloadFile polecenia z UseBinary właściwością ustawioną na true .Only downloaded binary content is cached; that is, content received using the DownloadFile command with the UseBinary property set to true.

Wiele FtpWebRequest s ponownie Użyj istniejących połączeń, jeśli jest to możliwe.Multiple FtpWebRequests reuse existing connections, if possible.

Aby uzyskać więcej informacji na temat protokołu FTP, zobacz RFC 959: protokół transferu plików.For more information about the FTP protocol, see RFC 959: File Transfer Protocol.

Właściwości

AuthenticationLevel

Pobiera lub ustawia wartości wskazujące poziom uwierzytelniania i personifikacji używany dla tego żądania.Gets or sets values indicating the level of authentication and impersonation used for this request.

(Odziedziczone po WebRequest)
CachePolicy

Pobiera lub ustawia zasady pamięci podręcznej dla tego żądania.Gets or sets the cache policy for this request.

(Odziedziczone po WebRequest)
ClientCertificates

Pobiera lub ustawia certyfikaty używane do nawiązywania szyfrowanego połączenia z serwerem FTP.Gets or sets the certificates used for establishing an encrypted connection to the FTP server.

ConnectionGroupName

Pobiera lub ustawia nazwę grupy połączeń zawierającej punkt usługi używany do wysyłania bieżącego żądania.Gets or sets the name of the connection group that contains the service point used to send the current request.

ContentLength

Pobiera lub ustawia wartość, która jest ignorowana przez FtpWebRequest klasę.Gets or sets a value that is ignored by the FtpWebRequest class.

ContentOffset

Pobiera lub ustawia przesunięcie bajtów do pliku pobranego przez to żądanie.Gets or sets a byte offset into the file being downloaded by this request.

ContentType

Zawsze zgłasza NotSupportedException .Always throws a NotSupportedException.

CreatorInstance
Nieaktualne.

Gdy jest zastępowany w klasie podrzędnej, pobiera obiekt fabryki pochodzący z IWebRequestCreate klasy użytej do utworzenia WebRequest wystąpienia dla żądania do określonego identyfikatora URI.When overridden in a descendant class, gets the factory object derived from the IWebRequestCreate class used to create the WebRequest instantiated for making the request to the specified URI.

(Odziedziczone po WebRequest)
Credentials

Pobiera lub ustawia poświadczenia używane do komunikacji z serwerem FTP.Gets or sets the credentials used to communicate with the FTP server.

DefaultCachePolicy

Definiuje domyślne zasady pamięci podręcznej dla wszystkich żądań FTP.Defines the default cache policy for all FTP requests.

EnableSsl

Pobiera lub ustawia wartość określającą Boolean , czy ma być używane połączenie SSL.Gets or sets a Boolean that specifies that an SSL connection should be used.

Headers

Pobiera pusty WebHeaderCollection obiekt.Gets an empty WebHeaderCollection object.

ImpersonationLevel

Pobiera lub ustawia poziom personifikacji dla bieżącego żądania.Gets or sets the impersonation level for the current request.

(Odziedziczone po WebRequest)
KeepAlive

Pobiera lub ustawia wartość określającą Boolean , czy połączenie z serwerem FTP jest zamknięte po zakończeniu żądania.Gets or sets a Boolean value that specifies whether the control connection to the FTP server is closed after the request completes.

Method

Pobiera lub ustawia polecenie do wysłania do serwera FTP.Gets or sets the command to send to the FTP server.

PreAuthenticate

Zawsze zgłasza NotSupportedException .Always throws a NotSupportedException.

Proxy

Pobiera lub ustawia serwer proxy używany do komunikacji z serwerem FTP.Gets or sets the proxy used to communicate with the FTP server.

ReadWriteTimeout

Pobiera lub ustawia limit czasu podczas odczytywania lub zapisywania w strumieniu.Gets or sets a time-out when reading from or writing to a stream.

RenameTo

Pobiera lub ustawia nową nazwę pliku, którego nazwa jest zmieniana.Gets or sets the new name of a file being renamed.

RequestUri

Pobiera identyfikator URI żądany przez to wystąpienie.Gets the URI requested by this instance.

ServicePoint

Pobiera ServicePoint obiekt używany do nawiązywania połączenia z serwerem FTP.Gets the ServicePoint object used to connect to the FTP server.

Timeout

Pobiera lub ustawia liczbę milisekund oczekiwania na żądanie.Gets or sets the number of milliseconds to wait for a request.

UseBinary

Pobiera lub ustawia wartość określającą Boolean Typ danych dla transferów plików.Gets or sets a Boolean value that specifies the data type for file transfers.

UseDefaultCredentials

Zawsze zgłasza NotSupportedException .Always throws a NotSupportedException.

UsePassive

Pobiera lub ustawia zachowanie procesu transferu danych aplikacji klienta.Gets or sets the behavior of a client application's data transfer process.

Metody

Abort()

Kończy asynchroniczne operacje FTP.Terminates an asynchronous FTP operation.

BeginGetRequestStream(AsyncCallback, Object)

Rozpoczyna asynchroniczne otwieranie strumienia zawartości żądania do zapisu.Begins asynchronously opening a request's content stream for writing.

BeginGetResponse(AsyncCallback, Object)

Zaczyna wysyłać żądanie i odbierać odpowiedź z serwera FTP asynchronicznie.Begins sending a request and receiving a response from an FTP server asynchronously.

CreateObjRef(Type)

Tworzy obiekt, który zawiera wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikacji z obiektem zdalnym.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Odziedziczone po MarshalByRefObject)
EndGetRequestStream(IAsyncResult)

Zakończenie oczekującej operacji asynchronicznej rozpoczętej z BeginGetRequestStream(AsyncCallback, Object) .Ends a pending asynchronous operation started with BeginGetRequestStream(AsyncCallback, Object).

EndGetResponse(IAsyncResult)

Zakończenie oczekującej operacji asynchronicznej rozpoczętej z BeginGetResponse(AsyncCallback, Object) .Ends a pending asynchronous operation started with BeginGetResponse(AsyncCallback, Object).

Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetLifetimeService()
Nieaktualne.

Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
GetObjectData(SerializationInfo, StreamingContext)

Wypełnia dane, SerializationInfo które są konieczne do serializacji obiektu docelowego.Populates a SerializationInfo with the data needed to serialize the target object.

(Odziedziczone po WebRequest)
GetRequestStream()

Pobiera strumień używany do przekazywania danych do serwera FTP.Retrieves the stream used to upload data to an FTP server.

GetRequestStreamAsync()

Gdy jest zastępowany w klasie podrzędnej, zwraca do Stream zapisu danych do zasobu internetowego jako operację asynchroniczną.When overridden in a descendant class, returns a Stream for writing data to the Internet resource as an asynchronous operation.

(Odziedziczone po WebRequest)
GetResponse()

Zwraca odpowiedź serwera FTP.Returns the FTP server response.

GetResponseAsync()

Gdy jest zastępowany w klasie podrzędnej, zwraca odpowiedź na żądanie internetowe jako operację asynchroniczną.When overridden in a descendant class, returns a response to an Internet request as an asynchronous operation.

(Odziedziczone po WebRequest)
GetType()

Pobiera Type bieżące wystąpienie.Gets the Type of the current instance.

(Odziedziczone po Object)
InitializeLifetimeService()
Nieaktualne.

Uzyskuje obiekt usługi istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia.Obtains a lifetime service object to control the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
MemberwiseClone()

Tworzy skróconą kopię bieżącego elementu Object .Creates a shallow copy of the current Object.

(Odziedziczone po Object)
MemberwiseClone(Boolean)

Tworzy skróconą kopię bieżącego MarshalByRefObject obiektu.Creates a shallow copy of the current MarshalByRefObject object.

(Odziedziczone po MarshalByRefObject)
ToString()

Zwraca ciąg reprezentujący bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)

Jawne implementacje interfejsu

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Gdy jest zastępowany w klasie podrzędnej, wypełnia SerializationInfo wystąpienie danymi wymaganymi do serializacji WebRequest .When overridden in a descendant class, populates a SerializationInfo instance with the data needed to serialize the WebRequest.

(Odziedziczone po WebRequest)

Dotyczy

Zobacz też