FtpWebRequest Classe

Définition

Implémente un client FTP (File Transfer Protocol).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
Héritage

Exemples

L’exemple de code suivant montre comment supprimer un fichier d’un serveur 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;
}

L’exemple de code suivant illustre le téléchargement d’un fichier à partir d’un WebClient serveur FTP à l’aide de la classe.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;
}

L’exemple de code suivant illustre l’utilisation d’opérations asynchrones pour charger un fichier sur un serveur 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();
            }
        }
    }
}

Remarques

Important

Nous vous déconseillons d’utiliser FtpWebRequest la classe pour un nouveau développement.We don't recommend that you use the FtpWebRequest class for new development. Pour plus d’informations et pour FtpWebRequestobtenir des alternatives à, consultez WebRequest ne doit pas être utilisé sur GitHub.For more information and alternatives to FtpWebRequest, see WebRequest shouldn't be used on GitHub.

Pour obtenir une instance de FtpWebRequest, utilisez la Create méthode.To obtain an instance of FtpWebRequest, use the Create method. Vous pouvez également utiliser la WebClient classe pour charger et télécharger des informations à partir d’un serveur FTP.You can also use the WebClient class to upload and download information from an FTP server. À l’aide de l’une de ces approches, lorsque vous spécifiez une ressource réseau qui utilise le schéma "ftp://contoso.com"FTP ( FtpWebRequest par exemple,), la classe offre la possibilité d’interagir par programmation avec les serveurs 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.

L’URI peut être relatif ou absolu.The URI may be relative or absolute. Si l’URI se présente sous la "ftp://contoso.com/%2fpath" forme (% 2F est un caractère d’échappement'/'), l’URI est absolu et le répertoire actuel est /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. Toutefois, si l’URI se présente sous la forme "ftp://contoso.com/path", le .NET Framework se connecte au serveur FTP (en utilisant le nom d’utilisateur et le mot Credentials de passe définis par la propriété), le répertoire <UserLoginDirectory>/pathactif est défini sur.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.

Vous devez disposer d’un nom d’utilisateur et d’un mot de passe valides pour le serveur ou le serveur doit autoriser l’ouverture de session anonyme.You must have a valid user name and password for the server or the server must allow anonymous logon. Vous pouvez spécifier les informations d’identification utilisées pour se connecter au serveur en définissant la Credentials propriété ou vous pouvez les inclure dans la UserInfo partie de l’URI passée Create à la méthode.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. Si vous incluez UserInfo des informations dans l’URI Credentials , la propriété est définie sur une nouvelle information d’identification réseau avec le nom d’utilisateur et les informations de mot de passe spécifiés.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.

Attention

À moins EnableSsl que la truepropriété ne soit, toutes les données et toutes les commandes, y compris vos informations de nom d’utilisateur et de mot de passe, sont envoyées au serveur en texte clair.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. Toute personne surveillant le trafic réseau peut afficher vos informations d’identification et les utiliser pour se connecter au serveur.Anyone monitoring network traffic can view your credentials and use them to connect to the server. Si vous vous connectez à un serveur FTP qui requiert des informations d’identification et prend en charge protocole SSL (SSL) EnableSsl , truevous devez affecter la valeur à.If you are connecting to an FTP server that requires credentials and supports Secure Sockets Layer (SSL), you should set EnableSsl to true.

Vous devez avoir WebPermission accès à la ressource FTP; sinon, une SecurityException exception est levée.You must have WebPermission to access the FTP resource; otherwise, a SecurityException exception is thrown.

Spécifiez la commande FTP à envoyer au serveur en affectant Method à la propriété une valeur définie dans WebRequestMethods.Ftp la structure.Specify the FTP command to send to the server by setting the Method property to a value defined in the WebRequestMethods.Ftp structure. Pour transmettre des données texte, remplacez UseBinary la valeur par défaut (true) falsede la propriété par.To transmit text data, change the UseBinary property from its default value (true) to false. Pour plus d’informations et pour Methodconnaître les restrictions, consultez.For details and restrictions, see Method.

Lorsque vous utilisez FtpWebRequest un objet pour télécharger un fichier sur un serveur, vous devez écrire le contenu du fichier dans le flux de demande obtenu GetRequestStream en appelant la méthode ou ses équivalents BeginGetRequestStream asynchrones, les méthodes et EndGetRequestStream .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. Vous devez écrire dans le flux et fermer le flux avant d’envoyer la demande.You must write to the stream and close the stream before sending the request.

