Melhor maneira de verificar se um caminho é um arquivo ou um diretório?


382

Estou processando um TreeViewde diretórios e arquivos. Um usuário pode selecionar um arquivo ou um diretório e, em seguida, fazer algo com ele. Isso exige que eu tenha um método que execute ações diferentes com base na seleção do usuário.

No momento, estou fazendo algo assim para determinar se o caminho é um arquivo ou um diretório:

bool bIsFile = false;
bool bIsDirectory = false;

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

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

Não posso deixar de sentir que há uma maneira melhor de fazer isso! Eu esperava encontrar um método .NET padrão para lidar com isso, mas não consegui fazer isso. Existe esse método e, se não, qual é o meio mais direto para determinar se um caminho é um arquivo ou diretório?


8
Alguém pode editar o título da pergunta para especificar o arquivo / diretório "existente" ? Todas as respostas se aplicam a um caminho para um arquivo / diretório que está no disco.
Jake Berger

11
@berger, consulte a minha resposta abaixo. Eu encontrei uma maneira de fazer isso para caminhos de arquivos / pastas que podem ou não existir.
Lhan 18/10/12


Como você está preenchendo essa visualização em árvore? Como você está tirando o caminho disso?
Random832

Respostas:


596

Em Como saber se o caminho é arquivo ou diretório :

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

Atualização para .NET 4.0+

Pelos comentários abaixo, se você estiver no .NET 4.0 ou posterior (e o desempenho máximo não for crítico), poderá escrever o código de maneira mais limpa:

// 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 Essa é a melhor abordagem e é significativamente mais rápida que a solução que propus.
Andrew Hare

6
@ KeyMs92 Sua matemática bit a bit. Basicamente, attr é algum valor binário com um bit que significa "este é um diretório". O bit a bit e o &operador retornarão um valor binário em que apenas os bits que estão ligados (1) nos dois operandos estão ativados. Nesse caso, fazendo uma operação bit a bit e contra attre o FileAttributes.Directoryvalor retornará o valor FileAttributes.Directoryse o bit de atributo do arquivo de diretório estiver ativado. Veja en.wikipedia.org/wiki/Bitwise_operation para uma explicação melhor.
Kyle Trauberman

6
@jberger Se o caminho não existe, é ambíguo se C:\Temprefere a um diretório chamado Tempou a um arquivo chamado Temp. O que o código deve fazer?
ta.speot.is

26
@ Key: Após o .NET 4.0, attr.HasFlag(FileAttributes.Directory)pode ser usado.
Şafak Gür

13
@ ŞafakGür: Não faça isso dentro de um loop sensível ao tempo. attr.HasFlag () é lento como o inferno e usa reflexão para cada chamada
springy76

247

Que tal usá-los?

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

43
Isso também tem a vantagem de não lançar uma exceção em um caminho inválido, ao contrário File.GetAttributes().
perfil

Eu uso a biblioteca Long Path da BCL bcl.codeplex.com/… no meu projeto, então não há como obter atributos de arquivo, mas chamar Exist é uma boa solução.
Puterdo Borato

4
@ jberger Espero que NÃO funcione para caminhos para arquivos / pastas inexistentes. File.Exists ("c: \\ temp \\ nonexistant.txt") deve retornar false, como ocorre.
precisa

12
Se você está preocupado sobre arquivos inexistentes / pastas tentar isso 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

11
Mais detalhes sobre isso estão em msdn.microsoft.com/en-us/library/…
Moji

20

Com apenas essa linha, você pode obter se um caminho é um diretório ou arquivo:

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

4
Lembre-se de que você precisa pelo menos do .NET 4.0 para isso. Além disso, isso irá explodir se o caminho não for um caminho válido.
Nawfal

Use um objeto FileInfo para verificar se o caminho existe: FileInfo pFinfo = new FileInfo (FList [0]); if (pFinfo.Exists) {if (File.GetAttributes (FList [0]). HasFlag (FileAttributes.Directory)) {}}. Este funciona para mim.
Michael Stimson

Se você já criou um objeto FileInfo e está usando a propriedade Exists da instância, por que não acessar a propriedade Attributes em vez de usar o método estático File.GetAttributes ()?
precisa saber é o seguinte

10

Aqui está o meu:

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

É semelhante às respostas dos outros, mas não exatamente o mesmo.


3
Tecnicamente você deve usar Path.DirectorySeparatorCharePath.AltDirectorySeparatorChar
drzaus 02/02

11
Essa ideia de adivinhar a intenção é interessante. IMHO melhor dividir em dois métodos. O método um faz os testes de existência, retornando um booleano anulável. Se o chamador desejar a parte "adivinhar", em um resultado nulo de Um, chame o Método Dois, que faz a adivinhação.
Home

