Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

FtpWebRequest, classe

Implémente un client FTP (File Transfer Protocol).

Espace de noms :  System.Net
Assembly :  System (dans System.dll)

public sealed class FtpWebRequest : WebRequest

Le type FtpWebRequest expose les membres suivants.

  NomDescription
Propriété publiqueAuthenticationLevelObtient ou définit des valeurs indiquant les niveaux d'authentification et d'emprunt d'identité utilisés pour cette demande. (Hérité de WebRequest.)
Propriété publiqueCachePolicyObtient ou définit la stratégie de cache de cette demande. (Hérité de WebRequest.)
Propriété publiqueClientCertificatesObtient ou définit les certificats utilisés pour établir une connexion chiffrée au serveur FTP.
Propriété publiqueConnectionGroupNameObtient ou définit le nom du groupe de connexions contenant le point de service utilisé pour envoyer la demande actuelle. (Substitue WebRequest.ConnectionGroupName.)
Propriété publiqueContentLengthInfrastructure. Obtient ou définit une valeur ignorée par la classe FtpWebRequest. (Substitue WebRequest.ContentLength.)
Propriété publiqueContentOffsetObtient ou définit un offset d'octet dans le fichier actuellement téléchargé par cette demande.
Propriété publiqueContentTypeInfrastructure. Lève toujours NotSupportedException. (Substitue WebRequest.ContentType.)
Propriété publiqueCreatorInstance Obsolète. En cas de substitution dans une classe descendante, obtient l'objet de fabrique dérivé de la classe IWebRequestCreate utilisée afin de créer la WebRequest instanciée pour créer la requête à l'URI spécifié. (Hérité de WebRequest.)
Propriété publiqueCredentialsObtient ou définit les informations d'identification utilisées pour communiquer avec le serveur FTP. (Substitue WebRequest.Credentials.)
Propriété publiqueMembre statiqueDefaultCachePolicyDéfinit la stratégie de cache par défaut pour toutes les demandes FTP.
Propriété publiqueEnableSslObtient ou définit un Boolean qui spécifie qu'une connexion SSL doit être utilisée.
Propriété publiqueHeadersInfrastructure. Obtient un objet WebHeaderCollection vide. (Substitue WebRequest.Headers.)
Propriété publiqueImpersonationLevelObtient ou définit le niveau d'emprunt d'identité pour la demande en cours. (Hérité de WebRequest.)
Propriété publiqueKeepAliveObtient 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.
Propriété publiqueMethodObtient ou définit la commande à envoyer au serveur FTP. (Substitue WebRequest.Method.)
Propriété publiquePreAuthenticateInfrastructure. Lève toujours NotSupportedException. (Substitue WebRequest.PreAuthenticate.)
Propriété publiqueProxyObtient ou définit le proxy utilisé pour communiquer avec le serveur FTP. (Substitue WebRequest.Proxy.)
Propriété publiqueReadWriteTimeoutObtient ou définit un délai d'expiration lors de la lecture ou de l'écriture d'un flux.
Propriété publiqueRenameToObtient ou définit le nouveau nom d'un fichier qui est renommé.
Propriété publiqueRequestUriObtient l'URI demandé par cette instance. (Substitue WebRequest.RequestUri.)
Propriété publiqueServicePointObtient l'objet ServicePoint utilisé pour la connexion au serveur FTP.
Propriété publiqueTimeoutObtient ou définit le nombre de millisecondes pendant lequel attendre une demande. (Substitue WebRequest.Timeout.)
Propriété publiqueUseBinaryObtient ou définit une valeur Boolean qui spécifie le type de données pour les transferts de fichiers.
Propriété publiqueUseDefaultCredentialsInfrastructure. Lève toujours NotSupportedException. (Substitue WebRequest.UseDefaultCredentials.)
Propriété publiqueUsePassiveObtient ou définit le comportement du processus de transfert de données d'une application cliente.
Début

  NomDescription
Méthode publiqueAbortMet fin à une opération FTP asynchrone. (Substitue WebRequest.Abort().)
Méthode publiqueBeginGetRequestStreamCommence l'ouverture asynchrone du flux de contenu d'une demande en vue de l'écriture. (Substitue WebRequest.BeginGetRequestStream(AsyncCallback, Object).)
Méthode publiqueBeginGetResponseCommence à envoyer une demande et à recevoir une réponse d'un serveur FTP de façon asynchrone. (Substitue WebRequest.BeginGetResponse(AsyncCallback, Object).)
Méthode publiqueCreateObjRefCrée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant. (Hérité de MarshalByRefObject.)
Méthode publiqueEndGetRequestStreamMet fin à une opération asynchrone en attente démarrée avec BeginGetRequestStream. (Substitue WebRequest.EndGetRequestStream(IAsyncResult).)
Méthode publiqueEndGetResponseMet fin à une opération asynchrone en attente démarrée avec BeginGetResponse. (Substitue WebRequest.EndGetResponse(IAsyncResult).)
Méthode publiqueEquals(Object)Détermine si l'objet spécifié est identique à l'objet actuel. (Hérité de Object.)
Méthode publiqueGetHashCodeSert de fonction de hachage par défaut. (Hérité de Object.)
Méthode publiqueGetLifetimeServiceRé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. (Hérité de MarshalByRefObject.)
Méthode publiqueGetRequestStreamRécupère le flux utilisé pour transférer des données vers un serveur FTP. (Substitue WebRequest.GetRequestStream().)
Méthode publiqueGetRequestStreamAsyncEn 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. (Hérité de WebRequest.)
Méthode publiqueGetResponseRetourne la réponse du serveur FTP. (Substitue WebRequest.GetResponse().)
Méthode publiqueGetResponseAsyncEn cas de substitution dans une classe descendante, retourne une réponse à une demande Internet en tant qu'opération asynchrone. (Hérité de WebRequest.)
Méthode publiqueGetTypeObtient le Type de l'instance actuelle. (Hérité de Object.)
Méthode publiqueInitializeLifetimeServiceObtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject.)
Méthode publiqueToStringRetourne une chaîne qui représente l'objet actif. (Hérité de Object.)
Début

  NomDescription
