Vérifier si une chaîne est un Windows valide répertoire (dossier) chemin

Appel Path.GetFullPath; il lèvera une exception si le chemin n'est pas valide.

Pour interdire les chemins relatifs (tels que Word), appel Path.IsPathRooted.

Chemin.GetFullPath donne ci-dessous des exceptions uniquement

ArgumentException chemin est une chaîne de longueur nulle, ne contient que des blancs
de l'espace, ou contient un ou plusieurs des caractères non valides définis dans
GetInvalidPathChars.
-ou - Le système n'a pas pu récupérer le chemin absolu.

SecurityException L'appelant n'a pas les autorisations requises.

ArgumentNullException chemin est null.

NotSupportedException chemin d'accès contient un deux-points (":") qui ne fait pas partie de
un identificateur de volume (par exemple, "c:\").

PathTooLongException Le chemin d'accès spécifié, le nom de fichier, ou les deux excéder
le système défini par la longueur maximale. Par exemple, sur Windows
les plates-formes, les chemins d'accès doivent être à moins de 248 caractères, et les noms de fichier doivent
être inférieure à 260 caractères.

Autre moyen est d'utiliser les éléments suivants :

///<summary>
///Validate the Path. If path is relative append the path to the project directory by default.
///</summary>
///<param name="path">Path to validate</param>
///<param name="RelativePath">Relative path</param>
///<param name="Extension">If want to check for File Path</param>
///<returns></returns>
private static bool ValidateDllPath(ref string path, string RelativePath = "", string Extension = "")
{
//Check if it contains any Invalid Characters.
if (path.IndexOfAny(Path.GetInvalidPathChars()) == -1)
{
try
{
//If path is relative take %IGXLROOT% as the base directory
if (!Path.IsPathRooted(path))
{
if (string.IsNullOrEmpty(RelativePath))
{
//Exceptions handled by Path.GetFullPath
//ArgumentException path is a zero-length string, contains only white space, or contains one or more of the invalid characters defined in GetInvalidPathChars. -or- The system could not retrieve the absolute path.
//
//SecurityException The caller does not have the required permissions.
//
//ArgumentNullException path is null.
//
//NotSupportedException path contains a colon (":") that is not part of a volume identifier (for example, "c:\"). 
//PathTooLongException The specified path, file name, or both exceed the system-defined maximum length. For example, on Windows-based platforms, paths must be less than 248 characters, and file names must be less than 260 characters.
//RelativePath is not passed so we would take the project path 
path = Path.GetFullPath(RelativePath);
}
else
{
//Make sure the path is relative to the RelativePath and not our project directory
path = Path.Combine(RelativePath, path);
}
}
//Exceptions from FileInfo Constructor:
//  System.ArgumentNullException:
//    fileName is null.
//
//  System.Security.SecurityException:
//    The caller does not have the required permission.
//
//  System.ArgumentException:
//    The file name is empty, contains only white spaces, or contains invalid characters.
//
//  System.IO.PathTooLongException:
//    The specified path, file name, or both exceed the system-defined maximum
//    length. For example, on Windows-based platforms, paths must be less than
//    248 characters, and file names must be less than 260 characters.
//
//  System.NotSupportedException:
//    fileName contains a colon (:) in the middle of the string.
FileInfo fileInfo = new FileInfo(path);
//Exceptions using FileInfo.Length:
//  System.IO.IOException:
//    System.IO.FileSystemInfo.Refresh() cannot update the state of the file or
//    directory.
//
//  System.IO.FileNotFoundException:
//    The file does not exist.-or- The Length property is called for a directory.
bool throwEx = fileInfo.Length == -1;
//Exceptions using FileInfo.IsReadOnly:
//  System.UnauthorizedAccessException:
//    Access to fileName is denied.
//    The file described by the current System.IO.FileInfo object is read-only.-or-
//    This operation is not supported on the current platform.-or- The caller does
//    not have the required permission.
throwEx = fileInfo.IsReadOnly;
if (!string.IsNullOrEmpty(Extension))
{
//Validate the Extension of the file.
if (Path.GetExtension(path).Equals(Extension, StringComparison.InvariantCultureIgnoreCase))
{
//Trim the Library Path
path = path.Trim();
return true;
}
else
{
return false;
}
}
else
{
return true;
}
}
catch (ArgumentNullException)
{
//  System.ArgumentNullException:
//    fileName is null.
}
catch (System.Security.SecurityException)
{
//  System.Security.SecurityException:
//    The caller does not have the required permission.
}
catch (ArgumentException)
{
//  System.ArgumentException:
//    The file name is empty, contains only white spaces, or contains invalid characters.
}
catch (UnauthorizedAccessException)
{
//  System.UnauthorizedAccessException:
//    Access to fileName is denied.
}
catch (PathTooLongException)
{
//  System.IO.PathTooLongException:
//    The specified path, file name, or both exceed the system-defined maximum
//    length. For example, on Windows-based platforms, paths must be less than
//    248 characters, and file names must be less than 260 characters.
}
catch (NotSupportedException)
{
//  System.NotSupportedException:
//    fileName contains a colon (:) in the middle of the string.
}
catch (FileNotFoundException)
{
//System.FileNotFoundException
// The exception that is thrown when an attempt to access a file that does not
// exist on disk fails.
}
catch (IOException)
{
//  System.IO.IOException:
//    An I/O error occurred while opening the file.
}
catch (Exception)
{
//Unknown Exception. Might be due to wrong case or nulll checks.
}
}
else
{
//Path contains invalid characters
}
return false;
}

Utiliser ce Code

string DirectoryName = "Sample Name For Directory Or File";
Path.GetInvalidFileNameChars().Where(x => DirectoryName.Contains(x)).Count() > 0 || DirectoryName == "con"

Je n'ai pas eu de problèmes avec ce code:

private bool IsValidPath(string path, bool exactPath = true)
{
bool isValid = true;
try
{
string fullPath = Path.GetFullPath(path);
if (exactPath)
{
string root = Path.GetPathRoot(path);
isValid = string.IsNullOrEmpty(root.Trim(new char[] { '\\', '/' })) == false;
}
else
{
isValid = Path.IsPathRooted(path);
}
}
catch(Exception ex)
{
isValid = false;
}
return isValid;
}

Par exemple ces return false:

IsValidPath("C:/abc*d");
IsValidPath("C:/abc?d");
IsValidPath("C:/abc\"d");
IsValidPath("C:/abc<d");
IsValidPath("C:/abc>d");
IsValidPath("C:/abc|d");
IsValidPath("C:/abc:d");
IsValidPath("");
IsValidPath("./abc");
IsValidPath("/abc");
IsValidPath("abc");
IsValidPath("abc", false);

Et retourner la valeur true:

IsValidPath(@"C:\\abc");
IsValidPath(@"F:\FILES\");
IsValidPath(@"C:\\abc.docx\\defg.docx");
IsValidPath(@"C:/abc/defg");
IsValidPath(@"C:\\\//\/\\/\\\/abc/\/\/\/\///\\\//\defg");
IsValidPath(@"C:/abc/def~`!@#$%^&()_-+={[}];',.g");
IsValidPath(@"C:\\\\\abc////////defg");
IsValidPath(@"/abc", false);