2
Eu reescreveria isso para retornar uma tupla, adivinhada ou não.
Ronnie Overby

11
"se tem extensão, então é um arquivo" - isso não é verdade. Um arquivo não precisa ter uma extensão (mesmo no Windows) e um diretório pode ter uma "extensão". Por exemplo, isso pode ser um arquivo ou um diretório: "C: \ New folder.log"
bytedev 19/09/18

2
@bytedev Eu sei disso, mas nesse ponto da função, o código está adivinhando a intenção. Há até um comentário dizendo isso. A maioria dos arquivos tem uma extensão. A maioria dos diretórios não.
Ronnie Overby

7

Como alternativa ao Directory.Exists (), você pode usar o método File.GetAttributes () para obter os atributos de um arquivo ou diretório, para poder criar um método auxiliar como este:

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

Você também pode considerar adicionar um objeto à propriedade tag do controle TreeView ao preencher o controle que contém metadados adicionais para o item. Por exemplo, você pode adicionar um objeto FileInfo para arquivos e um objeto DirectoryInfo para diretórios e, em seguida, testar o tipo de item na propriedade tag para economizar fazendo chamadas adicionais ao sistema para obter esses dados ao clicar no item.


2
como isso é diferente do que a outra resposta
Jake Berger

6
Ao invés de esse bloco horrível de lógica, tenteisDirectory = (fa & FileAttributes.Directory) != 0);
Immortal Azul

5

Este foi o melhor que pude apresentar, devido ao comportamento das propriedades 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;
    }
}

Aqui está como ele é testado:

    [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

Depois de combinar as sugestões das outras respostas, percebi que tinha a mesma coisa que a resposta de Ronnie Overby . Aqui estão alguns testes para apontar algumas coisas em que pensar:

  1. pastas podem ter "extensões": C:\Temp\folder_with.dot
  2. os arquivos não podem terminar com um separador de diretório (barra)
  3. Tecnicamente, existem dois separadores de diretório que são específicos da plataforma - ou seja, podem ou não ser barras ( Path.DirectorySeparatorChare Path.AltDirectorySeparatorChar)

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

Resultados

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 

Método

/// <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()em vez de concat string com ""?
Gone Coding

@GoneCoding provavelmente; na época, eu trabalhava com várias propriedades anuláveis, por isso adquiri o hábito de "concat com a cadeia vazia", ​​em vez de me preocupar em procurar nulos. Você também pode fazer new String(Path.DirectorySeparatorChar, 1)o que ToStringfaz, se quiser realmente ser otimizado.
precisa saber é

4

A abordagem mais precisa será usar algum código de interoperabilidade do 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);

Você poderia chamar assim:

#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
Feio. Eu odeio interoperabilidade para fazer essas tarefas simples. E não é portátil. e é feio. Eu disse que é feio? :)
Ignacio Soler Garcia

5
@SoMoS Pode ser "feio" na sua opinião, mas ainda é a abordagem mais precisa. Sim, não é uma solução portátil, mas não foi isso que a pergunta foi feita.
Scott Dorman

8
O que você quer dizer exatamente com precisão? Ele fornece os mesmos resultados da resposta de Quinn Wilson e a interoperabilidade necessária que quebra a portabilidade. Para mim, é tão preciso quanto as outras soluções e tem efeitos colaterais que os outros não.
Ignacio Soler Garcia

7
Há uma API do Framework para fazer isso. Usar a Interop não é o caminho a seguir.
TomXP411

5
Sim, isso funciona, mas NÃO é a solução "mais precisa" - não mais do que usar o .NET Framework existente. Em vez disso, você pega 6 linhas de código para substituir o que pode ser feito em uma linha pelo .NET Framework e se prende ao uso somente do Windows, em vez de deixar em aberto a capacidade de portar isso com o Mono Project. Nunca use a Interop quando o .NET Framework oferecer uma solução mais elegante.
213 Russ

2

Aqui está o que usamos:

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

Me deparei com isso ao enfrentar um problema semelhante, exceto que eu precisava verificar se o caminho é para um arquivo ou pasta, quando esse arquivo ou pasta pode realmente não existir . Houve alguns comentários nas respostas acima que mencionaram que não funcionariam nesse cenário. Encontrei uma solução (eu uso o VB.NET, mas você pode converter, se necessário) que parece funcionar bem para mim:

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

Espero que isso possa ser útil para alguém!


11
você já tentou o método Path.HasExtension ?
Jake Berger

