Comment peut-ClientFTP supprimer un répertoire?

Question

Je veux supprimer un dossier FTP.

Can objet FTPClient supprimer?

Answer 1

FtpWebRequest fournit l'action Supprimer. Voici un morceau de code pour y parvenir:

               FtpWebRequest reqFTP = FtpWebRequest.Create(uri);
                // Credentials and login handling...

                reqFTP.Method = WebRequestMethods.Ftp.DeleteFile;

                string result = string.Empty;
                FtpWebResponse response = reqFTP.GetResponse();
                long size = response.ContentLength;
                Stream datastream = response.GetResponseStream();
                StreamReader sr = new StreamReader(datastream);
                result = sr.ReadToEnd();
                sr.Close();
                datastream.Close();
                response.Close();

Il doit travailler sur des fichiers et des répertoires. En effet, s'il vous plaît vérifier que vous disposez des autorisations appropriées.

En outre, vous ne pouviez pas supprimer des dossiers alors qu'ils ne sont pas vides. Vous devez les traverser récursive au contenu avant suppression.

Les exceptions lancées en raison de problèmes de permissions ne sont pas toujours très clair ...

Answer 2

Pour supprimer un répertoire vide, utilisez la "méthode" RemoveDirectory du FtpWebRequest:

void DeleteFtpDirectory(string url, NetworkCredential credentials)
{
    FtpWebRequest request = (FtpWebRequest)WebRequest.Create(url);
    request.Method = WebRequestMethods.Ftp.RemoveDirectory;
    request.Credentials = credentials;
    request.GetResponse().Close();
}

utiliser comme:

string url = "ftp://ftp.example.com/directory/todelete";
NetworkCredential credentials = new NetworkCredential("username", "password");
DeleteFtpDirectory(url, credentials);

---

Bien qu'il obtient une manière plus compliquée, si vous avez besoin de supprimer un répertoire non vide. Il n'y a pas de soutien pour les opérations récursives en classe FtpWebRequest (ou toute autre application FTP dans le cadre de .NET). Vous devez mettre en œuvre la récursion vous:

• Liste du répertoire distant
• Itérer les entrées, la suppression de fichiers et récursion dans les sous-répertoires (les énumérer à nouveau, etc.)

Tricky est partie pour identifier les fichiers de sous-répertoires. Il n'y a aucun moyen de le faire de manière portable avec le FtpWebRequest. Le FtpWebRequest malheureusement ne supporte pas la commande MLSD, qui est le seul moyen portable pour récupérer liste des répertoires avec des attributs de fichiers dans le protocole FTP. Voir aussi Vérification si l'objet sur le serveur FTP est un fichier ou un répertoire .

Vos options sont:

• Faites une opération sur un nom de fichier qui est certain d'échouer pour le fichier et réussit pour les répertoires (ou vice versa). C'est à dire. vous pouvez essayer de télécharger le « nom ». Si cela réussit, il est un fichier, si cela échoue, il est un répertoire. Mais cela peut devenir un problème de performance, lorsque vous avez un grand nombre d'entrées.
• Vous pouvez être chanceux et dans votre cas spécifique, vous pouvez dire un fichier à partir d'un répertoire par un nom de fichier (à savoir tous vos fichiers ont une extension, tandis que les sous-répertoires ne le font pas)
• Vous utilisez une longue liste des répertoires (commande LIST = méthode ListDirectoryDetails) et essayer d'analyser une liste spécifique au serveur. De nombreux serveurs FTP utilisent * liste de style nix, où vous identifiez un répertoire par le d au début de l'entrée. Mais de nombreux serveurs utilisent un format différent. L'exemple suivant utilise cette approche (en supposant le format * nix).
• Dans ce cas spécifique, vous pouvez simplement essayer de supprimer l'entrée en tant que fichier. Si la suppression échoue, essayez de lister l'entrée comme répertoire. Si la liste réussit, vous assumez c'est un dossier et agir en conséquence. Malheureusement, certains serveurs ne pas erreur, lorsque vous essayez de lister un fichier. Ils vont simplement retourner une liste avec une seule entrée pour le fichier.

static void DeleteFtpDirectory(string url, NetworkCredential credentials)
{
    FtpWebRequest listRequest = (FtpWebRequest)WebRequest.Create(url);
    listRequest.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
    listRequest.Credentials = credentials;

    List<string> lines = new List<string>();

    using (FtpWebResponse listResponse = (FtpWebResponse)listRequest.GetResponse())
    using (Stream listStream = listResponse.GetResponseStream())
    using (StreamReader listReader = new StreamReader(listStream))
    {
        while (!listReader.EndOfStream)
        {
            lines.Add(listReader.ReadLine());
        }
    }

    foreach (string line in lines)
    {
        string[] tokens =
            line.Split(new[] { ' ' }, 9, StringSplitOptions.RemoveEmptyEntries);
        string name = tokens[8];
        string permissions = tokens[0];

        string fileUrl = url + name;

        if (permissions[0] == 'd')
        {
            DeleteFtpDirectory(fileUrl + "/", credentials);
        }
        else
        {
            FtpWebRequest deleteRequest = (FtpWebRequest)WebRequest.Create(fileUrl);
            deleteRequest.Method = WebRequestMethods.Ftp.DeleteFile;
            deleteRequest.Credentials = credentials;

            deleteRequest.GetResponse();
        }
    }

    FtpWebRequest removeRequest = (FtpWebRequest)WebRequest.Create(url);
    removeRequest.Method = WebRequestMethods.Ftp.RemoveDirectory;
    removeRequest.Credentials = credentials;

    removeRequest.GetResponse();
}

