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

382

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?

SnAzBaZ
quelle
8
Kann jemand den Fragentitel bearbeiten, um "vorhandene" Datei / Verzeichnis anzugeben ? Alle Antworten gelten für einen Pfad für eine Datei / ein Verzeichnis auf der Festplatte.
Jake Berger
1
@jberger bitte beziehen Sie sich auf meine Antwort unten. Ich habe einen Weg gefunden, dies für Pfade von Dateien / Ordnern zu erreichen, die möglicherweise vorhanden sind oder nicht.
lhan
Wie bevölkern Sie diese Baumansicht? Wie kommst du da raus?
Random832

Antworten:

595

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");
Quinn Wilson
quelle
8
+1 Dies ist der bessere Ansatz und deutlich schneller als die von mir vorgeschlagene Lösung.
Andrew Hare
6
@ KeyMs92 Seine bitweise Mathematik. Grundsätzlich ist attr ein Binärwert mit einem Bit, was "dies ist ein Verzeichnis" bedeutet. Der bitweise &Operator und der Operator geben einen Binärwert zurück, bei dem nur die Bits aktiviert sind, die in beiden Operanden aktiviert sind (1). In diesem Fall führt eine bitweise Operation und eine Operation gegen attrund der FileAttributes.DirectoryWert den Wert zurück, FileAttributes.Directorywenn das Attributbit der Verzeichnisdatei aktiviert ist. Eine bessere Erklärung finden Sie unter en.wikipedia.org/wiki/Bitwise_operation .
Kyle Trauberman
6
@jberger Wenn der Pfad nicht existiert, ist es nicht eindeutig, ob C:\Tempauf ein Verzeichnis namens Tempoder eine Datei namens verwiesen wird Temp. Was soll der Code tun?
ta.speot.is
26
@Key: Kann nach .NET 4.0 attr.HasFlag(FileAttributes.Directory)stattdessen verwendet werden.
Şafak Gür
13
@ ŞafakGür: Mach das nicht in einer zeitkritischen Schleife. attr.HasFlag () ist langsam wie die Hölle und verwendet Reflection für jeden Aufruf
springy76
247

Wie wäre es mit diesen?

File.Exists();
Directory.Exists();
llamaoo7
quelle
43
Dies hat im Gegensatz dazu auch den Vorteil, dass auf einem ungültigen Pfad keine Ausnahme ausgelöst wird File.GetAttributes().
Deanna
Ich verwende in meinem Projekt die Long Path-Bibliothek von BCL bcl.codeplex.com/… , sodass es keine Möglichkeit gibt, Dateiattribute abzurufen , aber das Aufrufen von Exist ist eine gute Problemumgehung .
Puterdo Borato
4
@jberger Ich würde erwarten, dass es NICHT für Pfade zu nicht existierenden Dateien / Ordnern funktioniert. File.Exists ("c: \\ temp \\ nonexistant.txt") sollte wie folgt false zurückgeben.
Michaelkoss
12
Wenn Sie sich Sorgen über nicht vorhandene Dateien / Ordner machen, versuchen Sie dies public static bool? IsDirectory(string path){ if (Directory.Exists(path)) return true; // is a directory else if (File.Exists(path)) return false; // is a file else return null; // is a nothing }
Dustin Townsend
1
Weitere Details hierzu finden Sie unter msdn.microsoft.com/en-us/library/…
Moji
20

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

File.GetAttributes(data.Path).HasFlag(FileAttributes.Directory)
Gerard Gilabert Kanal
quelle
4
Beachten Sie, dass Sie dafür mindestens .NET 4.0 benötigen. Dies explodiert auch, wenn der Pfad kein gültiger Pfad ist.
Nawfal
Verwenden Sie ein FileInfo-Objekt, um zu überprüfen, ob der Pfad vorhanden ist: FileInfo pFinfo = new FileInfo (FList [0]); if (pFinfo.Exists) {if (File.GetAttributes (FList [0]). HasFlag (FileAttributes.Directory)) {}}. Dieser arbeitet für mich.
Michael Stimson
Wenn Sie bereits ein FileInfo-Objekt erstellt haben und die Exists-Eigenschaft der Instanz verwenden, können Sie auf die Attributes-Eigenschaft zugreifen, anstatt die statische File.GetAttributes () -Methode zu verwenden.
Dynamichael
10

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.

Ronnie Overby
quelle
3
Technisch sollten Sie Path.DirectorySeparatorCharundPath.AltDirectorySeparatorChar
drzaus
1
Diese Idee, die Absicht zu erraten, ist interessant. IMHO besser in zwei Methoden aufzuteilen. Methode 1 führt die Existenztests durch und gibt einen nullbaren Booleschen Wert zurück. Wenn der Anrufer dann den Teil "Raten" für ein Null-Ergebnis von Eins möchte, rufen Sie Methode Zwei auf, die das Raten übernimmt.
ToolmakerSteve
2
Ich würde dies umschreiben, um ein Tupel zurückzugeben, ob es erraten hat oder nicht.
Ronnie Overby
1
"Wenn es eine Erweiterung hat, ist es eine Datei" - das ist nicht wahr. Eine Datei muss keine Erweiterung haben (auch nicht in Windows) und ein Verzeichnis kann eine "Erweiterung" haben. Dies kann beispielsweise eine Datei oder ein Verzeichnis sein: "C: \ New folder.log"
bytedev
2
@bytedev Ich weiß das, aber an diesem Punkt in der Funktion errät der Code die Absicht. Es gibt sogar einen Kommentar, der dies sagt. Die meisten Dateien haben eine Erweiterung. Die meisten Verzeichnisse tun dies nicht.
Ronnie Overby
7

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.

Michael A. McCloskey
quelle
2
Wie unterscheidet sich das von der anderen Antwort
Jake Berger
6
Anstelle dieses schrecklichen Logikblocks versuchen Sie esisDirectory = (fa & FileAttributes.Directory) != 0);
Immortal Blue
5

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

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;
}
drzaus
quelle
Path.DirectorySeparatorChar.ToString()statt string concat mit ""?
Gone Coding
@GoneCoding wahrscheinlich; Zu der Zeit hatte ich mit einer Reihe von nullbaren Eigenschaften gearbeitet, also habe ich mir angewöhnt, "mit leerer Zeichenfolge zu konzertieren", anstatt mir Gedanken über die Überprüfung auf null zu machen. Sie können auch das tun new String(Path.DirectorySeparatorChar, 1), was Sie tun ToString, wenn Sie wirklich optimiert werden möchten.
Drzaus
4

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);
}
Scott Dorman
quelle
31
Hässlich. Ich hasse es, diese einfachen Aufgaben zu erledigen. Und es ist nicht tragbar. und es ist hässlich. Habe ich gesagt, dass es hässlich ist? :)
Ignacio Soler Garcia
5
@ SoMoS Es mag Ihrer Meinung nach "hässlich" sein, aber es ist immer noch der genaueste Ansatz. Ja, es ist keine tragbare Lösung, aber das war nicht die Frage.
Scott Dorman
8
Was meinst du genau mit genau? Es liefert die gleichen Ergebnisse wie die Antwort von Quinn Wilson und erfordert Interop, wodurch die Portabilität beeinträchtigt wird. Für mich ist es genauso genau wie die anderen Lösungen und hat Nebenwirkungen, die andere nicht haben.
Ignacio Soler Garcia
7
Hierfür gibt es eine Framework-API. Die Verwendung von Interop ist nicht der richtige Weg.
TomXP411
5
Ja, das funktioniert, aber es ist NICHT die "genaueste" Lösung - nicht mehr als die Verwendung des vorhandenen .NET Framework. Stattdessen verwenden Sie 6 Codezeilen, um zu ersetzen, was in einer Zeile mit .NET Framework möglich ist, und beschränken sich darauf, nur Windows zu verwenden, anstatt die Möglichkeit offen zu lassen, dies mit dem Mono-Projekt zu portieren. Verwenden Sie Interop niemals, wenn .NET Framework eine elegantere Lösung bietet.
Russ
2

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

  }

}
PMBottas
quelle
2

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!

