Comment supprimer tous les fichiers et dossiers dans un répertoire?

Oui, c'est la façon correcte de le faire. Si vous êtes à la recherche pour vous donner un "Propre" (ou, comme je préfère l'appeler, "Vides" de la fonction), vous pouvez créer une méthode d'extension.

public static void Empty(this System.IO.DirectoryInfo directory)
{
    foreach(System.IO.FileInfo file in directory.GetFiles()) file.Delete();
    foreach(System.IO.DirectoryInfo subDirectory in directory.GetDirectories()) subDirectory.Delete(true);
}

Cela vous permettra ensuite de faire quelque chose comme..

System.IO.DirectoryInfo directory = new System.IO.DirectoryInfo(@"C:\...");

directory.Empty();

Nous pouvons aussi montrer de l'amour pour LINQ:

using System.IO;
using System.Linq;
…
var directory = Directory.GetParent(TestContext.TestDir);

directory.EnumerateFiles()
    .ToList().ForEach(f => f.Delete());

directory.EnumerateDirectories()
    .ToList().ForEach(d => d.Delete(true));

Remarque que ma solution n'est pas performant, parce que je suis en utilisant Get*().ToList().ForEach(...) qui génère le même IEnumerable deux fois. J'utilise une méthode d'extension pour éviter ce problème:

using System.IO;
using System.Linq;
…
var directory = Directory.GetParent(TestContext.TestDir);

directory.EnumerateFiles()
    .ForEachInEnumerable(f => f.Delete());

directory.EnumerateDirectories()
    .ForEachInEnumerable(d => d.Delete(true));

C'est la méthode d'extension:

///<summary>
///Extensions for <see cref="System.Collections.Generic.IEnumerable"/>.
///</summary>
public static class IEnumerableOfTExtensions
{
    ///<summary>
    ///Performs the <see cref="System.Action"/>
    ///on each item in the enumerable object.
    ///</summary>
    ///<typeparam name="TEnumerable">The type of the enumerable.</typeparam>
    ///<param name="enumerable">The enumerable.</param>
    ///<param name="action">The action.</param>
    ///<remarks>
    ///“I am philosophically opposed to providing such a method, for two reasons.
    ///…The first reason is that doing so violates the functional programming principles
    ///that all the other sequence operators are based upon. Clearly the sole purpose of a call
    ///to this method is to cause side effects.”
    ///—Eric Lippert, “foreach” vs “ForEach” [http://blogs.msdn.com/b/ericlippert/archive/2009/05/18/foreach-vs-foreach.aspx]
    ///</remarks>
    public static void ForEachInEnumerable<TEnumerable>(this IEnumerable<TEnumerable> enumerable, Action<TEnumerable> action)
    {
        foreach (var item in enumerable)
        {
            action(item);
        }
    }
}

La façon la plus simple:

Directory.Delete(path,true);  
Directory.CreateDirectory(path);

Être conscient que cela peut effacer certaines autorisations sur le dossier.

System.IO.Directory.Delete(installPath, true);
System.IO.Directory.CreateDirectory(installPath);

Le code suivant va nettoyer le répertoire, mais laissez le répertoire racine de y (récursif).

Action<string> DelPath = null;
DelPath = p =>
{
    Directory.EnumerateFiles(p).ToList().ForEach(File.Delete);
    Directory.EnumerateDirectories(p).ToList().ForEach(DelPath);
    Directory.EnumerateDirectories(p).ToList().ForEach(Directory.Delete);
};
DelPath(path);

Juste en utilisant des méthodes statiques avec de Fichier et de Répertoire au lieu de FileInfo et DirectoryInfo permettra d'effectuer plus rapidement. (voir accepté de répondre à Quelle est la différence entre un Fichier et FileInfo en C#?). Réponse montré que l'utilité de la méthode.

public static void Empty(string directory)
{
    foreach(string fileToDelete in System.IO.Directory.GetFiles(directory))
    {
        System.IO.File.Delete(fileToDelete);
    }
    foreach(string subDirectoryToDeleteToDelete in System.IO.Directory.GetDirectories(directory))
    {
        System.IO.Directory.Delete(subDirectoryToDeleteToDelete, true);
    }
}

Dans Windows 7, si vous avez créé manuellement avec l'Explorateur de Windows, le répertoire de la structure est semblable à celui-ci:

C:
  \AAA
    \BBB
      \CCC
        \DDD

Et d'exécuter le code proposé dans la question d'origine pour nettoyer le répertoire C:\AAA la ligne di.Delete(true) échoue toujours avec IOException "Le répertoire n'est pas vide" lorsque vous essayez de supprimer BBB. C'est probablement à cause d'une sorte de retards/mise en cache dans l'Explorateur Windows.

Le code suivant fonctionne de manière fiable pour moi:

static void Main(string[] args)
{
    DirectoryInfo di = new DirectoryInfo(@"c:\aaa");
    CleanDirectory(di);
}

private static void CleanDirectory(DirectoryInfo di)
{
    if (di == null)
        return;

    foreach (FileSystemInfo fsEntry in di.GetFileSystemInfos())
    {
        CleanDirectory(fsEntry as DirectoryInfo);
        fsEntry.Delete();
    }
    WaitForDirectoryToBecomeEmpty(di);
}

private static void WaitForDirectoryToBecomeEmpty(DirectoryInfo di)
{
    for (int i = 0; i < 5; i++)
    {
        if (di.GetFileSystemInfos().Length == 0)
            return;
        Console.WriteLine(di.FullName + i);
        Thread.Sleep(50 * i);
    }
}

Cette version n'utilise pas les appels récursifs, et résout le readonly problème.

public static void EmptyDirectory(string directory)
{
    //First delete all the files, making sure they are not readonly
    var stackA = new Stack<DirectoryInfo>();
    stackA.Push(new DirectoryInfo(directory));

    var stackB = new Stack<DirectoryInfo>();
    while (stackA.Any())
    {
        var dir = stackA.Pop();
        foreach (var file in dir.GetFiles())
        {
            file.IsReadOnly = false;
            file.Delete();
        }
        foreach (var subDir in dir.GetDirectories())
        {
            stackA.Push(subDir);
            stackB.Push(subDir);
        }
    }

    //Then delete the sub directories depth first
    while (stackB.Any())
    {
        stackB.Pop().Delete();
    }
}

L'exemple suivant montre comment vous pouvez le faire. Il crée d'abord certains répertoires et fichiers, puis les supprime via Directory.Delete(topPath, true);:

    static void Main(string[] args)
    {
        string topPath = @"C:\NewDirectory";
        string subPath = @"C:\NewDirectory\NewSubDirectory";

        try
        {
            Directory.CreateDirectory(subPath);

            using (StreamWriter writer = File.CreateText(subPath + @"\example.txt"))
            {
                writer.WriteLine("content added");
            }

            Directory.Delete(topPath, true);

            bool directoryExists = Directory.Exists(topPath);

            Console.WriteLine("top-level directory exists: " + directoryExists);
        }
        catch (Exception e)
        {
            Console.WriteLine("The process failed: {0}", e.Message);
        }
    }

Il est pris de https://msdn.microsoft.com/en-us/library/fxeahc5f(v=vs. 110).aspx.

DirectoryInfo Folder = new DirectoryInfo(Server.MapPath(path)); 
if (Folder .Exists)
{
    foreach (FileInfo fl in Folder .GetFiles())
    {
        fl.Delete();
    }

    Folder .Delete();
}

cela montrera la façon dont nous supprimer le dossier et vérifiez pour cela nous utilisons la zone de Texte

using System.IO;
namespace delete_the_folder
{
public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    private void Deletebt_Click(object sender, EventArgs e)
    {
        //the  first you should write the folder place
        if (Pathfolder.Text=="")
        {
            MessageBox.Show("ples write the path of the folder");
            Pathfolder.Select();
            //return;
        }

        FileAttributes attr = File.GetAttributes(@Pathfolder.Text);

        if (attr.HasFlag(FileAttributes.Directory))
            MessageBox.Show("Its a directory");
        else
            MessageBox.Show("Its a file");

        string path = Pathfolder.Text;
        FileInfo myfileinf = new FileInfo(path);
        myfileinf.Delete();

    }


}

}

Appel de la principale

static void Main(string[] args)
{ 
   string Filepathe =<Your path>
   DeleteDirectory(System.IO.Directory.GetParent(Filepathe).FullName);              
}

Ajouter cette méthode

public static void DeleteDirectory(string path)
{
    if (Directory.Exists(path))
    {
        //Delete all files from the Directory
        foreach (string file in Directory.GetFiles(path))
        {
            File.Delete(file);
        }
        //Delete all child Directories
        foreach (string directory in Directory.GetDirectories(path))
        {
             DeleteDirectory(directory);
        }
        //Delete a Directory
        Directory.Delete(path);
    }
 }

De supprimer le dossier, c'est le code à l'aide de la zone de Texte et un bouton using System.IO; :

private void Deletebt_Click(object sender, EventArgs e)
{
    System.IO.DirectoryInfo myDirInfo = new DirectoryInfo(@"" + delete.Text);

    foreach (FileInfo file in myDirInfo.GetFiles())
    {
       file.Delete();
    }
    foreach (DirectoryInfo dir in myDirInfo.GetDirectories())
    {
       dir.Delete(true);
    }
}

La seule chose que vous devez faire est de mettre en optional recursive parameter à True.

Directory.Delete("C:\MyDummyDirectory", True)

Grâce à .NET. 🙂