Utilisez la même manière que la mise en œuvre précédente (plat).

Bien que Microsoft ne recommande pas FtpWebRequest pour un nouveau développement .

---

Ou utiliser une bibliothèque 3ème partie qui soutient les opérations récursives.

Par exemple avec WinSCP assemblage .NET vous pouvez supprimer le répertoire entier avec un seul appel à Session.RemoveFiles :

// Setup session options
SessionOptions sessionOptions = new SessionOptions
{
    Protocol = Protocol.Ftp,
    HostName = "example.com",
    UserName = "user",
    Password = "mypassword",
};

using (Session session = new Session())
{
    // Connect
    session.Open(sessionOptions);

    // Delete folder
    session.RemoveFiles("/directory/todelete").Check();
} 

interne, WinSCP utilise la commande MLSD, si pris en charge par le serveur. Dans le cas contraire, il utilise la commande LIST et soutient des dizaines de différents formats d'inscription.

(je suis l'auteur de WinSCP)

Answer 3

La seule manière que je trouvais travailler est de compter sur « WebRequestMethods.Ftp.DeleteFile » et il donnera une Incase d'exception des dossiers ou des dossiers avec des fichiers si j'ai créé une nouvelle méthode interenal à DeleteDirectory récursive voici le code

public void delete(string deleteFile)
            {
                try
                {
                    /* Create an FTP Request */
                    ftpRequest = (FtpWebRequest)WebRequest.Create(host + "/" + deleteFile);
                    /* Log in to the FTP Server with the User Name and Password Provided */
                    ftpRequest.Credentials = new NetworkCredential(user, pass);
                    /* When in doubt, use these options */
                    ftpRequest.UseBinary = true;
                    ftpRequest.UsePassive = true;
                    ftpRequest.KeepAlive = true;
                    /* Specify the Type of FTP Request */
                    ftpRequest.Method = WebRequestMethods.Ftp.DeleteFile;
                    /* Establish Return Communication with the FTP Server */
                    ftpResponse = (FtpWebResponse)ftpRequest.GetResponse();
                    /* Resource Cleanup */
                    ftpResponse.Close();
                    ftpRequest = null;
                }
                catch (Exception ex) { 
                    //Console.WriteLine(ex.ToString()); 
                    try
                    {
                        deleteDirectory(deleteFile);
                    }
                    catch { }


                }
                return;
            }

et la suppression de répertoire

/* Delete Directory*/
            private void deleteDirectory(string directoryName)
            {
                try
                {
                    //Check files inside 
                    var direcotryChildren  = directoryListSimple(directoryName);
                    if (direcotryChildren.Any() && (!string.IsNullOrWhiteSpace(direcotryChildren[0])))
                    {
                        foreach (var child in direcotryChildren)
                        {
                            delete(directoryName + "/" +  child);
                        }
                    }


                    /* Create an FTP Request */
                    ftpRequest = (FtpWebRequest)WebRequest.Create(host + "/" + directoryName);
                    /* Log in to the FTP Server with the User Name and Password Provided */
                    ftpRequest.Credentials = new NetworkCredential(user, pass);
                    /* When in doubt, use these options */
                    ftpRequest.UseBinary = true;
                    ftpRequest.UsePassive = true;
                    ftpRequest.KeepAlive = true;
                    /* Specify the Type of FTP Request */
                    ftpRequest.Method = WebRequestMethods.Ftp.RemoveDirectory;

                    /* Establish Return Communication with the FTP Server */
                    ftpResponse = (FtpWebResponse)ftpRequest.GetResponse();
                    /* Resource Cleanup */
                    ftpResponse.Close();
                    ftpRequest = null;
                }
                catch (Exception ex) { Console.WriteLine(ex.ToString()); }
                return;
            }

Liste des enfants direcotry

/* List Directory Contents File/Folder Name Only */
            public string[] directoryListSimple(string directory)
            {
                try
                {
                    /* Create an FTP Request */
                    ftpRequest = (FtpWebRequest)FtpWebRequest.Create(host + "/" + directory);
                    /* Log in to the FTP Server with the User Name and Password Provided */
                    ftpRequest.Credentials = new NetworkCredential(user, pass);
                    /* When in doubt, use these options */
                    ftpRequest.UseBinary = true;
                    ftpRequest.UsePassive = true;
                    ftpRequest.KeepAlive = true;
                    /* Specify the Type of FTP Request */
                    ftpRequest.Method = WebRequestMethods.Ftp.ListDirectory;
                    /* Establish Return Communication with the FTP Server */
                    ftpResponse = (FtpWebResponse)ftpRequest.GetResponse();
                    /* Establish Return Communication with the FTP Server */
                    ftpStream = ftpResponse.GetResponseStream();
                    /* Get the FTP Server's Response Stream */
                    StreamReader ftpReader = new StreamReader(ftpStream);
                    /* Store the Raw Response */
                    string directoryRaw = null;
                    /* Read Each Line of the Response and Append a Pipe to Each Line for Easy Parsing */
                    try { while (ftpReader.Peek() != -1) { directoryRaw += ftpReader.ReadLine() + "|"; } }
                    catch (Exception ex) { Console.WriteLine(ex.ToString()); }
                    /* Resource Cleanup */
                    ftpReader.Close();
                    ftpStream.Close();
                    ftpResponse.Close();
                    ftpRequest = null;
                    /* Return the Directory Listing as a string Array by Parsing 'directoryRaw' with the Delimiter you Append (I use | in This Example) */
                    try { string[] directoryList = directoryRaw.Split("|".ToCharArray()); return directoryList; }
                    catch (Exception ex) { Console.WriteLine(ex.ToString()); }
                }
                catch (Exception ex) { Console.WriteLine(ex.ToString()); }
                /* Return an Empty string Array if an Exception Occurs */
                return new string[] { "" };
            }

            /* List Directory Contents in Detail (Name, Size, Created, etc.) */
            public string[] directoryListDetailed(string directory)
            {
                try
                {
                    /* Create an FTP Request */
                    ftpRequest = (FtpWebRequest)FtpWebRequest.Create(host + "/" + directory);
                    /* Log in to the FTP Server with the User Name and Password Provided */
                    ftpRequest.Credentials = new NetworkCredential(user, pass);
                    /* When in doubt, use these options */
                    ftpRequest.UseBinary = true;
                    ftpRequest.UsePassive = true;
                    ftpRequest.KeepAlive = true;
                    /* Specify the Type of FTP Request */
                    ftpRequest.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
                    /* Establish Return Communication with the FTP Server */
                    ftpResponse = (FtpWebResponse)ftpRequest.GetResponse();
                    /* Establish Return Communication with the FTP Server */
                    ftpStream = ftpResponse.GetResponseStream();
                    /* Get the FTP Server's Response Stream */
                    StreamReader ftpReader = new StreamReader(ftpStream);
                    /* Store the Raw Response */
                    string directoryRaw = null;
                    /* Read Each Line of the Response and Append a Pipe to Each Line for Easy Parsing */
                    try { while (ftpReader.Peek() != -1) { directoryRaw += ftpReader.ReadLine() + "|"; } }
                    catch (Exception ex) { Console.WriteLine(ex.ToString()); }
                    /* Resource Cleanup */
                    ftpReader.Close();
                    ftpStream.Close();
                    ftpResponse.Close();
                    ftpRequest = null;
                    /* Return the Directory Listing as a string Array by Parsing 'directoryRaw' with the Delimiter you Append (I use | in This Example) */
                    try { string[] directoryList = directoryRaw.Split("|".ToCharArray()); return directoryList; }
                    catch (Exception ex) { Console.WriteLine(ex.ToString()); }
                }
                catch (Exception ex) { Console.WriteLine(ex.ToString()); }
                /* Return an Empty string Array if an Exception Occurs */
                return new string[] { "" };
            }

Answer 4

Point important

Comme mentionné ci-dessus ..

vous ne pouviez pas supprimer des dossiers alors qu'ils ne sont pas vides. Vous devez les traverser récursive au contenu avant suppression.

Answer 5

public void Deletedir(string remoteFolder)
{
    try
    {
        /* Create an FTP Request */
        ftpRequest = (FtpWebRequest)FtpWebRequest.Create(host + "/"+ remoteFolder);
        /* Log in to the FTP Server with the User Name and Password Provided */
        ftpRequest.Credentials = new NetworkCredential(user, pass);
        /* When in doubt, use these options */
        ftpRequest.UseBinary = true;***strong text***
        ftpRequest.UsePassive = true;
        ftpRequest.KeepAlive = true;
        /* Specify the Type of FTP Request */
        ftpRequest.Method = WebRequestMethods.Ftp.RemoveDirectory;
        /* Establish Return Communication with the FTP Server */
        ftpResponse = (FtpWebResponse)ftpRequest.GetResponse();
        /* Get the FTP Server's Response Stream */
        ftpStream = ftpResponse.GetResponseStream();
        /* Open a File Stream to Write the Downloaded File */
    }
    catch { }
}

C'est le code que vous pouvez utiliser. Et voici comment vous pouvez l'utiliser, par exemple, sur un bouton clic.

private void button5_Click(object sender, EventArgs e)
{
    ftp ftpClient = new ftp(@"SERVICE PROVIDER", "USERNAME", "PASSWORD");
    ftpClient.Deletedir("DIRECTORY U WANT TO DELETE");
}

Et rappelez-vous simplement que votre dossier doit être vide.