Les demandes sont envoyées au serveur en appelant la GetResponse méthode ou ses équivalents asynchrones, BeginGetResponse les EndGetResponse méthodes et.Requests are sent to the server by calling the GetResponse method or its asynchronous counterparts, the BeginGetResponse and EndGetResponse methods. Lorsque l’opération demandée est terminée, un FtpWebResponse objet est retourné.When the requested operation completes, an FtpWebResponse object is returned. L' FtpWebResponse objet fournit l’état de l’opération et toutes les données téléchargées à partir du serveur.The FtpWebResponse object provides the status of the operation and any data downloaded from the server.

Vous pouvez définir une valeur de délai d’attente pour la lecture ou l’écriture sur le serveur ReadWriteTimeout à l’aide de la propriété.You can set a time-out value for reading or writing to the server by using the ReadWriteTimeout property. Si le délai d’attente est dépassé, la méthode d’appel lève une WebException avec dont WebExceptionStatus la valeur Timeoutest.If the time-out period is exceeded, the calling method throws a WebException with WebExceptionStatus set to Timeout.

Lors du téléchargement d’un fichier à partir d’un serveur FTP, si la commande a réussi, le contenu du fichier demandé est disponible dans le flux de l’objet de réponse.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. Vous pouvez accéder à ce flux en appelant GetResponseStream la méthode.You can access this stream by calling the GetResponseStream method. Pour plus d'informations, consultez FtpWebResponse.For more information, see FtpWebResponse.

Si la Proxy propriété est définie, soit directement, soit dans un fichier de configuration, les communications avec le serveur FTP sont effectuées via le proxy spécifié.If the Proxy property is set, either directly or in a configuration file, communications with the FTP server are made through the specified proxy. Si le proxy spécifié est un proxy http, seules les DownloadFilecommandes ListDirectory, et ListDirectoryDetails sont prises en charge.If the specified proxy is an HTTP proxy, only the DownloadFile, ListDirectory, and ListDirectoryDetails commands are supported.

Seul le contenu binaire téléchargé est mis en cache; autrement dit, le contenu reçu à DownloadFile l’aide de UseBinary la commande avec truela propriété définie sur.Only downloaded binary content is cached; that is, content received using the DownloadFile command with the UseBinary property set to true.

Plusieurs FtpWebRequests réutilisent les connexions existantes, si possible.Multiple FtpWebRequests reuse existing connections, if possible.

Pour plus d’informations sur le protocole FTP, consultez RFC 959: Protocole FTP.For more information about the FTP protocol, see RFC 959: File Transfer Protocol.

Propriétés

AuthenticationLevel

Obtient ou définit des valeurs indiquant les niveaux d'authentification et d'emprunt d'identité utilisés pour cette demande.Gets or sets values indicating the level of authentication and impersonation used for this request.

(Hérité de WebRequest)
CachePolicy

Obtient ou définit la stratégie de cache de cette demande.Gets or sets the cache policy for this request.

(Hérité de WebRequest)
ClientCertificates

Obtient ou définit les certificats utilisés pour établir une connexion chiffrée au serveur FTP.Gets or sets the certificates used for establishing an encrypted connection to the FTP server.

ConnectionGroupName

Obtient ou définit le nom du groupe de connexions contenant le point de service utilisé pour envoyer la demande actuelle.Gets or sets the name of the connection group that contains the service point used to send the current request.

ContentLength

Obtient ou définit une valeur ignorée par la classe FtpWebRequest.Gets or sets a value that is ignored by the FtpWebRequest class.

ContentOffset

Obtient ou définit un offset d'octet dans le fichier actuellement téléchargé par cette demande.Gets or sets a byte offset into the file being downloaded by this request.

ContentType

Lève toujours NotSupportedException.Always throws a NotSupportedException.

CreatorInstance

En cas de remplacement dans une classe descendante, obtient l'objet de fabrique dérivé de la classe IWebRequestCreate utilisé pour créer l'élément WebRequest instancié pour créer la demande à l'URI spécifié.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.

(Hérité de WebRequest)
Credentials

Obtient ou définit les informations d'identification utilisées pour communiquer avec le serveur FTP.Gets or sets the credentials used to communicate with the FTP server.

DefaultCachePolicy

Définit la stratégie de cache par défaut pour toutes les demandes FTP.Defines the default cache policy for all FTP requests.

EnableSsl

Obtient ou définit un Boolean qui spécifie qu'une connexion SSL doit être utilisée.Gets or sets a Boolean that specifies that an SSL connection should be used.

Headers

Obtient un objet WebHeaderCollection vide.Gets an empty WebHeaderCollection object.

ImpersonationLevel

Obtient ou définit le niveau d'emprunt d'identité pour la demande en cours.Gets or sets the impersonation level for the current request.

(Hérité de WebRequest)
KeepAlive

Obtient ou définit une valeur Boolean qui indique si la connexion de contrôle au serveur FTP doit être fermée une fois la demande terminée.Gets or sets a Boolean value that specifies whether the control connection to the FTP server is closed after the request completes.

