Bir Yolun Dosya veya Dizin olup olmadığını kontrol etmenin daha iyi bir yolu var mı?

Bir TreeViewdizin ve dosya işliyorum. Bir kullanıcı bir dosya veya dizin seçebilir ve ardından onunla bir şeyler yapabilir. Bu, kullanıcının seçimine göre farklı eylemler gerçekleştiren bir yönteme sahip olmamı gerektirir.

Şu anda yolun bir dosya veya dizin olup olmadığını belirlemek için böyle bir şey yapıyorum:

bool bIsFile = false;
bool bIsDirectory = false;

try
{
    string[] subfolders = Directory.GetDirectories(strFilePath);

    bIsDirectory = true;
    bIsFile = false;
}
catch(System.IO.IOException)
{
    bIsFolder = false;
    bIsFile = true;
}

Bunu yapmanın daha iyi bir yolu olduğunu hissetmek için yardım edemem! Bunu idare etmek için standart bir .NET yöntemi bulmayı umuyordum, ancak bunu yapamadım. Böyle bir yöntem var mı ve yoksa, bir yolun dosya veya dizin olup olmadığını belirlemenin en kolay yolu nedir?

Gönderen nasıl yol dosya veya dizin olup olmadığını söylemek için :

// get the file attributes for file or directory
FileAttributes attr = File.GetAttributes(@"c:\Temp");

//detect whether its a directory or file
if ((attr & FileAttributes.Directory) == FileAttributes.Directory)
    MessageBox.Show("Its a directory");
else
    MessageBox.Show("Its a file");

.NET 4.0+ için güncelleştirme

Aşağıdaki yorumlara göre, .NET 4.0 veya sonraki bir sürümdeyseniz (ve maksimum performans kritik değilse) kodu daha temiz bir şekilde yazabilirsiniz:

// get the file attributes for file or directory
FileAttributes attr = File.GetAttributes(@"c:\Temp");

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

Bunları kullanmaya ne dersiniz?

File.Exists();
Directory.Exists();

Yalnızca bu satırla, bir yol bir dizin veya dosyaysa elde edebilirsiniz:

File.GetAttributes(data.Path).HasFlag(FileAttributes.Directory)

Benimki burada:

    bool IsPathDirectory(string path)
    {
        if (path == null) throw new ArgumentNullException("path");
        path = path.Trim();

        if (Directory.Exists(path)) 
            return true;

        if (File.Exists(path)) 
            return false;

        // neither file nor directory exists. guess intention

        // if has trailing slash then it's a directory
        if (new[] {"\\", "/"}.Any(x => path.EndsWith(x)))
            return true; // ends with slash

        // if has extension then its a file; directory otherwise
        return string.IsNullOrWhiteSpace(Path.GetExtension(path));
    }

Başkalarının cevaplarına benzer, ancak tam olarak aynı değildir.

Directory.Exists () yöntemine alternatif olarak, bir dosyanın veya dizinin özniteliklerini almak için File.GetAttributes () yöntemini kullanabilirsiniz, böylece böyle bir yardımcı yöntem oluşturabilirsiniz:

private static bool IsDirectory(string path)
{
    System.IO.FileAttributes fa = System.IO.File.GetAttributes(path);
    return (fa & FileAttributes.Directory) != 0;
}

Ayrıca, öğe için ek meta veriler içeren denetimi doldururken TreeView denetiminin tag özelliğine bir nesne eklemeyi de düşünebilirsiniz. Örneğin, dosyalar için bir FileInfo nesnesi ve dizinler için bir DirectoryInfo nesnesi ekleyebilir ve ardından öğeye tıkladığınızda bu verileri almak için ek sistem çağrıları yapmak üzere tag özelliğinde öğe türünü test edebilirsiniz.

Bu, Var Olanlar ve Nitelikler özelliklerinin davranışı göz önüne alındığında gelebileceğim en iyisiydi:

using System.IO;

public static class FileSystemInfoExtensions
{
    /// <summary>
    /// Checks whether a FileInfo or DirectoryInfo object is a directory, or intended to be a directory.
    /// </summary>
    /// <param name="fileSystemInfo"></param>
    /// <returns></returns>
    public static bool IsDirectory(this FileSystemInfo fileSystemInfo)
    {
        if (fileSystemInfo == null)
        {
            return false;
        }

        if ((int)fileSystemInfo.Attributes != -1)
        {
            // if attributes are initialized check the directory flag
            return fileSystemInfo.Attributes.HasFlag(FileAttributes.Directory);
        }

        // If we get here the file probably doesn't exist yet.  The best we can do is 
        // try to judge intent.  Because directories can have extensions and files
        // can lack them, we can't rely on filename.
        // 
        // We can reasonably assume that if the path doesn't exist yet and 
        // FileSystemInfo is a DirectoryInfo, a directory is intended.  FileInfo can 
        // make a directory, but it would be a bizarre code path.

        return fileSystemInfo is DirectoryInfo;
    }
}

İşte nasıl test ettiği:

    [TestMethod]
    public void IsDirectoryTest()
    {
        // non-existing file, FileAttributes not conclusive, rely on type of FileSystemInfo
        const string nonExistentFile = @"C:\TotallyFakeFile.exe";

        var nonExistentFileDirectoryInfo = new DirectoryInfo(nonExistentFile);
        Assert.IsTrue(nonExistentFileDirectoryInfo.IsDirectory());

        var nonExistentFileFileInfo = new FileInfo(nonExistentFile);
        Assert.IsFalse(nonExistentFileFileInfo.IsDirectory());

        // non-existing directory, FileAttributes not conclusive, rely on type of FileSystemInfo
        const string nonExistentDirectory = @"C:\FakeDirectory";

        var nonExistentDirectoryInfo = new DirectoryInfo(nonExistentDirectory);
        Assert.IsTrue(nonExistentDirectoryInfo.IsDirectory());

        var nonExistentFileInfo = new FileInfo(nonExistentDirectory);
        Assert.IsFalse(nonExistentFileInfo.IsDirectory());

        // Existing, rely on FileAttributes
        const string existingDirectory = @"C:\Windows";

        var existingDirectoryInfo = new DirectoryInfo(existingDirectory);
        Assert.IsTrue(existingDirectoryInfo.IsDirectory());

        var existingDirectoryFileInfo = new FileInfo(existingDirectory);
        Assert.IsTrue(existingDirectoryFileInfo.IsDirectory());

        // Existing, rely on FileAttributes
        const string existingFile = @"C:\Windows\notepad.exe";

        var existingFileDirectoryInfo = new DirectoryInfo(existingFile);
        Assert.IsFalse(existingFileDirectoryInfo.IsDirectory());

        var existingFileFileInfo = new FileInfo(existingFile);
        Assert.IsFalse(existingFileFileInfo.IsDirectory());
    }

Diğer cevaplardan gelen önerileri birleştirdikten sonra, Ronnie Overby'nin cevabı ile aynı şeyi bulduğumu fark ettim . Düşünmeniz gereken bazı şeyleri gösteren bazı testler:

1. klasörlerde "uzantılar" bulunabilir: C:\Temp\folder_with.dot
2. dosyalar bir dizin ayırıcıyla (eğik çizgi) bitemez
3. Platforma özgü teknik olarak iki dizin ayırıcı vardır - yani eğik çizgiler ( ve ) olabilir veya olmayabilirPath.DirectorySeparatorCharPath.AltDirectorySeparatorChar

Testler (Linqpad)

var paths = new[] {
    // exists
    @"C:\Temp\dir_test\folder_is_a_dir",
    @"C:\Temp\dir_test\is_a_dir_trailing_slash\",
    @"C:\Temp\dir_test\existing_folder_with.ext",
    @"C:\Temp\dir_test\file_thats_not_a_dir",
    @"C:\Temp\dir_test\notadir.txt",
    // doesn't exist
    @"C:\Temp\dir_test\dne_folder_is_a_dir",
    @"C:\Temp\dir_test\dne_folder_trailing_slash\",
    @"C:\Temp\dir_test\non_existing_folder_with.ext",
    @"C:\Temp\dir_test\dne_file_thats_not_a_dir",
    @"C:\Temp\dir_test\dne_notadir.txt",        
};

foreach(var path in paths) {
    IsFolder(path/*, false*/).Dump(path);
}

Sonuçlar

C:\Temp\dir_test\folder_is_a_dir
  True 
C:\Temp\dir_test\is_a_dir_trailing_slash\
  True 
C:\Temp\dir_test\existing_folder_with.ext
  True 
C:\Temp\dir_test\file_thats_not_a_dir
  False 
C:\Temp\dir_test\notadir.txt
  False 
C:\Temp\dir_test\dne_folder_is_a_dir
  True 
C:\Temp\dir_test\dne_folder_trailing_slash\
  True 
C:\Temp\dir_test\non_existing_folder_with.ext
  False (this is the weird one)
C:\Temp\dir_test\dne_file_thats_not_a_dir
  True 
C:\Temp\dir_test\dne_notadir.txt
  False 

Yöntem

/// <summary>
/// Whether the <paramref name="path"/> is a folder (existing or not); 
/// optionally assume that if it doesn't "look like" a file then it's a directory.
/// </summary>
/// <param name="path">Path to check</param>
/// <param name="assumeDneLookAlike">If the <paramref name="path"/> doesn't exist, does it at least look like a directory name?  As in, it doesn't look like a file.</param>
/// <returns><c>True</c> if a folder/directory, <c>false</c> if not.</returns>
public static bool IsFolder(string path, bool assumeDneLookAlike = true)
{
    // /programming/1395205/better-way-to-check-if-path-is-a-file-or-a-directory
    // turns out to be about the same as https://stackoverflow.com/a/19596821/1037948

    // check in order of verisimilitude

    // exists or ends with a directory separator -- files cannot end with directory separator, right?
    if (Directory.Exists(path)
        // use system values rather than assume slashes
        || path.EndsWith("" + Path.DirectorySeparatorChar)
        || path.EndsWith("" + Path.AltDirectorySeparatorChar))
        return true;

    // if we know for sure that it's an actual file...
    if (File.Exists(path))
        return false;

    // if it has an extension it should be a file, so vice versa
    // although technically directories can have extensions...
    if (!Path.HasExtension(path) && assumeDneLookAlike)
        return true;

    // only works for existing files, kinda redundant with `.Exists` above
    //if( File.GetAttributes(path).HasFlag(FileAttributes.Directory) ) ...; 

    // no idea -- could return an 'indeterminate' value (nullable bool)
    // or assume that if we don't know then it's not a folder
    return false;
}

En doğru yaklaşım shlwapi.dll bazı birlikte çalışma kodu kullanmak olacak

[DllImport(SHLWAPI, CharSet = CharSet.Unicode)]
[return: MarshalAsAttribute(UnmanagedType.Bool)]
[ResourceExposure(ResourceScope.None)]
internal static extern bool PathIsDirectory([MarshalAsAttribute(UnmanagedType.LPWStr), In] string pszPath);

Daha sonra şöyle derdiniz:

#region IsDirectory
/// <summary>
/// Verifies that a path is a valid directory.
/// </summary>
/// <param name="path">The path to verify.</param>
/// <returns><see langword="true"/> if the path is a valid directory; 
/// otherwise, <see langword="false"/>.</returns>
/// <exception cref="T:System.ArgumentNullException">
/// <para><paramref name="path"/> is <see langword="null"/>.</para>
/// </exception>
/// <exception cref="T:System.ArgumentException">
/// <para><paramref name="path"/> is <see cref="F:System.String.Empty">String.Empty</see>.</para>
/// </exception>
public static bool IsDirectory(string path)
{
    return PathIsDirectory(path);
}

İşte ne kullanıyoruz:

using System;

using System.IO;

namespace crmachine.CommonClasses
{

  public static class CRMPath
  {

    public static bool IsDirectory(string path)
    {
      if (path == null)
      {
        throw new ArgumentNullException("path");
      }

      string reason;
      if (!IsValidPathString(path, out reason))
      {
        throw new ArgumentException(reason);
      }

      if (!(Directory.Exists(path) || File.Exists(path)))
      {
        throw new InvalidOperationException(string.Format("Could not find a part of the path '{0}'",path));
      }

      return (new System.IO.FileInfo(path).Attributes & FileAttributes.Directory) == FileAttributes.Directory;
    } 

    public static bool IsValidPathString(string pathStringToTest, out string reasonForError)
    {
      reasonForError = "";
      if (string.IsNullOrWhiteSpace(pathStringToTest))
      {
        reasonForError = "Path is Null or Whitespace.";
        return false;
      }
      if (pathStringToTest.Length > CRMConst.MAXPATH) // MAXPATH == 260
      {
        reasonForError = "Length of path exceeds MAXPATH.";
        return false;
      }
      if (PathContainsInvalidCharacters(pathStringToTest))
      {
        reasonForError = "Path contains invalid path characters.";
        return false;
      }
      if (pathStringToTest == ":")
      {
        reasonForError = "Path consists of only a volume designator.";
        return false;
      }
      if (pathStringToTest[0] == ':')
      {
        reasonForError = "Path begins with a volume designator.";
        return false;
      }

      if (pathStringToTest.Contains(":") && pathStringToTest.IndexOf(':') != 1)
      {
        reasonForError = "Path contains a volume designator that is not part of a drive label.";
        return false;
      }
      return true;
    }

