경로가 파일인지 디렉토리인지 확인하는 더 좋은 방법은 무엇입니까?


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
누군가 질문 제목을 편집하여 "기존" 파일 / 디렉토리 를 지정할 수 있습니까 ? 모든 답변은 디스크에있는 파일 / 디렉토리의 경로에 적용됩니다.
Jake Berger 2016 년

1
@jberger 아래 내 답변을 참조하십시오. 존재하거나 존재하지 않는 파일 / 폴더의 경로에 대해 이것을 수행하는 방법을 찾았습니다.
lhan


이 트 리뷰를 어떻게 채우시나요? 그 길을 어떻게 벗어나고 있습니까?
Random832

답변:


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 비트의 이진 값입니다. 비트 단위와 &연산자는 두 피연산자 모두에있는 (1) 비트 만 켜져있는 이진 값을 반환합니다. 이 경우에 비트 AND 연산을 수행 attr하고, FileAttributes.Directory값은의 값이 반환됩니다 FileAttributes.Directory디렉토리 파일 속성 비트가 설정되어있는 경우입니다. 자세한 설명 은 en.wikipedia.org/wiki/Bitwise_operation 을 참조하십시오 .
Kyle Trauberman

6
@jberger 경로가 존재하지 않는 경우 C:\Temp라는 디렉토리 Temp또는이라는 파일을 참조 하는지 여부 는 모호합니다 Temp. 코드는 무엇을 의미합니까?
ta.speot.is는

26
@Key : .NET 4.0 이후에 attr.HasFlag(FileAttributes.Directory)대신 사용할 수 있습니다.
Şafak Gür

13
@ ŞafakGür : 시간에 민감한 루프 안에서 이것을하지 마십시오. attr.HasFlag ()는 지옥만큼 느리고 각 호출에 대해 Reflection을 사용합니다
springy76

247

이것들을 사용하는 것은 어떻습니까?

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

43
또한 달리 달리 유효하지 않은 경로에서 예외를 발생시키지 않는 이점이 있습니다 File.GetAttributes().
Deanna

내 프로젝트 에서 BCL bcl.codeplex.com/…의 Long Path 라이브러리를 사용 하므로 파일 속성을 얻을 수있는 방법은 없지만 Exist를 호출하는 것이 좋습니다.
Puterdo Borato

4
@jberger 존재하지 않는 파일 / 폴더의 경로에는 작동하지 않을 것으로 예상됩니다. File.Exists ( "c : \\ temp \\ nonexistant.txt")는 false를 반환해야합니다.
michaelkoss

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

1
이에 대한 자세한 내용은 msdn.microsoft.com/en-us/library/…
Moji

20

이 줄만 있으면 경로가 디렉토리 또는 파일인지 확인할 수 있습니다.

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

4
이를 위해서는 최소한 .NET 4.0이 필요합니다. 또한 경로가 유효한 경로가 아닌 경우 폭발합니다.
nawfal

FileInfo 객체를 사용하여 경로가 있는지 확인하십시오. FileInfo pFinfo = new FileInfo (FList [0]); if (pFinfo.Exists) {if (File.GetAttributes (FList [0]). HasFlag (FileAttributes.Directory)) {}}. 이것은 나를 위해 작동합니다.
Michael Stimson

FileInfo 객체를 이미 만들고 인스턴스의 Exists 속성을 사용하는 경우 정적 File.GetAttributes () 메서드를 사용하는 대신 Attributes 속성에 액세스하지 않겠습니까?
dynamichael 2018 년

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.DirectorySeparatorChar하고Path.AltDirectorySeparatorChar
drzaus

1
의도를 추측하는이 아이디어는 흥미 롭습니다. IMHO는 두 가지 방법으로 나누는 것이 좋습니다. 방법 1은 존재 여부 테스트를 수행하여 널 입력 가능 부울을 리턴합니다. 호출자가 "추측"부분을 원하면 One의 null 결과에 대해 추측하는 방법 2를 호출합니다.
ToolmakerSteve

2
추측 여부에 관계없이 튜플을 반환하도록 이것을 다시 작성합니다.
Ronnie Overby

