检查路径是文件还是目录的更好方法?


382

我正在处理TreeView目录和文件。用户可以选择文件或目录,然后对其进行操作。这就要求我有一种根据用户的选择执行不同动作的方法。

目前,我正在执行以下操作来确定路径是文件还是目录:

bool bIsFile = false;
bool bIsDirectory = false;

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

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

我不禁感到有更好的方法可以做到这一点!我希望找到一种标准的.NET方法来处理此问题,但我一直未能做到这一点。是否存在这种方法,如果不存在,那么确定路径是文件还是目录的最直接方法是什么?


8
有人可以编辑问题标题以指定“现有”文件/目录吗?所有答案都适用于磁盘上文件/目录的路径。
杰克·伯杰

1
@jberger请参阅下面的我的答案。我找到了一种方法来解决可能存在或不存在的文件/文件夹的路径。
lhan 2012年


您如何填充此树形视图?您如何摆脱困境?
Random832

Answers:


594

如何判断路径是文件还是目录

// 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+的更新

根据以下注释,如果您使用的是.NET 4.0或更高版本(并且最高性能并不关键),则可以采用一种更简洁的方式编写代码:

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

8
+1这是更好的方法,比我提出的解决方案快得多。
Andrew Hare

6
@ KeyMs92按位数学。基本上,attr是一个二进制值,只有一位,表示“这是目录”。按位和&运算符将返回一个二进制值,其中仅打开两个操作数中的位(1)。在这种情况下,如果Directory文件属性位已打开,则对attr和进行按位运算并FileAttributes.Directory返回的值FileAttributes.Directory。有关详细说明,请参见en.wikipedia.org/wiki/Bitwise_operation
凯尔·特劳伯曼

6
@jberger如果该路径不存在,则是否C:\Temp指向一个名为Temp还是文件名为Temp。代码是做什么的?
ta.speot.is

26
@Key:在.NET 4.0之后,attr.HasFlag(FileAttributes.Directory)可以代替使用。
Şafak古尔

13
@ŞafakGür:不要在时间敏感的循环内执行此操作。attr.HasFlag()慢如地狱,每次调用都使用反射
springy76

247

如何使用这些?

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

43
与相比,这还具有不会在无效路径上引发异常的优点File.GetAttributes()
Deanna

我在项目中使用BCLbcl.codeplex.com/…中的Long Path库,因此无法获取文件属性,但是调用Exist是一个不错的解决方法。
Puterdo Borato

4
@jberger我希望它不适用于不存在的文件/文件夹的路径。File.Exists(“ c:\\ temp \\ nonexistant.txt”)应该返回false,就像这样。
michaelkoss 2012年

12
如果您担心不存在的文件/文件夹,请尝试此 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 2014年

1
有关此问题的更多详细信息,请访问msdn.microsoft.com/en-us/library/…–
Moji

20

仅使用此行,您可以获取路径是目录还是文件:

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

4
请注意,您至少需要.NET 4.0。如果path不是有效路径,这也会爆炸。
nawfal

使用FileInfo对象检查路径是否存在:FileInfo pFinfo = new FileInfo(FList [0]); if(pFinfo.Exists){if(File.GetAttributes(FList [0])。HasFlag(FileAttributes.Directory)){}}。这对我有用。
Michael Stimson

如果您已经创建了FileInfo对象,并且正在使用实例的Exists属性,为什么不访问其Attributes属性而不是使用静态File.GetAttributes()方法呢?
dynamichael

10

这是我的:

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

它与其他人的答案相似,但不完全相同。


3
从技术上讲,您应该使用Path.DirectorySeparatorCharandPath.AltDirectorySeparatorChar
drzaus

1
这个意图的想法很有趣。恕我直言,最好分为两种方法。方法一进行了存在性测试,返回一个可为空的布尔值。如果调用方然后想要“猜测”部分,则返回One的空结果,然后调用方法2,进行猜测。
ToolmakerSteve

