Besser prüfen, ob ein Pfad eine Datei oder ein Verzeichnis ist?

Ich verarbeite a TreeView von Verzeichnissen und Dateien. Ein Benutzer kann entweder eine Datei oder ein Verzeichnis auswählen und dann etwas damit tun. Dies erfordert eine Methode, die je nach Auswahl des Benutzers verschiedene Aktionen ausführt.

Im Moment mache ich so etwas, um festzustellen, ob der Pfad eine Datei oder ein Verzeichnis ist:

bool bIsFile = false;
bool bIsDirectory = false;

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

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

Ich kann nicht anders, als das Gefühl zu haben, dass es einen besseren Weg gibt, dies zu tun! Ich hatte gehofft, eine Standard-.NET-Methode zu finden, um dies zu handhaben, aber ich war nicht in der Lage, dies zu tun. Gibt es eine solche Methode, und wenn nicht, was ist das einfachste Mittel, um festzustellen, ob ein Pfad eine Datei oder ein Verzeichnis ist?

Von So erkennen Sie, ob der Pfad eine Datei oder ein Verzeichnis ist :

// 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");

Update für .NET 4.0+

Wenn Sie unter .NET 4.0 oder höher arbeiten (und die maximale Leistung nicht kritisch ist), können Sie den Code gemäß den folgenden Kommentaren sauberer schreiben:

// 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");

Wie wäre es mit diesen?

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

Mit nur dieser Zeile können Sie erhalten, ob ein Pfad ein Verzeichnis oder eine Datei ist:

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

Hier ist meins:

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

Es ähnelt den Antworten anderer, ist aber nicht genau gleich.

Alternativ zu Directory.Exists () können Sie die File.GetAttributes () -Methode verwenden, um die Attribute einer Datei oder eines Verzeichnisses abzurufen. So können Sie eine Hilfsmethode wie die folgende erstellen:

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

Sie können auch ein Objekt zur Tag-Eigenschaft des TreeView-Steuerelements hinzufügen, wenn Sie das Steuerelement füllen, das zusätzliche Metadaten für das Element enthält. Sie können beispielsweise ein FileInfo-Objekt für Dateien und ein DirectoryInfo-Objekt für Verzeichnisse hinzufügen und dann in der Tag-Eigenschaft auf den Elementtyp testen, um zusätzliche Systemaufrufe zu sparen, um diese Daten beim Klicken auf das Element abzurufen.

Dies war das Beste, was ich angesichts des Verhaltens der Eigenschaften Exists und Attribute finden konnte:

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

So testet es:

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

Nachdem ich die Vorschläge aus den anderen Antworten kombiniert hatte, stellte ich fest, dass ich ungefähr das Gleiche fand wie Ronnie Overbys Antwort . Hier sind einige Tests, um auf einige Dinge hinzuweisen, über die Sie nachdenken sollten:

1. Ordner können "Erweiterungen" haben: C:\Temp\folder_with.dot
2. Dateien können nicht mit einem Verzeichnistrennzeichen (Schrägstrich) enden.
3. Es gibt technisch zwei Verzeichnis Separatoren , die plattformspezifisch sind - also kann oder nicht Schrägstriche sein ( Path.DirectorySeparatorCharund Path.AltDirectorySeparatorChar)

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

Ergebnisse

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 

Methode

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

Der genaueste Ansatz ist die Verwendung von Interop-Code aus der shlwapi.dll

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

Sie würden es dann so nennen:

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

Folgendes verwenden wir:

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

  }

}

Ich bin darauf gestoßen, als ich auf ein ähnliches Problem gestoßen bin, außer dass ich überprüfen musste, ob ein Pfad für eine Datei oder einen Ordner vorhanden ist, wenn diese Datei oder dieser Ordner möglicherweise nicht vorhanden ist . Zu den obigen Antworten gab es einige Kommentare, in denen erwähnt wurde, dass sie für dieses Szenario nicht funktionieren würden. Ich habe eine Lösung gefunden (ich verwende VB.NET, aber Sie können sie bei Bedarf konvertieren), die für mich gut zu funktionieren scheint:

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

Hoffentlich kann dies jemandem helfen!

Soooo spät im Spiel weiß ich, aber ich dachte, ich würde das trotzdem teilen. Wenn Sie nur mit den Pfaden als Zeichenfolgen arbeiten, ist es ganz einfach, dies herauszufinden:

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

Zum Beispiel: ThePath == "C:\SomeFolder\File1.txt"würde am Ende folgendes sein:

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

Ein anderes Beispiel: ThePath == "C:\SomeFolder\"würde am Ende folgendes sein:

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

Und dies würde auch ohne den nachfolgenden Backslash funktionieren: ThePath == "C:\SomeFolder"Am Ende wäre dies:

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

Denken Sie hier daran, dass dies nur mit den Pfaden selbst funktioniert und nicht mit der Beziehung zwischen dem Pfad und der "physischen Festplatte". Sie können also nicht sagen, ob der Pfad / die Datei vorhanden ist oder ähnliches, aber es ist sicher kann Ihnen sagen, ob der Pfad ein Ordner oder eine Datei ist ...

Wenn Sie Verzeichnisse suchen möchten, einschließlich solcher, die als "versteckt" und "system" gekennzeichnet sind, versuchen Sie Folgendes (erfordert .NET V4):

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

Ich brauchte das, die Beiträge haben geholfen, das bringt es auf eine Zeile, und wenn der Pfad überhaupt kein Pfad ist, kehrt er einfach zurück und beendet die Methode. Es behebt alle oben genannten Probleme und benötigt auch keinen abschließenden Schrägstrich.

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

Ich verwende Folgendes, es testet auch die Erweiterung, was bedeutet, dass es zum Testen verwendet werden kann, ob der angegebene Pfad eine Datei ist, aber eine Datei, die nicht existiert.

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

Unter Verwendung der ausgewählten Antwort in diesem Beitrag habe ich mir die Kommentare angesehen und @ ŞafakGür, @Anthony und @Quinn Wilson für ihre Infobits, die mich zu dieser verbesserten Antwort führten, die ich geschrieben und getestet habe, Glauben geschenkt:

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

Vielleicht für UWP C #

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

Ich sehe, ich bin 10 Jahre zu spät zur Party. Ich war mit der Situation konfrontiert, dass ich von einer Eigenschaft entweder einen Dateinamen oder einen vollständigen Dateipfad erhalten kann. Wenn kein Pfad angegeben ist, muss ich die Dateiexistenz überprüfen, indem ich einen "globalen" Verzeichnispfad anhänge, der von einer anderen Eigenschaft bereitgestellt wird.

In meinem Fall

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

hat den Trick gemacht. Ok, es ist keine Magie, aber vielleicht könnte dies jemandem ein paar Minuten Zeit sparen, um es herauszufinden. Da dies nur ein String-Parsing ist, können Dir-Namen mit Punkten falsch positive Ergebnisse liefern ...

Sehr spät zur Party hier, aber ich fand den Nullable<Boolean>Rückgabewert ziemlich hässlich - das IsDirectory(string path)Zurückgeben nullentspricht nicht einem nicht existierenden Pfad ohne ausführliche Kommentare, daher habe ich mir Folgendes ausgedacht:

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

Diese Hilfsmethode ist so geschrieben, dass sie ausführlich und präzise genug ist, um die Absicht beim ersten Lesen zu verstehen.

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

Würde das nicht funktionieren?

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