Implémentation d'interface expliciteMéthode privéeISerializable.GetObjectDataInfrastructure. En cas de substitution dans une classe descendante, remplit une instance de SerializationInfo avec les données nécessaire à la sérialisation de WebRequest. (Hérité de WebRequest.)
Début

Pour obtenir une instance de FtpWebRequest, utilisez la méthode Create. Vous pouvez également utiliser la classe WebClient pour transférer et télécharger des informations à partir d'un serveur FTP. À l'aide de l'une ou l'autre de ces approches, si vous spécifiez une ressource réseau qui utilise le schéma FTP (par exemple, "ftp://contoso.com"), la classe FtpWebRequest permet d'interagir par programme avec les serveurs FTP.

L'URI peut être relatif ou absolu. Si l'URI se présente sous la forme "ftp://contoso.com/%2fpath" (%2f est un caractère '/' d'échappement), l'URI est absolu, et le répertoire actif est /path. En revanche, si l'URI se présente sous la forme "ftp://contoso.com/path", le .NET Framework se connecte tout d'abord au serveur FTP (à l'aide du nom d'utilisateur et du mot de passe définis par la propriété Credentials). Ensuite, le répertoire actif est <UserLoginDirectory>/path.

Vous devez disposer d'un nom d'utilisateur et d'un mot de passe valides pour le serveur, ou ce dernier doit autoriser l'ouverture de session anonyme. Vous pouvez spécifier les informations d'identification utilisées pour se connecter au serveur en définissant la propriété Credentials, ou les inclure dans la partie UserInfo de l'URI passé à la méthode Create. Si vous incluez des informations UserInfo dans l'URI, de nouvelles informations d'identification réseau avec le nom d'utilisateur et le mot de passe spécifiés constituent la valeur de la propriété Credentials.

Mise en gardeAttention

À moins que la propriété EnableSsl n'ait la valeur true, toutes les données et commandes, y compris votre nom d'utilisateur et votre mot de passe, sont envoyées au serveur en texte clair. Quiconque contrôlant le trafic réseau peut consulter vos informations d'identification et les utiliser pour se connecter au serveur. Si vous vous connectez à un serveur FTP exigeant des informations d'identification et prenant en charge SSL (Secure Sockets Layer), vous devez affecter à EnableSsl la valeur true.

Vous devez disposer de WebPermission pour accéder à la ressource FTP ; sinon, une exception SecurityException est levée.

Spécifiez la commande FTP à envoyer au serveur en affectant à la propriété Method une valeur définie dans la structure WebRequestMethods.Ftp. Pour transmettre des données texte, remplacez la valeur par défaut de la propriété UseBinary (true) par false. Pour plus d'informations sur les détails et les restrictions, consultez Method.

Lorsque vous utilisez un objet FtpWebRequest pour transférer un fichier vers un serveur, vous devez écrire le contenu du fichier dans le flux de demande obtenu en appelant la méthode GetRequestStream ou ses équivalents asynchrones, les méthodes BeginGetRequestStream et EndGetRequestStream. Vous devez écrire dans le flux et le fermer avant d'envoyer la demande.

Les demandes sont envoyées au serveur en appelant la méthode GetResponse ou ses équivalents asynchrones, les méthodes BeginGetResponse et EndGetResponse. Une fois l'opération demandée terminée, un objet FtpWebResponse est retourné. L'objet FtpWebResponse fournit l'état de l'opération et toute donnée téléchargée à partir du serveur.

Vous pouvez définir une valeur de délai d'attente pour la lecture ou l'écriture sur le serveur à l'aide de la propriété ReadWriteTimeout. Si le délai d'attente est dépassé, la méthode d'appel lève WebException avec WebExceptionStatus ayant la valeur 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. Vous pouvez accéder à ce flux en appelant la méthode GetResponseStream. Pour plus d'informations, consultez FtpWebResponse.

Si la propriété Proxy est définie, directement ou dans un fichier de configuration, les communications avec le serveur FTP s'effectuent par l'intermédiaire du proxy spécifié. Si le proxy spécifié est un proxy HTTP, seules les commandes DownloadFile, ListDirectory et ListDirectoryDetails sont prises en charge.

Seul le contenu binaire téléchargé est mis en cache ; c'est-à-dire le contenu reçu à l'aide de la commande DownloadFile avec la propriété UseBinary ayant la valeur true.

Dans la mesure du possible, les FtpWebRequest multiples réutilisent des connexions existantes.

Pour plus d'informations sur le protocole FTP, consultez la RFC 959, « File Transfer Protocol », disponible à l'adresse http://www.rfc-editor.org/.

L'exemple de code suivant illustre la suppression d'un fichier d'un serveur FTP.


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 serveur FTP à l'aide de la classe WebClient.


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 télécharger un fichier vers un serveur FTP.


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


.NET Framework

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

  • WebPermission 

    pour l'accès à la ressource référencée par cette demande. Énumération associée : Connect.

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Tous les membres static (Shared en Visual Basic) publics de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft