.NET Comment vérifier si le chemin d'accès est un fichier et non un répertoire?

J'ai un chemin d'accès et j'ai besoin de savoir si c'est un répertoire ou un fichier.

Est-ce la meilleure façon de déterminer si le chemin est un fichier?

string file = @"C:\Test\foo.txt";

bool isFile = !System.IO.Directory.Exists(file) && 
                         System.IO.File.Exists(file);

Pour un répertoire, je voudrais inverser la logique.

string directory = @"C:\Test";

bool isDirectory = System.IO.Directory.Exists(directory) && 
                            !System.IO.File.Exists(directory);

Si les deux n'existe pas, que puis je ne vais pas aller faire une ou l'autre branche. Donc supposer qu'ils les deux, n'existe.

stackoverflow.com/a/17198139/128506
Double Possible de Meilleure façon de vérifier si le Chemin d'un Fichier ou d'un Répertoire?

InformationsquelleAutor David Basarab | 2009-01-13

109

Utilisation:
```
System.IO.File.GetAttributes(string path)
```
et de vérifier si le retour de l' FileAttributes résultat contient la valeur FileAttributes.Directory:
```
bool isDir = (File.GetAttributes(path) & FileAttributes.Directory)
                 == FileAttributes.Directory;
```
- Assurez-vous de le faire dans un try/catch, depuis le chemin d'accès peut même ne pas exister.
- Qu'advient-il si le chemin d'accès a des caractères génériques dans tout ça? Je reçois un caractère illégal de l'argument, mais si je utiliser des caractères génériques et c'est une voie légitime pour mes utilisateurs?
- Autant que je sache, de traiter avec des caractères génériques, vous devez appeler Directory.GetFiles à la chaîne, et voir si le résultat est un nombre supérieur à zéro. Un "chemin d'accès avec des caractères génériques" n'est pas un chemin. C'est un modèle.
InformationsquelleAutor Alnitak
53

Je pense que c'est la façon la plus simple d'où vous avez seulement besoin de deux vérifications:
```
string file = @"C:\tmp";
if (System.IO.Directory.Exists(file))
{
    //do stuff when file is an existing directory
}
else if (System.IO.File.Exists(file))
{
    //do stuff when file is an existing file
}
```
- Je n'ai pas downvote vous, mais il l'a accepté réponse est sûrement plus "simple" et n'a besoin que d'un seul appel (pas de deux).
- Eh bien, ça dépend, personnellement, je voudrais envisager de isDir = Système.IO.Répertoire.Existe(fichier) pour être "simple" que la solution retenue.
- L'avantage de cette approche est qu'il fonctionne même si il n'y a pas d'entrée correspondante dans le système de fichiers (en d'autres termes, ce n'est ni un dossier ni fichier); En ce sens, il est plus "simple". Par ailleurs, l'OP a dit: "chemin", et pas "un chemin qui est connue pour exister".
- Ouais, en fait, je pense que c'est la meilleure réponse quand vous ne savez pas le chemin que vous étudiez est là ou pas. Ne pas avoir à vous inquiéter au sujet de la capture des exceptions est une grosse affaire.
- Je suis d'accord que cette méthode est efficace. Je viens de créer un petit utilitaire pour déterminer si le nom spécifié est un fichier ou un répertoire, et cette méthode fait qu'il est extrêmement simple de revenir 1 de répertoire, 2 pour le fichier, et 0 d'erreur (par exemple, le nom n'est pas valide). L'outil est minuscule (338 octets source, 3584 octets compilé) et fonctionne très rapidement.
- +1 pour la meilleure réponse ici 🙂
- Ne dépend pas de cette réponse, il est trompeur. Cela vous indique si le Fichier ou le Répertoire existe pas, PAS ce type de IO entrée qu'ils sont. Si le chemin d'accès est incorrect, les chèques seront de retour faux.
- Ce qu'exactement vous attendre si le chemin n'existe pas?
- L'OP je voulais savoir si un chemin d'un fichier ou d'un répertoire et de ne pas laisser ouverte la possibilité de la voie de la non-existence à tous. Depuis, nous pouvons citer quoi que ce soit dans la façon que nous voulons (nous ne sommes pas coincé avec 8.3 comme autrefois) j'ai essayé d'obtenir l'idée que le chemin n'est pas assez. Vous avez besoin d'une réelle IO objet de déterminer si une chose est un fichier ou un dir. Vous ne pouvez pas le dire par le nom À TOUS. Par opposition à la accepté de répondre que va lever une exception si le chemin n'est pas valide.
- Pas de. Les DEUX approches d'identifier correctement tous les 3 états. Celle-ci par une paire de tests: si les deux sont faux, alors le chemin n'est pas valide (ou vous n'avez pas la permission). L'autre par une exception dans ce cas. Décrivez une situation où cette approche diffère de l'approche que vous préférez.
- Vous n'avez même pas besoin du Fichier.Il existe() vérifier. Si il existe, mais n'est pas un répertoire, alors il doit être un fichier.
InformationsquelleAutor Dirk Vollmar
10

Vous pouvez le faire avec une certaine interopérabilité code:
```
    [DllImport("shlwapi.dll", CharSet = CharSet.Unicode)]
    [return: MarshalAsAttribute(UnmanagedType.Bool)]
    public static extern bool PathIsDirectory([MarshalAsAttribute(UnmanagedType.LPWStr), In] string pszPath);
```
De préciser davantage certains commentaires...

L'introduction de code non managé ce n'est plus inherintly dangereux que n'importe quel autre fichier ou d'e/S, les appels en .NET car ils ultimatley tous appel à du code non managé.

C'est un seul appel de fonction à l'aide d'une chaîne. Vous n'êtes pas introduire de nouveaux types de données et/ou de l'utilisation de la mémoire par l'appel de cette fonction. Oui, vous avez besoin de s'appuyer sur le code non managé pour bien nettoyer, mais vous avez cette dépendance sur la plupart des e/S, les appels.

Pour référence, voici le code dans un Fichier.GetAttributes(string path) du Réflecteur:
```
public static FileAttributes GetAttributes(string path)
{
    string fullPathInternal = Path.GetFullPathInternal(path);
    new FileIOPermission(FileIOPermissionAccess.Read, new string[] { fullPathInternal }, false, false).Demand();
    Win32Native.WIN32_FILE_ATTRIBUTE_DATA data = new Win32Native.WIN32_FILE_ATTRIBUTE_DATA();
    int errorCode = FillAttributeInfo(fullPathInternal, ref data, false, true);
    if (errorCode != 0)
    {
        __Error.WinIOError(errorCode, fullPathInternal);
    }
    return (FileAttributes) data.fileAttributes;
}
```
Comme vous pouvez le voir, il est aussi appel à du code non managé afin de récupérer les attributs de fichier, de sorte que les arguments sur l'introduction du code non managé être dangereux ne sont pas valides. De même, l'argument au sujet de rester complètement dans le code managé. Il n'y a pas de code managé mise en œuvre pour ce faire. Même l'appel de Fichier.GetAttributes() que les autres réponses proposons ont les mêmes "problèmes" de l'appel de unmanged code et je crois que c'est la méthode plus fiable pour accomplir déterminer si un chemin est un répertoire.

Modifier Pour répondre au commentaire de @Christian K sur le TAS. Je crois que la seule raison pour laquelle GetAttributes fait la demande de sécurité est parce qu'il a besoin de lire les propriétés du fichier afin qu'il veut s'assurer que le code appelant est autorisé à le faire. Ce n'est pas le même que l'OS sous-jacent de contrôle (le cas échéant). Vous pouvez toujours créer une fonction wrapper autour de l'appel de P/Invoke pour PathIsDirectory qui exige aussi de certains CAS d'autorisations, si nécessaire.
- Cela ressemble à beaucoup de travail, de savoir si un chemin est un fichier ou d'un répertoire.
- Comment est-ce beaucoup de travail? Vous déclarez une seule fonction importée et peut en appeler ça comme s'il s'agissait d'une méthode native.
- Je ne vois pas pourquoi c'est downvoted, bien que ce serait beaucoup plus simple pour rester en code managé à l'aide .NET fonctionnalité.
- L'introduction du code non managé à obtenir si le chemin d'un fichier ou d'un répertoire est dangereux. Je relais sur l'appel de la fonction pour nettoyer la mémoire correctement ou mon code pourrait avoir des fuites.
- Je n'ai pas downvote juste parce que c'est du code non managé, je baisse voté parce qu'il ne fait pas partie de la norme .net-library
- La question jamais précisé qu'il ne voulait que le code managé, d'ailleurs il n'y a vraiment aucun moyen de le faire en utilisant uniquement du code managé.
- Je ne suis pas sûr si c'est un problème, mais le GetAttributes() ne CAS à l'aide de FileIOPermission, l'appel des indigènes n'a pas (hormis le système d'exploitation vérifie, qui ne sont pas neccessarly la même, sont-ils?).
- Je ne comprends toujours pas pourquoi c'est arriver downvoted qu'il répond correctement à la question avec une méthode qui ne fournit pas le niveau de ambiguitity.
- C'est la "beauté" de la SORTE, même une des bonnes réponses peut être downvoted par certains fanatiques 😉
- Le seul problème avec cette solution que je vois, c'est un changement de l'API dans les futures versions de l'OS. Il est de la .NET framework qui devrait être downvoted pour ne pas avoir cette. Sinon, cela semble une solution élégante. Je suis très à la performance, et ce bat tout le reste beaucoup de temps! Si vous avez un +1
- Je n'aurais jamais l'utiliser, mais +1 pour l'effort 🙂
- C'est la plus simple et la réponse directe, et cela peut éviter la PathTooLong problème.
- son obtention downvoted parce que vous avez fourni aucune raison qui justifie en marchant à l'extérieur de l'géré disponibles appels (indépendamment de ce Réflecteur montre). Si vous pouvez donner à une situation où cela a un avantage, alors la réponse est l'existence est justifiée. Sinon, son enseignement d'une mauvaise habitude, à mon humble avis. Il y a un fondamentaux différence entre un programmeur explicitement l'importation d'une référence à du code non managé, et à l'aide d'un existant géré appel. Comme un code examinateur, ma première question serait: "pourquoi avez-vous fait ça?" J'ai vérifier les implications de manière plus approfondie.
- en réponse à Alnitak, vous dites: "en outre, il n'y a vraiment aucun moyen de le faire en utilisant uniquement du code managé". Dans ce cas, quel est le problème avec les autres réponses, qui n'ont réussi appels? Si vous dites "la gestion des appels éventuellement avoir à appeler du code non managé", alors vous manquez le point. Je préférerais de beaucoup avoir les programmeurs font existant géré les appels, en laissant à Microsoft pour obtenir la limite entre les administrés et non administrés le droit, plutôt que de les inutilement traverser les frontières elles-mêmes.
InformationsquelleAutor Scott Dorman
7

En supposant que le répertoire existe...
```
bool isDir = (File.GetAttributes(path) & FileAttributes.Directory)
                 == FileAttributes.Directory;
```
- Si le chemin n'existe pas, GetAttributes sera de retour -1.
- Docs semblent indiquer qu'il va lever une exception si le fichier n'existe pas. msdn.microsoft.com/en-us/library/...
- votre test est à l'envers - qui devrait être isDir pas isFile...
- corrigé de isDir
InformationsquelleAutor tvanfosson

Check this out:

///<summary>
///Returns true if the given file path is a folder.
///</summary>
///<param name="Path">File path</param>
///<returns>True if a folder</returns>
public bool IsFolder(string path)
{
    return ((File.GetAttributes(path) & FileAttributes.Directory) == FileAttributes.Directory);
}

de http://www.jonasjohn.de/snippets/csharp/is-folder.htm

InformationsquelleAutor Dror

2

Lire les attributs de fichier:
```
FileAttributes att = System.IO.File.GetAttributes(PATH_TO_FILE);
```
Vérifier la Répertoire drapeau.

InformationsquelleAutor Igor Zelaya
1

Donné qu'une chaîne de chemin d'accès ne peut pas représenter à la fois un répertoire et un fichier, puis le suivant fonctionne très bien et ouvre la porte pour d'autres opérations.
```
bool isFile = new FileInfo(path).Exists;
bool isDir = new DirectoryInfo(path).Exists;
```
Si vous travaillez avec le système de fichiers, à l'aide de FileInfo et DirectoryInfo est beaucoup plus simple que d'utiliser des chaînes de caractères.
- Voir 0xA3 réponse, un peu mieux les appels de l'omi.
- Ou tout simplement si (dans le Répertoire.Existe(src)) ... Si c'est un fichier, il sera faux. Si la src est un répertoire, il sera faux. Si la src est un répertoire qui n'existe pas, alors par définition src peut pas un répertoire.
InformationsquelleAutor Drew Noakes
-3

Hmm, on dirait que le Files classe (dans java.nio) a fait un statique isDirectory méthode. Donc, je pense que vous pouvez réellement utiliser les éléments suivants:
```
Path what = ...
boolean isDir = Files.isDirectory(what);
```
- Vous cherchez un .NET solution.
InformationsquelleAutor Onikoroshi

Vous devez vous connecter pour publier un commentaire.