Se não existir, não será um arquivo ou diretório. Qualquer nome pode ser criado como qualquer um. Se você pretende criá-lo, deve saber o que está criando e, caso não o faça, por que poderia precisar dessas informações?
Random832

8
A pasta pode ser nomeado test.txte um arquivo pode ser chamado test-, nestes casos, o código seria retornar resultados incorretos
Stephan Bauer

2
Existe um método .Exists nas classes System.IO.FIle e System.IO.Directory. essa é a coisa a fazer. Diretórios podem ter extensões; Eu o vejo com frequência.
TomXP411

2

muuuuito tarde no jogo eu sei, mas pensei em compartilhar isso de qualquer maneira. Se você estiver trabalhando apenas com os caminhos como seqüências de caracteres, descobrir isso é fácil como torta:

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

por exemplo: ThePath == "C:\SomeFolder\File1.txt"acabaria sendo assim:

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

Outro exemplo: ThePath == "C:\SomeFolder\"acabaria sendo este:

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

E isso também funcionaria sem a barra invertida: ThePath == "C:\SomeFolder"acabaria sendo assim:

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

Lembre-se de que isso só funciona com os caminhos em si, e não com o relacionamento entre o caminho e o "disco físico" ... portanto, não é possível dizer se o caminho / arquivo existe ou algo parecido, mas com certeza pode dizer se o caminho é uma pasta ou um arquivo ...


2
Não funciona System.IO.FileSystemWatcherdesde que, quando um diretório é excluído, ele é enviado c:\my_directorycomo um argumento que é o mesmo quando um arquivo com menos extensão c:\my_directoryé excluído.
Raio de Cheng

GetDirectoryName('C:\SomeFolder')retorna 'C:\', para que seu último caso não funcione. Isso não faz distinção entre diretórios e arquivos sem extensões.
Lucy

Você supõe erroneamente que um caminho de diretório sempre incluirá o "\" final. Por exemplo, Path.GetDirectoryName("C:\SomeFolder\SomeSubFolder")retornará C:\SomeFolder. Observe que seus próprios exemplos do que GetDirectoryName retorna mostram que ele retorna um caminho que não termina em uma barra invertida. Isso significa que, se alguém usar GetDirectoryName em outro local para obter um caminho de diretório e, em seguida, alimentá-lo com o seu método, eles obterão a resposta errada.
Home

1

Se você deseja encontrar diretórios, incluindo aqueles marcados como "ocultos" e "sistema", tente o seguinte (requer o .NET V4):

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

1

Eu precisava disso, as postagens ajudaram, isso reduz a uma linha e, se o caminho não é um caminho, ele apenas retorna e sai do método. Ele aborda todas as preocupações acima, também não precisa da barra final.

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

0

Eu uso o seguinte, ele também testa a extensão, o que significa que pode ser usado para testar se o caminho fornecido é um arquivo, mas não existe.

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

11
FileInfo Extensão é (IMAO) uma boa opção para verificar caminhos inexistentes
Datacore

2
sua segunda condição (mais) é fedorenta. se não é um arquivo existente, você não sabe o que poderia ser (os diretórios também podem terminar com algo como ".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

Usando a resposta selecionada neste post, analisei os comentários e dou crédito a @ ŞafakGür, @Anthony e @Quinn Wilson por seus bits de informações que me levaram a essa resposta aprimorada que escrevi e testei:

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

Parece um pouco inútil verificar os atributos depois de verificar o diretório / arquivo existente ()? Só essas duas ligações fazem todo o trabalho necessário aqui.
Gone Coding

0

Talvez para 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

Entendo, estou 10 anos atrasado para a festa. Eu estava enfrentando a situação, onde de alguma propriedade posso receber um nome de arquivo ou um caminho completo. Se não houver um caminho fornecido, eu tenho que verificar a existência do arquivo anexando um caminho de diretório "global" fornecido por outra propriedade.

No meu caso

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

fez o truque. Ok, não é mágico, mas talvez isso possa poupar alguém alguns minutos de descobrir. Como isso é apenas uma análise de string, nomes de diretórios com pontos podem fornecer falsos positivos ...


0

Muito tarde para a festa aqui, mas eu achei o Nullable<Boolean>valor de retorno bastante feio - IsDirectory(string path)retornar nullnão equivale a um caminho inexistente sem comentários detalhados, então eu vim com o seguinte:

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

Esse método auxiliar foi escrito para ser detalhado e conciso o suficiente para entender a intenção na primeira vez em que você o lê.

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

Isso não funcionaria?

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

11
Isso não iria funcionar só porque os nomes das pastas podem ter períodos neles
KSib

Os arquivos também não precisam ter períodos neles.
precisa
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.