2
我会重写它以返回一个元组,无论是否猜测。
罗尼·奥弗比

1
“如果具有扩展名,则为其扩展名”-这不是正确的。文件不必具有扩展名(即使在Windows中),目录也可以具有“扩展名”。例如,这可以是文件或目录:“ C:\ New folder.log”
bytedev

2
@bytedev我知道,但是在函数的这一点上,代码正在猜测意图。甚至有评论说。大多数文件都有扩展名。大多数目录没有。
罗尼·奥弗比

7

作为Directory.Exists()的替代方法,可以使用File.GetAttributes()方法获取文件或目录的属性,因此可以创建如下的帮助方法:

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

在填充包含该项目的其他元数据的控件时,您还可以考虑将一个对象添加到TreeView控件的tag属性中。例如,您可以为文件添加FileInfo对象,为目录添加DirectoryInfo对象,然后在tag属性中测试项目类型,以节省在单击项目时进行额外的系统调用以获取该数据的过程。


2
与其他答案
杰克·伯杰

6
与其尝试那种可怕的逻辑,不如尝试isDirectory = (fa & FileAttributes.Directory) != 0);
不朽之蓝

5

考虑到Exists and Attributes属性的行为,这是我能想到的最好的方法:

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

测试方法如下:

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

5

结合其他答案的建议后,我意识到我想到了与Ronnie Overby的答案相同的东西。以下是一些测试,指出了一些需要考虑的事项:

  1. 文件夹可以具有“扩展名”: C:\Temp\folder_with.dot
  2. 文件不能以目录分隔符(斜杠)结尾
  3. 从技术上讲,有两个特定于平台的目录分隔符-即可以是斜线(和),也可以不是Path.DirectorySeparatorCharPath.AltDirectorySeparatorChar

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

结果

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 

方法

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

Path.DirectorySeparatorChar.ToString()而不是用""
Gone Coding

@GoneCoding可能;当时我一直在使用一堆可为null的属性,所以我养成了“用空字符串concat”的习惯,而不用担心检查null。你也可以做new String(Path.DirectorySeparatorChar, 1)的那是什么ToString呢,如果你想获得真正的优化。
drzaus

4

最准确的方法是使用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);

然后,您可以这样称呼它:

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

31
丑陋。我讨厌互操作来完成这些简单的任务。而且它不是便携式的。而且很丑。我是说丑陋吗?:)
Ignacio Soler Garcia

5
@SoMoS您认为这可能是“丑陋”的,但它仍然是最准确的方法。是的,它不是便携式解决方案,但这不是问题要问的。
Scott Dorman

8
您准确的意思是什么?它提供的结果与奎因·威尔逊(Quinn Wilson)的答案相同,并且需要互操作性,这破坏了可移植性。对我来说,它与其他解决方案一样准确,并且具有其他解决方案没有的副作用。
Ignacio Soler Garcia

7
有一个框架API可以做到这一点。使用Interop并非可行之路。
TomXP411

5
是的,这是可行的,但它不是“最准确”的解决方案,仅是使用现有的.NET Framework。取而代之的是,您需要6行代码来替换.NET Framework一行中可以完成的工作,并锁定自己仅使用Windows,而不是将其与Mono Project一起移植。.NET Framework提供更优雅的解决方案时,切勿使用Interop。
2015年

2

这是我们使用的:

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

  }

}

2

遇到类似问题时,我遇到了这个问题,只是当文件或文件夹可能实际上不存在时,我需要检查该文件或文件夹的路径是否存在。关于以上答案,有一些评论提到它们不适用于这种情况。我找到了一个似乎对我来说很好的解决方案(我使用VB.NET,但可以根据需要进行转换):

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

希望这对某人有帮助!


1
您是否尝试过Path.HasExtension方法?
杰克·伯杰