lhan
quelle
1
Haben Sie die Path.HasExtension- Methode ausprobiert ?
Jake Berger
Wenn es nicht existiert, ist es keine Datei oder ein Verzeichnis. Jeder Name kann als einer von beiden erstellt werden. Wenn Sie beabsichtigen, es zu erstellen, sollten Sie wissen, was Sie erstellen, und wenn nicht, warum könnten Sie diese Informationen möglicherweise benötigen?
Random832
8
Ein Ordner kann benannt werden test.txtund eine Datei kann benannt werden test- in diesen Fällen der Code falsche Ergebnisse zurückgeben würde
Stephan Bauer
2
In den Klassen System.IO.FIle und System.IO.Directory gibt es eine .Exists-Methode. das ist die Sache zu tun. Verzeichnisse können Erweiterungen haben. Ich sehe es häufig.
TomXP411
2

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 ...

MaxOvrdrv
quelle
2
Funktioniert nicht mit, System.IO.FileSystemWatcherda beim Löschen eines Verzeichnisses c:\my_directoryein Argument gesendet wird, das beim c:\my_directoryLöschen einer Datei ohne Erweiterung identisch ist.
Ray Cheng
GetDirectoryName('C:\SomeFolder')kehrt zurück 'C:\', sodass Ihr letzter Fall nicht funktioniert. Dies unterscheidet nicht zwischen Verzeichnissen und Dateien ohne Erweiterungen.
Lucy
Sie gehen fälschlicherweise davon aus, dass ein Verzeichnispfad immer das endgültige "\" enthält. Path.GetDirectoryName("C:\SomeFolder\SomeSubFolder")Wird zum Beispiel zurückkehren C:\SomeFolder. Beachten Sie, dass Ihre eigenen Beispiele für die Rückgabe von GetDirectoryName zeigen, dass ein Pfad zurückgegeben wird, der nicht mit einem Backslash endet. Das heißt, wenn jemand GetDirectoryName an anderer Stelle verwendet, um einen Verzeichnispfad abzurufen, und ihn dann Ihrer Methode zuführt, erhält er die falsche Antwort.
ToolmakerSteve
1

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)) 
Jamie
quelle
1

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;
Joe Stellato
quelle
0

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;
}
Stu1983
quelle
1
FileInfo Extension ist (IMAO) eine gute Option, um nicht vorhandene Pfade zu überprüfen
dataCore
2
Ihre zweite Bedingung (sonst) stinkt. Wenn es sich nicht um eine vorhandene Datei handelt, wissen Sie nicht, was es möglicherweise sein könnte (Verzeichnisse können auch mit so etwas wie ".txt" enden).
Nawfal
0
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));
          }
     }
}
Diaa Eddin
quelle
0

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;
    }
Mike Socha III
quelle
Scheint etwas verschwenderisch, nach den Attributen zu suchen, nachdem bereits nach Directory / File Exists () gesucht wurde? Allein diese beiden Anrufe erledigen die hier erforderliche Arbeit.
Gone Coding
0

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;
    }
Minute V.
quelle
0

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 ...

dba
quelle
0

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
    }
}
martinthebeardy
quelle
-4

Würde das nicht funktionieren?

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

quelle
1
Dies würde nicht nur funktionieren, weil
Ordnernamen Punkte enthalten
Außerdem müssen Dateien keine Punkte enthalten.
Keith Pinson