    public static bool PathContainsInvalidCharacters(string path)
    {
      if (path == null)
      {
        throw new ArgumentNullException("path");
      }

      bool containedInvalidCharacters = false;

      for (int i = 0; i < path.Length; i++)
      {
        int n = path[i];
        if (
            (n == 0x22) || // "
            (n == 0x3c) || // <
            (n == 0x3e) || // >
            (n == 0x7c) || // |
            (n  < 0x20)    // the control characters
          )
        {
          containedInvalidCharacters = true;
        }
      }

      return containedInvalidCharacters;
    }


    public static bool FilenameContainsInvalidCharacters(string filename)
    {
      if (filename == null)
      {
        throw new ArgumentNullException("filename");
      }

      bool containedInvalidCharacters = false;

      for (int i = 0; i < filename.Length; i++)
      {
        int n = filename[i];
        if (
            (n == 0x22) || // "
            (n == 0x3c) || // <
            (n == 0x3e) || // >
            (n == 0x7c) || // |
            (n == 0x3a) || // : 
            (n == 0x2a) || // * 
            (n == 0x3f) || // ? 
            (n == 0x5c) || // \ 
            (n == 0x2f) || // /
            (n  < 0x20)    // the control characters
          )
        {
          containedInvalidCharacters = true;
        }
      }

      return containedInvalidCharacters;
    }

  }

}

Benzer bir sorunla karşılaştığımda buna rastladım, ancak o dosya veya klasör gerçekten mevcut olmadığında bir yolun bir dosya veya klasör için olup olmadığını kontrol etmem gerekiyordu . Bu senaryoda işe yaramayacaklarını belirten yukarıdaki cevaplar hakkında birkaç yorum vardı. Benim için iyi çalışıyor gibi görünüyor bir çözüm (VB.NET kullanın, ancak gerekirse dönüştürebilirsiniz) buldum:

Dim path As String = "myFakeFolder\ThisDoesNotExist\"
Dim bIsFolder As Boolean = (IO.Path.GetExtension(path) = "")
'returns True

Dim path As String = "myFakeFolder\ThisDoesNotExist\File.jpg"
Dim bIsFolder As Boolean = (IO.Path.GetExtension(path) = "")
'returns False

Umarım bu birisi için yararlı olabilir!

Soooo oyuna geç biliyorum, ama yine de paylaşacağımı düşündüm. Yalnızca yollarla dize olarak çalışıyorsanız, bunu bulmak pasta gibi kolaydır:

private bool IsFolder(string ThePath)
{
    string BS = Path.DirectorySeparatorChar.ToString();
    return Path.GetDirectoryName(ThePath) == ThePath.TrimEnd(BS.ToCharArray());
}

örneğin: ThePath == "C:\SomeFolder\File1.txt"sonuçta şu olur:

return "C:\SomeFolder" == "C:\SomeFolder\File1.txt" (FALSE)

Başka bir örnek: ThePath == "C:\SomeFolder\"sonunda bu olur:

return "C:\SomeFolder" == "C:\SomeFolder" (TRUE)

Ve bu da sondaki ters eğik çizgi olmadan da işe yarayacaktır ThePath == "C:\SomeFolder":

return "C:\SomeFolder" == "C:\SomeFolder" (TRUE)

Burada yolun "fiziksel disk" arasındaki ilişkiyle değil, yalnızca yollarla çalıştığını unutmayın ... bu nedenle yolun / dosyanın var olup olmadığını veya bunun gibi bir şey olup olmadığını söyleyemez, ancak yolun bir klasör mü yoksa bir dosya mı olduğunu söyleyebilir ...

"Gizli" ve "sistem" olarak işaretlenmiş dizinler de dahil olmak üzere dizinleri bulmak istiyorsanız, bunu deneyin (.NET V4 gerektirir):

FileAttributes fa = File.GetAttributes(path);
if(fa.HasFlag(FileAttributes.Directory)) 

Buna ihtiyacım vardı, gönderiler yardımcı oldu, bu bir satıra indirir ve yol hiç bir yol değilse, sadece döndürür ve yöntemden çıkar. Yukarıdaki tüm endişeleri giderir, sondaki eğik çizgiye de ihtiyaç duymaz.

if (!Directory.Exists(@"C:\folderName")) return;

Aşağıdakileri kullanıyorum, ayrıca uzantıyı test eder, bu da sağlanan yolun bir dosya olup olmadığını test etmek için kullanılabileceği anlamına gelir.

