Comment vérifier rapidement si le dossier est vide (.NET)?

Je dois vérifier si le répertoire sur le disque est vide. Cela signifie qu'il ne contient aucun dossier / fichier. Je sais qu'il existe une méthode simple. Nous obtenons un tableau de FileSystemInfo et vérifions si le nombre d'éléments est égal à zéro. Quelque chose comme ca:

public static bool CheckFolderEmpty(string path)
{
    if (string.IsNullOrEmpty(path))
    {
        throw new ArgumentNullException("path");
    }

    var folder = new DirectoryInfo(path);
    if (folder.Exists)
    {
        return folder.GetFileSystemInfos().Length == 0;
    }

    throw new DirectoryNotFoundException();
}

Cette approche semble correcte. MAIS!! C'est très, très mauvais du point de vue des performances. GetFileSystemInfos () est une méthode très difficile. En fait, il énumère tous les objets du système de fichiers du dossier, récupère toutes leurs propriétés, crée des objets, remplit un tableau typé etc. Et tout cela simplement pour vérifier la longueur. C'est stupide, non?

Je viens de profiler ce code et j'ai déterminé que ~ 250 appels d'une telle méthode sont exécutés en ~ 500 ms. C'est très lent et je pense qu'il est possible de le faire beaucoup plus rapidement.

Aucune suggestion?

Il existe une nouvelle fonctionnalité dans Directoryet DirectoryInfodans .NET 4 qui leur permet de renvoyer un IEnumerableau lieu d'un tableau et de commencer à renvoyer des résultats avant de lire tout le contenu du répertoire.

• Nouveautés de la BCL dans .NET 4 Beta 1
• Directory.EnumerateFileSystemEntries surcharges de méthode

public bool IsDirectoryEmpty(string path)
{
    IEnumerable<string> items = Directory.EnumerateFileSystemEntries(path);
    using (IEnumerator<string> en = items.GetEnumerator())
    {
        return !en.MoveNext();
    }
}

EDIT: en revoyant cette réponse, je me rends compte que ce code peut être rendu beaucoup plus simple ...

public bool IsDirectoryEmpty(string path)
{
    return !Directory.EnumerateFileSystemEntries(path).Any();
}

Voici la solution ultra rapide, que j'ai finalement implémentée. Ici, j'utilise WinAPI et les fonctions FindFirstFile , FindNextFile . Il permet d'éviter l'énumération de tous les éléments dans le dossier et s'arrête juste après la détection du premier objet dans le dossier . Cette approche est ~ 6 (!!) fois plus rapide que celle décrite ci-dessus. 250 appels en 36ms!

private static readonly IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1);

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
private struct WIN32_FIND_DATA
{
    public uint dwFileAttributes;
    public System.Runtime.InteropServices.ComTypes.FILETIME ftCreationTime;
    public System.Runtime.InteropServices.ComTypes.FILETIME ftLastAccessTime;
    public System.Runtime.InteropServices.ComTypes.FILETIME ftLastWriteTime;
    public uint nFileSizeHigh;
    public uint nFileSizeLow;
    public uint dwReserved0;
    public uint dwReserved1;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
    public string cFileName;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)]
    public string cAlternateFileName;
}

[DllImport("kernel32.dll", CharSet=CharSet.Auto)]
private static extern IntPtr FindFirstFile(string lpFileName, out WIN32_FIND_DATA lpFindFileData);

[DllImport("kernel32.dll", CharSet=CharSet.Auto)]
private static extern bool FindNextFile(IntPtr hFindFile, out WIN32_FIND_DATA lpFindFileData);

[DllImport("kernel32.dll")]
private static extern bool FindClose(IntPtr hFindFile);

public static bool CheckDirectoryEmpty_Fast(string path)
{
    if (string.IsNullOrEmpty(path))
    {
        throw new ArgumentNullException(path);
    }

    if (Directory.Exists(path))
    {
        if (path.EndsWith(Path.DirectorySeparatorChar.ToString()))
            path += "*";
        else
            path += Path.DirectorySeparatorChar + "*";

        WIN32_FIND_DATA findData;
        var findHandle = FindFirstFile(path, out findData);

        if (findHandle != INVALID_HANDLE_VALUE)
        {
            try
            {
                bool empty = true;
                do
                {
                    if (findData.cFileName != "." && findData.cFileName != "..")
                        empty = false;
                } while (empty && FindNextFile(findHandle, out findData));

                return empty;
            }
            finally
            {
                FindClose(findHandle);
            }
        }

        throw new Exception("Failed to get directory first file",
            Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()));
    }
    throw new DirectoryNotFoundException();
}

J'espère que cela sera utile à quelqu'un à l'avenir.

Vous pouvez essayer Directory.Exists(path)et Directory.GetFiles(path)- probablement moins de frais généraux (pas d'objets - juste des chaînes, etc.).

private static void test()
{
    System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
    sw.Start();

    string [] dirs = System.IO.Directory.GetDirectories("C:\\Test\\");
    string[] files = System.IO.Directory.GetFiles("C:\\Test\\");

    if (dirs.Length == 0 && files.Length == 0)
        Console.WriteLine("Empty");
    else
        Console.WriteLine("Not Empty");

    sw.Stop();
    Console.WriteLine(sw.ElapsedMilliseconds);
}

Ce test rapide est revenu en 2 millisecondes pour le dossier lorsqu'il était vide et lorsqu'il contenait des sous-dossiers et des fichiers (5 dossiers avec 5 fichiers chacun)

J'utilise ceci pour les dossiers et les fichiers (je ne sais pas si c'est optimal)

    if(Directory.GetFileSystemEntries(path).Length == 0)