如果不存在,则它不是文件或目录。可以创建任何名称。如果您打算创建它,那么您应该知道您正在创建什么,如果您不知道,那么为什么您可能需要此信息?
Random832 2013年

8
文件夹可以被命名test.txt和文件可以被命名为test-在这些情况下,您的代码将返回不正确的结果
斯蒂芬·鲍尔

2
System.IO.FIle和System.IO.Directory类中有一个.Exists方法。那就是要做的事情。目录可以有扩展名;我经常看到它。
TomXP411

2

我知道在游戏后期很晚,但以为我还是会分享这一点。如果仅将路径作为字符串来使用,则很容易理解这一点:

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

例如: ThePath == "C:\SomeFolder\File1.txt"最终将是这样:

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

另一个例子: ThePath == "C:\SomeFolder\"最终将是这样:

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

而且这也可以在没有反斜杠的情况下起作用: ThePath == "C:\SomeFolder"最终将是这样:

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

请记住,这仅适用于路径本身,而不适用于路径与“物理磁盘”之间的关系...因此它无法告诉您路径/文件是否存在或类似的东西,但是可以确定可以告诉您路径是文件夹还是文件...


2
不能使用,System.IO.FileSystemWatcher因为删除目录时,它将c:\my_directory作为自变量发送,而删除无扩展名的文件时,该参数是相同的c:\my_directory
Ray Cheng

GetDirectoryName('C:\SomeFolder')返回'C:\',因此您的最后一种情况不起作用。这不能区分没有扩展名的目录和文件。
露西

您错误地认为目录路径将始终包含最后的“ \”。例如,Path.GetDirectoryName("C:\SomeFolder\SomeSubFolder")将返回C:\SomeFolder。请注意,你自己有什么GetDirectoryName回报的例子表明,它返回它的路径不能以反斜线结束。这意味着,如果有人在其他地方使用GetDirectoryName来获取目录路径,然后将其提供给您的方法,他们将得到错误的答案。
ToolmakerSteve

1

如果要查找目录,包括标记为“隐藏”和“系统”的目录,请尝试以下操作(需要.NET V4):

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

1

我需要这个,帖子帮助了,这使它下降到了一行,如果该路径根本不是路径,它只会返回并退出该方法。它解决了上述所有问题,也不需要结尾的斜杠。

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

0

我使用以下内容,它还测试了扩展名,这意味着它可以用于测试提供的路径是否是文件但不存在的文件。

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

1
FileInfo Extension(IMAO)是检查不存在的路径的好选择
dataCore 2013年

2
您的第二个条件(其他)很臭。如果它不是现有文件,则您可能不知道它可能是什么(目录也可以以“ .txt”结尾)。
nawfal 2013年

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

0

使用本文中选定的答案,我查看了评论并给予@ŞafakGür,@ Anthony和@Quinn Wilson的信任,以使他们了解到一些信息,使我获得了我编写和测试的改进答案:

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

在已经检查过Directory / File Exists()之后检查属性似乎有点浪费?仅这两个调用即可完成此处所需的所有工作。
Gone Coding

0

也许对于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;
    }

0

我知道,我参加聚会已经晚了10年。我遇到的情况是,从某些属性中我可以接收文件名或完整文件路径。如果没有提供路径,我必须通过附加另一个属性提供的“全局”目录路径来检查文件是否存在。

就我而言

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

做到了。好的,这不是魔术,但这也许可以节省某人几分钟的时间。由于这只是一个字符串解析,因此带点的Dir名称可能会带来误报...


0

在这里参加聚会很晚,但是我发现Nullable<Boolean>返回值非常丑陋- IsDirectory(string path)返回null不等于没有冗长注释的不存在路径,因此我提出了以下建议:

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

该辅助方法写得很详细,简洁,足以在您初次阅读时理解其意图。

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

-4

这行不行吗?

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

1
这样做不仅仅因为文件夹名称中可以包含句点
KSib,2016年

此外,文件中不必包含句点。
基思·品森
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.