FtpWebRequest Classe

Définition

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

Object

MarshalByRefObject

WebRequest

FtpWebRequest

Exemples

L’exemple de code suivant illustre la suppression d’un fichier à partir 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 WebClient classe.

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.

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

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

L’URI peut être relatif ou absolu. Si l’URI est de la forme "ftp://contoso.com/%2fpath" (%2f est une séquence d’échappement '/'), l’URI est absolu et le répertoire actif est /path. Si, toutefois, l’URI est de la forme "ftp://contoso.com/path", tout d’abord les journaux .NET Framework dans le serveur FTP (à l’aide du nom d’utilisateur et du mot de passe défini par la Credentials propriété), le répertoire actif est défini sur <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. Vous pouvez spécifier les informations d’identification utilisées pour vous connecter au serveur en définissant la Credentials propriété ou en les incluant dans la UserInfo partie de l’URI passée à la Create méthode. Si vous incluez des UserInfo informations dans l’URI, la Credentials 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.

Vous devez avoir WebPermission accès à la ressource FTP ; sinon, une SecurityException exception est levée.

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

Lorsque vous utilisez un FtpWebRequest objet pour charger un fichier sur un serveur, vous devez écrire le contenu du fichier dans le flux de requête obtenu en appelant la GetRequestStream méthode ou ses équivalents asynchrones, et les BeginGetRequestStreamEndGetRequestStream méthodes. Vous devez écrire dans le flux et fermer le flux avant d’envoyer la requête.

Les demandes sont envoyées au serveur en appelant la GetResponse méthode ou ses équivalents asynchrones, les méthodes et EndGetResponse les BeginGetResponse méthodes. Une fois l’opération demandée terminée, un FtpWebResponse objet est retourné. L’objet FtpWebResponse fournit l’état de l’opération et toutes les données téléchargées à 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 ReadWriteTimeout propriété. Si le délai d’attente est dépassé, la méthode appelante lève une WebExceptionWebExceptionStatus valeur définie Timeoutsur .

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 réponse. Vous pouvez accéder à ce flux en appelant la GetResponseStream méthode. Pour plus d’informations, consultez FtpWebResponse.

Si la Proxy propriété est définie, directement ou dans un fichier de configuration, les communications avec le serveur FTP sont effectuées via le 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 ; autrement dit, le contenu reçu à l’aide de la DownloadFile commande avec la UseBinary propriété définie sur true.

Plusieurs FtpWebRequests réutilisent les connexions existantes, si possible.

Pour plus d’informations sur le protocole FTP, consultez RFC 959 : Protocole de transfert de fichiers.

Voir aussi

• FtpWebResponse
• FtpStatusCode
• WebRequestMethods.Ftp
• WebRequest
• WebResponse
• WebClient