[C#] Bessere Möglichkeit zu überprüfen, ob ein Pfad eine Datei oder ein Verzeichnis ist?


Answers

Wie wäre es mit diesen?

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

Ich verarbeite eine TreeView von Verzeichnissen und Dateien. Ein Benutzer kann entweder eine Datei oder ein Verzeichnis auswählen und dann etwas damit machen. Dies erfordert, dass ich eine Methode habe, die verschiedene Aktionen basierend auf der Auswahl des Benutzers 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 mir nicht helfen zu fühlen, dass es einen besseren Weg gibt, dies zu tun! Ich hatte gehofft, eine Standard-.NET-Methode zu finden, um das zu handhaben, aber ich war dazu nicht in der Lage. Gibt es eine solche Methode, und wenn nicht, was ist das einfachste Mittel, um zu bestimmen, ob ein Pfad eine Datei oder ein Verzeichnis ist?




Soooo spät im Spiel, ich weiß, aber ich dachte, ich würde es trotzdem teilen. Wenn Sie ausschließlich mit den Pfaden als Strings arbeiten, ist es 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 das würde auch ohne den folgenden ThePath == "C:\SomeFolder" Schrägstrich ThePath == "C:\SomeFolder" : ThePath == "C:\SomeFolder" würde am Ende folgendes sein:

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

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




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



Wenn Sie nach Verzeichnissen suchen möchten, einschließlich derjenigen, die mit "Versteckt" und "System" gekennzeichnet sind, versuchen Sie Folgendes (erfordert .NET V4):

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



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

  }

}



Mit der ausgewählten Antwort auf diesen Beitrag habe ich mir die Kommentare angeschaut und @ SafakGür, @Anthony und @Quinn Wilson für ihre Informationsbits, die mich zu dieser verbesserten Antwort geführt haben, 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;
    }



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 ist ähnlich wie die Antworten anderer, aber nicht genau gleich.




Der genaueste Ansatz besteht darin, einen Interop-Code aus der shlwapi.dll zu verwenden

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



Dies verwendet DirectoryInfo, um das Attribut abzurufen

Dim newnode As TreeNode
Dim dirs As New DirectoryInfo(node.FullPath)
For Each dir As DirectoryInfo In dirs.GetDirectories()
    If dir.Attributes = FileAttributes.Directory Then

    Else

    End If
Next

Dies funktioniert, wenn Sie DirectoryInfo versuchen, eine TreeView zu erstellen oder eine TreeView zu lesen