1
"확장자를 가진 파일이라면"-이것은 사실이 아닙니다. 파일은 확장명 (Windows에서도)을 가질 필요가 없으며 디렉토리는 "확장자"를 가질 수 있습니다. 예를 들어 파일 또는 디렉토리 일 수 있습니다. "C : \ New folder.log"
bytedev

2
@bytedev 나는 알고 있지만 함수의 시점에서 코드는 의도를 추측하고 있습니다. 그렇게 말하는 의견도 있습니다. 대부분의 파일 확장자는입니다. 대부분의 디렉토리는 그렇지 않습니다.
Ronnie Overby

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 속성에서 항목 유형을 테스트하여 항목을 클릭 할 때 해당 데이터를 얻기 위해 추가 시스템 호출을 저장할 수 있습니다.



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()문자열 연결 대신 ""?
사라 코딩

@GoneCoding 아마; 당시에는 nullable 속성을 사용하여 작업했기 때문에 null을 확인하는 것이 아니라 "빈 문자열로 연결"하는 습관을 얻었습니다. 당신은 또한 할 수있는 new String(Path.DirectorySeparatorChar, 1)그 무엇으로 ToString하지 않습니다 당신이 얻을 원한다면, 정말 최적화.
drzaus

4

가장 정확한 방법은 shlwapi.dll의 일부 interop 코드를 사용하는 것입니다.

[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
추한. 이 간단한 작업을 수행하기 위해 interop을 싫어합니다. 그리고 휴대용이 아닙니다. 못 생겼어요 내가 못 생겼다고 했어? :)
Ignacio Soler Garcia

5
@SoMoS 귀하의 의견으로는 "추악한"것일 수도 있지만 여전히 가장 정확한 방법입니다. 예, 휴대용 솔루션은 아니지만 질문이 아닙니다.
Scott Dorman

8
정확히 무엇을 의미합니까? Quinn Wilson의 답변과 동일한 결과를 제공하고 이식성을 깨뜨리는 필수 interop을 제공합니다. 나에게 다른 솔루션만큼 정확하고 다른 사람들이하지 않는 부작용이 있습니다.
이그나시오 솔러 가르시아

7
이를위한 프레임 워크 API가 있습니다. Interop을 사용하는 것은 좋은 방법이 아닙니다.
TomXP411

5
예, 이것이 작동하지만 "가장 정확한"솔루션은 아닙니다. 기존 .NET Framework를 사용하는 것 이상입니다. 대신 6 줄의 코드를 사용하여 한 줄로 수행 할 수있는 작업을 .NET Framework로 바꾸고 Mono Project 로이를 이식 할 수있는 능력을 열어 두지 말고 Windows 만 사용하십시오. .NET Framework가보다 세련된 솔루션을 제공 할 때는 Interop을 사용하지 마십시오.
Russ

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 방법 을 사용해 보셨습니까 ?
Jake Berger

존재하지 않는 경우 파일 또는 디렉토리가 아닙니다. 어떤 이름으로도 만들 수 있습니다. 작성하려는 경우 작성 중인 내용을 알고 있어야하며 그렇지 않은 경우이 정보가 필요한 이유는 무엇입니까?
Random832

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:\'하므로 마지막 사례가 작동하지 않습니다. 이것은 확장자가없는 파일과 디렉토리를 구별하지 않습니다.
Lucy

디렉토리 경로에는 항상 최종 "\"가 포함된다고 잘못 가정합니다. 예를 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 is (IMAO) 존재하지 않는 경로를 확인하는 좋은 옵션
dataCore

2
두 번째 상태 (다른)가 냄새가납니다. 기존 파일이 아닌 경우 파일이 무엇인지 알 수 없습니다 (디렉토리도 ".txt"와 같이 끝날 수 있음).
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));
          }
     }
}

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 ()를 확인한 후 속성을 확인하는 데 약간의 낭비가 있습니까? 이 두 가지 통화만으로 여기에 필요한 모든 작업을 수행 할 수 있습니다.
사라 코딩

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

나는 파티에 너무 늦었다. 어떤 속성에서 파일 이름이나 전체 파일 경로를 수신 할 수있는 상황에 직면했습니다. 제공된 경로가 없으면 다른 속성에서 제공 한 "전역"디렉토리 경로를 첨부하여 파일 존재를 확인해야합니다.

나의 경우에는

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

또한 파일에는 마침표가 없어도됩니다.
Keith Pinson
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.