Como verificar rapidamente se a pasta está vazia (.NET)?

Eu tenho que verificar, se o diretório no disco está vazio. Isso significa que ele não contém nenhuma pasta / arquivo. Eu sei que existe um método simples. Obtemos uma matriz de FileSystemInfo e verificamos se a contagem de elementos é igual a zero. Algo parecido:

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

Essa abordagem parece bem. MAS!! É muito, muito ruim do ponto de vista do desempenho. GetFileSystemInfos () é um método muito difícil. Na verdade, ele enumera todos os objetos do sistema de arquivos da pasta, obtém todas as suas propriedades, cria objetos, preenche a matriz digitada, etc. E tudo isso apenas para verificar Comprimento. Isso é estúpido, não é?

Acabei de criar um perfil desse código e determinei que ~ 250 chamadas desse método são executadas em ~ 500ms. Isso é muito lento e acredito que é possível fazê-lo muito mais rápido.

Alguma sugestão?

Há um novo recurso no Directorye DirectoryInfono .NET 4, que lhes permite retornar uma IEnumerablevez de uma matriz, e começar a retornar resultados antes de ler todo o conteúdo do diretório.

• O que há de novo na BCL no .NET 4 Beta 1
• Directory.EnumerateFileSystemEntries sobrecargas de método

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

EDIT: vendo essa resposta novamente, percebo que esse código pode ser muito mais simples ...

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

Aqui está a solução extra rápida que eu finalmente implementei. Aqui estou usando o WinAPI e as funções FindFirstFile , FindNextFile . Permite evitar a enumeração de todos os itens da pasta e para logo após a detecção do primeiro objeto na pasta . Essa abordagem é ~ 6 (!!) vezes mais rápida do que a descrita acima. 250 chamadas em 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();
}

Espero que seja útil para alguém no futuro.

Você pode tentar Directory.Exists(path)e Directory.GetFiles(path)- provavelmente menos sobrecarga (sem objetos - apenas strings 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);
}

Esse teste rápido voltou em 2 milissegundos para a pasta quando vazia e ao conter subpastas e arquivos (5 pastas com 5 arquivos em cada)

Eu uso isso para pastas e arquivos (não sei se é o ideal)

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

Se você não se importa em deixar o C # puro e fazer chamadas WinApi , considere a função PathIsDirectoryEmpty () . De acordo com o MSDN, a função:

Retorna TRUE se pszPath for um diretório vazio. Retorna FALSE se pszPath não for um diretório ou se contiver pelo menos um arquivo que não seja "." ou "..".

Essa parece ser uma função que faz exatamente o que você deseja, portanto provavelmente está bem otimizada para essa tarefa (embora eu não a tenha testado).

Para chamá-lo de C #, o site pinvoke.net deve ajudá-lo. (Infelizmente, ainda não descreve essa função, mas você deve encontrar algumas funções com argumentos semelhantes e retornar o tipo lá e usá-las como base para sua chamada. Se você olhar novamente para o MSDN, ele indicará que a DLL da qual importar é shlwapi.dll)

Não conheço as estatísticas de desempenho desta, mas você já tentou usar o Directory.GetFiles()método estático?

Ele retorna uma matriz de cadeias contendo nomes de arquivos (não FileInfos) e você pode verificar o comprimento da matriz da mesma maneira que acima.

Tenho certeza de que as outras respostas são mais rápidas e sua pergunta perguntou se uma pasta continha ou não arquivos ou pastas ... mas acho que na maioria das vezes as pessoas consideram um diretório vazio se ele não contiver arquivos. ou seja, ainda está "vazio" para mim se contiver subdiretórios vazios ... isso pode não ser adequado ao seu uso, mas pode ser para outros!

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

De qualquer forma, você terá que usar o disco rígido para obter essas informações, e isso sozinho superará qualquer criação de objeto e preenchimento de matriz.

Não estou ciente de um método que informará sucintamente se uma determinada pasta contém outras pastas ou arquivos, no entanto, usando:

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

deve ajudar o desempenho, pois esses dois métodos retornarão apenas uma matriz de cadeias com os nomes dos arquivos / diretórios, em vez de objetos inteiros FileSystemInfo.

Obrigado a todos, pelas respostas. Tentei usar os métodos Directory.GetFiles () e Directory.GetDirectories () . Boas notícias! O desempenho melhorou ~ duas vezes! 229 chamadas em 221ms. Mas também espero que seja possível evitar a enumeração de todos os itens da pasta. Concorde que ainda o trabalho desnecessário está sendo executado. Você não acha?

Depois de todas as investigações, cheguei a uma conclusão de que, sob o .NET puro, é impossível uma otimização adicional. Vou jogar com a função FindFirstFile do WinAPI . Espero que ajude.

Algum tempo, convém verificar se existem arquivos dentro dos subdiretórios e ignorar esses subdiretórios vazios; Nesse caso, você pode usar o método abaixo:

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

Fácil e simples:

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

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

Baseado no código de 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;
    }

Meu código é incrível, levou apenas 00: 00: 00.0007143 menos de milissegundo com 34 arquivos na pasta

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

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

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

Aqui está algo que pode ajudá-lo a fazer isso. Consegui fazer isso em duas iterações.

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

Como você trabalha com um objeto DirectoryInfo de qualquer maneira, eu usaria uma extensão

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

Usa isto. É simples.

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