Method

Obtient ou définit la commande à envoyer au serveur FTP.Gets or sets the command to send to the FTP server.

PreAuthenticate

Lève toujours NotSupportedException.Always throws a NotSupportedException.

Proxy

Obtient ou définit le proxy utilisé pour communiquer avec le serveur FTP.Gets or sets the proxy used to communicate with the FTP server.

ReadWriteTimeout

Obtient ou définit un délai d'expiration lors de la lecture ou de l'écriture d'un flux.Gets or sets a time-out when reading from or writing to a stream.

RenameTo

Obtient ou définit le nouveau nom d'un fichier qui est renommé.Gets or sets the new name of a file being renamed.

RequestUri

Obtient l'URI demandé par cette instance.Gets the URI requested by this instance.

ServicePoint

Obtient l'objet ServicePoint utilisé pour la connexion au serveur FTP.Gets the ServicePoint object used to connect to the FTP server.

Timeout

Obtient ou définit le nombre de millisecondes pendant lequel attendre une demande.Gets or sets the number of milliseconds to wait for a request.

UseBinary

Obtient ou définit une valeur Boolean qui spécifie le type de données pour les transferts de fichiers.Gets or sets a Boolean value that specifies the data type for file transfers.

UseDefaultCredentials

Lève toujours NotSupportedException.Always throws a NotSupportedException.

UsePassive

Obtient ou définit le comportement du processus de transfert de données d'une application cliente.Gets or sets the behavior of a client application's data transfer process.

Méthodes

Abort()

Met fin à une opération FTP asynchrone.Terminates an asynchronous FTP operation.

BeginGetRequestStream(AsyncCallback, Object)

Commence l'ouverture asynchrone du flux de contenu d'une demande en vue de l'écriture.Begins asynchronously opening a request's content stream for writing.

BeginGetResponse(AsyncCallback, Object)

Commence à envoyer une demande et à recevoir une réponse d'un serveur FTP de façon asynchrone.Begins sending a request and receiving a response from an FTP server asynchronously.

CreateObjRef(Type)

Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Hérité de MarshalByRefObject)
EndGetRequestStream(IAsyncResult)

Met fin à une opération asynchrone en attente démarrée avec BeginGetRequestStream(AsyncCallback, Object).Ends a pending asynchronous operation started with BeginGetRequestStream(AsyncCallback, Object).

EndGetResponse(IAsyncResult)

Met fin à une opération asynchrone en attente démarrée avec BeginGetResponse(AsyncCallback, Object).Ends a pending asynchronous operation started with BeginGetResponse(AsyncCallback, Object).

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetLifetimeService()

Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Hérité de MarshalByRefObject)
GetObjectData(SerializationInfo, StreamingContext)

Remplit SerializationInfo avec les données nécessaires pour sérialiser l'objet cible.Populates a SerializationInfo with the data needed to serialize the target object.

(Hérité de WebRequest)
GetRequestStream()

Récupère le flux utilisé pour transférer des données vers un serveur FTP.Retrieves the stream used to upload data to an FTP server.

GetRequestStreamAsync()

En cas de substitution dans une classe descendante, retourne un Stream pour l'écriture de données vers la ressource Internet en tant qu'opération asynchrone.When overridden in a descendant class, returns a Stream for writing data to the Internet resource as an asynchronous operation.

(Hérité de WebRequest)
GetResponse()

Retourne la réponse du serveur FTP.Returns the FTP server response.

GetResponseAsync()

En cas de substitution dans une classe descendante, retourne une réponse à une demande Internet en tant qu'opération asynchrone.When overridden in a descendant class, returns a response to an Internet request as an asynchronous operation.

(Hérité de WebRequest)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
InitializeLifetimeService()

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.Obtains a lifetime service object to control the lifetime policy for this instance.

(Hérité de MarshalByRefObject)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
MemberwiseClone(Boolean)

Crée une copie superficielle de l'objet MarshalByRefObject actuel.Creates a shallow copy of the current MarshalByRefObject object.

(Hérité de MarshalByRefObject)
ToString()

Retourne une chaîne qui représente l'objet en cours.Returns a string that represents the current object.

(Hérité de Object)

Implémentations d’interfaces explicites

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

En cas de substitution dans une classe descendante, remplit une instance de SerializationInfo avec les données nécessaire à la sérialisation de WebRequest.When overridden in a descendant class, populates a SerializationInfo instance with the data needed to serialize the WebRequest.

(Hérité de WebRequest)

Sécurité

WebPermission
pour accéder à la ressource référencée par cette demande.for accessing the resource referenced by this request. Énumération associée : Connect.Associated enumeration: Connect.

S’applique à

Voir aussi