private static bool isDirectory(string path)
{
    bool result = true;
    System.IO.FileInfo fileTest = new System.IO.FileInfo(path);
    if (fileTest.Exists == true)
    {
        result = false;
    }
    else
    {
        if (fileTest.Extension != "")
        {
            result = false;
        }
    }
    return result;
}

using System;
using System.IO;
namespace FileOrDirectory
{
     class Program
     {
          public static string FileOrDirectory(string path)
          {
               if (File.Exists(path))
                    return "File";
               if (Directory.Exists(path))
                    return "Directory";
               return "Path Not Exists";
          }
          static void Main()
          {
               Console.WriteLine("Enter The Path:");
               string path = Console.ReadLine();
               Console.WriteLine(FileOrDirectory(path));
          }
     }
}

Bu yazıdaki seçilen cevabı kullanarak, yorumlara baktım ve yazdığım ve test ettiğim bu geliştirilmiş cevaba götüren bilgi bitleri için @ ŞafakGür, @Anthony ve @Quinn Wilson'a güveniyorum:

    /// <summary>
    /// Returns true if the path is a dir, false if it's a file and null if it's neither or doesn't exist.
    /// </summary>
    /// <param name="path"></param>
    /// <returns></returns>
    public static bool? IsDirFile(this string path)
    {
        bool? result = null;

        if(Directory.Exists(path) || File.Exists(path))
        {
            // get the file attributes for file or directory
            var fileAttr = File.GetAttributes(path);

            if (fileAttr.HasFlag(FileAttributes.Directory))
                result = true;
            else
                result = false;
        }

        return result;
    }

Belki UWP C # için

public static async Task<IStorageItem> AsIStorageItemAsync(this string iStorageItemPath)
    {
        if (string.IsNullOrEmpty(iStorageItemPath)) return null;
        IStorageItem storageItem = null;
        try
        {
            storageItem = await StorageFolder.GetFolderFromPathAsync(iStorageItemPath);
            if (storageItem != null) return storageItem;
        } catch { }
        try
        {
            storageItem = await StorageFile.GetFileFromPathAsync(iStorageItemPath);
            if (storageItem != null) return storageItem;
        } catch { }
        return storageItem;
    }

Anladım, partiye 10 yıl geç kaldım. Bazı özelliklerden bir dosya adı veya tam dosya yolu alabileceğim durumla karşı karşıyaydım. Sağlanan bir yol yoksa, başka bir özellik tarafından sağlanan "genel" bir dizin yolu ekleyerek dosya varlığını denetlemek zorunda.

Benim durumumda

var isFileName = System.IO.Path.GetFileName (str) == str;

hile yaptı. Tamam, bu sihir değil, ama belki de birileri birkaç dakika bulup kurtarabilir. Bu sadece bir dize-ayrıştırma olduğundan, noktalı Dir-isimleri yanlış pozitifler verebilir ...

Burada partiye çok geç ama Nullable<Boolean>dönüş değerini oldukça çirkin buldum - IsDirectory(string path)geri dönüş null, ayrıntılı yorum yapmadan var olmayan bir yola eşit değil, bu yüzden aşağıdakileri buldum:

public static class PathHelper
{
    /// <summary>
    /// Determines whether the given path refers to an existing file or directory on disk.
    /// </summary>
    /// <param name="path">The path to test.</param>
    /// <param name="isDirectory">When this method returns, contains true if the path was found to be an existing directory, false in all other scenarios.</param>
    /// <returns>true if the path exists; otherwise, false.</returns>
    /// <exception cref="ArgumentNullException">If <paramref name="path"/> is null.</exception>
    /// <exception cref="ArgumentException">If <paramref name="path"/> equals <see cref="string.Empty"/></exception>
    public static bool PathExists(string path, out bool isDirectory)
    {
        if (path == null) throw new ArgumentNullException(nameof(path));
        if (path == string.Empty) throw new ArgumentException("Value cannot be empty.", nameof(path));

        isDirectory = Directory.Exists(path);

        return isDirectory || File.Exists(path);
    }
}

Bu yardımcı yöntem, ilk okuduğunuzda niyeti anlayacak kadar ayrıntılı ve özlü olacak şekilde yazılmıştır.

/// <summary>
/// Example usage of <see cref="PathExists(string, out bool)"/>
/// </summary>
public static void Usage()
{
    const string path = @"C:\dev";

    if (!PathHelper.PathExists(path, out var isDirectory))
        return;

    if (isDirectory)
    {
        // Do something with your directory
    }
    else
    {
        // Do something with your file
    }
}

Bu işe yaramaz mı?

var isFile = Regex.IsMatch(path, @"\w{1,}\.\w{1,}$");