Si cela ne vous dérange pas de laisser C # pur et de passer des appels WinApi , vous pouvez envisager la fonction PathIsDirectoryEmpty () . Selon le MSDN, la fonction:

Renvoie TRUE si pszPath est un répertoire vide. Renvoie FALSE si pszPath n'est pas un répertoire ou s'il contient au moins un fichier autre que "." ou "..".

Cela semble être une fonction qui fait exactement ce que vous voulez, donc elle est probablement bien optimisée pour cette tâche (bien que je ne l'ai pas testé).

Pour l'appeler depuis C #, le site pinvoke.net devrait vous aider. (Malheureusement, il ne décrit pas encore cette fonction, mais vous devriez être en mesure de trouver des fonctions avec des arguments similaires et de renvoyer le type là-bas et de les utiliser comme base pour votre appel. Si vous regardez à nouveau dans le MSDN, il indique que la DLL à importer est shlwapi.dll)

Je ne connais pas les statistiques de performances de celui-ci, mais avez-vous essayé d'utiliser la Directory.GetFiles()méthode statique?

Il renvoie un tableau de chaînes contenant des noms de fichiers (pas FileInfos) et vous pouvez vérifier la longueur du tableau de la même manière que ci-dessus.

Je suis sûr que les autres réponses sont plus rapides, et votre question demandait si un dossier contenait des fichiers ou des dossiers ... mais je pense que la plupart du temps, les gens considéreraient un répertoire vide s'il ne contient pas de fichiers. c'est-à-dire qu'il est toujours "vide" pour moi s'il contient des sous-répertoires vides ... cela peut ne pas convenir à votre usage, mais peut-être pour d'autres!

  public bool DirectoryIsEmpty(string path)
  {
    int fileCount = Directory.GetFiles(path).Length;
    if (fileCount > 0)
    {
        return false;
    }

    string[] dirs = Directory.GetDirectories(path);
    foreach (string dir in dirs)
    {
      if (! DirectoryIsEmpty(dir))
      {
        return false;
      }
    }

    return true;
  }

Dans tous les cas, vous devrez aller sur le disque dur pour obtenir ces informations, et cela seul l'emportera sur toute création d'objet et remplissage de tableau.

Je ne connais pas une méthode qui vous dira succinctement si un dossier donné contient d'autres dossiers ou fichiers, cependant, en utilisant:

Directory.GetFiles(path);
&
Directory.GetDirectories(path);

devrait améliorer les performances car ces deux méthodes ne renverront qu'un tableau de chaînes avec les noms des fichiers / répertoires plutôt que des objets FileSystemInfo entiers.

Facile et simple:

int num = Directory.GetFiles(pathName).Length;

if (num == 0)
{
   //empty
}

Merci à tous pour les réponses. J'ai essayé d'utiliser Directory.GetFiles () et Directory.GetDirectories () . Bonnes nouvelles! Les performances se sont améliorées ~ deux fois! 229 appels en 221 ms. Mais j'espère aussi qu'il est possible d'éviter l'énumération de tous les éléments du dossier. D'accord, que le travail inutile est toujours en cours d'exécution. Tu ne penses pas?

Après toutes les enquêtes, je suis arrivé à une conclusion, que sous .NET pur, une optimisation supplémentaire est impossible. Je vais jouer avec la fonction FindFirstFile de WinAPI . J'espère que cela aidera.

Vous voudrez peut-être vérifier si des fichiers existent dans les sous-répertoires et ignorer ces sous-répertoires vides; dans ce cas, vous pouvez utiliser la méthode ci-dessous:

public bool isDirectoryContainFiles(string path) {
    if (!Directory.Exists(path)) return false;
    return Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories).Any();
}

Basé dans le code Brad Parks :

    public static bool DirectoryIsEmpty(string path)
    {
        if (System.IO.Directory.GetFiles(path).Length > 0) return false;

        foreach (string dir in System.IO.Directory.GetDirectories(path))
            if (!DirectoryIsEmpty(dir)) return false;

        return true;
    }

Mon code est incroyable, il a juste fallu 00: 00: 00.0007143 moins de milliseconde avec 34 fichiers dans le dossier

   System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
    sw.Start();

     bool IsEmptyDirectory = (Directory.GetFiles("d:\\pdf").Length == 0);

     sw.Stop();
     Console.WriteLine(sw.Elapsed);

Voici quelque chose qui pourrait vous aider à le faire. J'ai réussi à le faire en deux itérations.

 private static IEnumerable<string> GetAllNonEmptyDirectories(string path)
   {
     var directories =
        Directory.EnumerateDirectories(path, "*.*", SearchOption.AllDirectories)
        .ToList();

     var directoryList = 
     (from directory in directories
     let isEmpty = Directory.GetFiles(directory, "*.*", SearchOption.AllDirectories).Length == 0
     where !isEmpty select directory)
     .ToList();

     return directoryList.ToList();
   }

Puisque vous allez de toute façon travailler avec un objet DirectoryInfo, j'irais avec une extension

public static bool IsEmpty(this DirectoryInfo directoryInfo)
{
    return directoryInfo.GetFileSystemInfos().Count() == 0;
}

Utilisez ceci. C'est simple.

Public Function IsDirectoryEmpty(ByVal strDirectoryPath As String) As Boolean
        Dim s() As String = _
            Directory.GetFiles(strDirectoryPath)
        If s.Length = 0 Then
            Return True
        Else
            Return False
        End If
    End Function