Klasörün boş olup olmadığını hızlı bir şekilde nasıl kontrol edebilirim (.NET)?

Diskteki dizinin boş olup olmadığını kontrol etmeliyim. Bu, herhangi bir klasör / dosya içermediği anlamına gelir. Biliyorum, basit bir yöntem var. FileSystemInfo dizisini alıyoruz ve eleman sayısının sıfıra eşit olup olmadığını kontrol ediyoruz. Bunun gibi bir şey:

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

Bu yaklaşım iyi görünüyor. FAKAT!! Performans açısından çok ama çok kötü. GetFileSystemInfos () çok zor bir yöntemdir. Aslında, klasörün tüm dosya sistemi nesnelerini numaralandırır, tüm özelliklerini alır, nesneleri oluşturur, yazılan diziyi doldurur vb. Ve tüm bunlar sadece uzunluğu kontrol etmek için. Bu aptalca, değil mi?

Ben sadece böyle bir kod profilli ve bu yöntem ~ 250 çağrı ~ 500ms yürütüldüğünü belirledim. Bu çok yavaş ve inanıyorum ki, çok daha hızlı yapmak mümkün.

Baska öneri?

.NET 4'te Directoryve DirectoryInfoiçinde IEnumerable, bir dizi yerine dönmelerine ve tüm dizin içeriğini okumadan önce sonuçları döndürmelerine izin veren yeni bir özellik vardır .

• .NET 4 Beta 1 BCL'deki Yenilikler
• Directory.EnumerateFileSystemEntries yöntem aşırı yükler

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

EDIT: bu cevabı tekrar görerek, bu kodun çok daha basit olabileceğini anlıyorum ...

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

İşte sonunda uyguladığım ekstra hızlı çözüm. Burada WinAPI ve FindFirstFile , FindNextFile işlevlerini kullanıyorum . Klasördeki tüm öğelerin numaralandırılmasını engeller ve Klasördeki ilk nesneyi algıladıktan hemen sonra durur . Bu yaklaşım yukarıda tarif edilenden ~ 6 (!!) kat daha hızlıdır. 36ms'de 250 çağrı!

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

Umarım gelecekte birileri için faydalı olur.

Sen-ebilmek denemek Directory.Exists(path)ve Directory.GetFiles(path)- muhtemelen daha az yükü (hiçbir nesne - sadece dizeleri vb).

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

Bu hızlı test, boş olduğunda ve alt klasörler ve dosyalar içerdiğinde klasör için 2 milisaniyede geri geldi (her birinde 5 dosya bulunan 5 klasör)

Bunu klasörler ve dosyalar için kullanıyorum (optimal olup olmadığını bilmiyorum)

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

Saf C # bırakıp WinApi çağrıları için sorun olmazsa , PathIsDirectoryEmpty () işlevini düşünmek isteyebilirsiniz . MSDN'ye göre, fonksiyon:

PszPath boş bir dizinse TRUE değerini döndürür. PszPath bir dizin değilse veya "." Dışında en az bir dosya içeriyorsa FALSE değerini döndürür. veya "..".

Bu tam olarak ne istediğinizi yapan bir işlev gibi görünüyor, bu yüzden muhtemelen bu görev için iyi optimize edilmiş (bunu test etmeme rağmen).

C # 'dan aramak için pinvoke.net sitesi size yardımcı olmalıdır. (Ne yazık ki, henüz bu belirli işlevi tanımlamıyor, ancak benzer argümanlara sahip bazı işlevleri bulabilmeli ve orada geri dönebilmeli ve bunları çağrınızın temeli olarak kullanabilmelisiniz. Tekrar MSDN'ye bakarsanız, diyor ki alınacak DLL is shlwapi.dll)

Bu konuda performans istatistikleri bilmiyorum, ama Directory.GetFiles()statik yöntemi kullanmayı denediniz mi?

Dosya adlarını (FileInfos değil) içeren bir dize dizisi döndürür ve dizinin uzunluğunu yukarıdaki gibi kontrol edebilirsiniz.

Eminim diğer yanıtlar daha hızlıdır ve sorunuz bir klasörün dosya veya klasör içerip içermediğini sordu ... ancak çoğu zaman insanların dosya içermiyorsa bir dizini boş olarak değerlendireceğini düşünürüm. yani boş alt dizinler içeriyorsa hala "boş" ... bu sizin kullanımınıza uygun olmayabilir, ama diğerleri için uygun olabilir!

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

Her durumda bu bilgi için sabit sürücüye gitmeniz gerekecek ve bu tek başına herhangi bir nesne oluşturma ve dizi doldurmayı koyacaktır.

Belirli bir klasörün diğer klasörleri veya dosyaları içerip içermediğini, ancak aşağıdakileri kullanarak kısa bir süre içinde anlatacak bir yöntemin farkında değilim:

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

bu yöntemlerin her ikisi de tüm FileSystemInfo nesneleri yerine yalnızca dosyaların / dizinlerin adlarını içeren bir dizgi dizisi döndüreceğinden performansa yardımcı olmalıdır.

Kolay ve basit:

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

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

Cevaplar için herkese teşekkürler. Directory.GetFiles () ve Directory.GetDirectories () yöntemlerini kullanmaya çalıştım . İyi haberler! Performans ~ iki kez arttı! 221 ms'de 229 çağrı. Ama aynı zamanda, klasördeki tüm öğelerin numaralandırılmasından kaçınmanın mümkün olduğunu umuyorum. Katılıyorum, yine de gereksiz iş yürütüyor. Sen öyle düşünmüyor musun?

Tüm araştırmalardan sonra, saf .NET altında daha fazla optimizasyonun imkansız olduğu sonucuna vardım. WinAPI'nin FindFirstFile işlevi ile oynayacağım . Umarım yardımcı olur.

Bir süre alt dizinlerde herhangi bir dosya olup olmadığını doğrulamak ve bu boş alt dizinleri yok saymak isteyebilirsiniz; bu durumda aşağıdaki yöntemi kullanabilirsiniz:

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

Merkezli Brad Parkı kodu:

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

Kodum inanılmaz klasörde 34 dosya ile milisaniyeden daha az 00: 00: 00.0007143 aldı

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

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

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

İşte bunu yapmanıza yardımcı olabilecek bir şey. Bunu iki iterasyonda yapmayı başardım.

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

Yine de bir DirectoryInfo nesnesiyle çalışacağınız için, bir uzantıyla giderim

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

Bunu kullan. Basit.

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