You have a path—possibly entered by the user—and you need to verify that it has no illegal characters and that a filename and extension exist.
We use several of the static fields and methods in the
Path
class. We begin by writing a method called
CheckUserEnteredPath
, which accepts a string
containing a path entered by the user and a Boolean value to decide
whether we want to find all illegal characters or just the occurrence
of any illegal character. Just finding any illegal character is much
faster if you don’t care which illegal characters
are present. This method first calls another method, either
FindAnyIllegalChars
or
FindAllIllegalChars
, each of which are described
later in the Solution. If there are no illegal characters in this
path, it is then checked for the existence of a file and
extension:
public bool CheckUserEnteredPath(string path, bool any) { try { Console.WriteLine("Checking path {0}",path); bool illegal = false; // two ways to do the search, one more expensive than the other... if(any == true) illegal = FindAnyIllegalChars(path); else illegal = FindAllIllegalChars(path); if (!illegal) { if (Path.GetFileName(path).Length == 0) { Console.WriteLine("A filename must be entered"); } else if (!Path.HasExtension(path)) { Console.WriteLine("The filename must have an extension"); } else { Console.WriteLine("Path is correct"); return (true); } } } catch(Exception e) { Console.WriteLine(e.ToString( )); } return (false); }
The FindAllIllegalChars
method, which is called by
the CheckUserEnteredPath
method, accepts a string
containing a path. This path is checked for illegal characters by
using the
IndexOfAny
method on
the string class. The IndexOfAny
method finds the
first occurrence of one of the characters supplied to it in the
string being looked at. This method uses the
Path.InvalidPathChars
static field to determine if any illegal characters exist in this
path:
private bool FindAllIllegalChars(string userEnteredPath) { int invalidCharPos = -1; bool endOfPath = false; bool foundIllegalChars = false; while (!endOfPath) { invalidCharPos = userEnteredPath.IndexOfAny(Path.InvalidPathChars, invalidCharPos + 1); if (invalidCharPos == -1) { endOfPath = true; } else { foundIllegalChars = true; Console.WriteLine("Invalid char {0} found at position {1}", userEnteredPath[invalidCharPos],invalidCharPos); if (invalidCharPos >= userEnteredPath.Length - 1) { endOfPath = true; } else { invalidCharPos++; } } } return (foundIllegalChars); }
The FindAnyIllegalChars
method, which is also
called by the CheckUserEnteredPath
method, accepts
a string containing a user entered path. This path is checked for the
existence of any illegal characters by using the
IndexOfAny
method on
the string class. If the IndexOfAny
method finds
anything, we have an illegal path and we return
false
:
private bool FindAnyIllegalChars(string userEnteredPath) { int invalidCharPos = userEnteredPath.IndexOfAny(Path.InvalidPathChars); if (invalidCharPos == -1) { return (false); } else { Console.WriteLine("Invalid char {0} found at position {1}", userEnteredPath[invalidCharPos],invalidCharPos); return (true); } }
This recipe provides a way of verifying a path for invalid characters
before it can be used in your application. This recipe does not
verify that the directory or path exists; use the
Directory.Exists
or File.Exists
methods to perform this verification.
The CheckUserEnteredPath
method starts by calling
the FindAnyIllegalChars
or
FindAllIllegalChars
methods and passing the chosen
one a path string. Two different mechanisms validate the path against
the set of characters supplied by
Path.InvalidPathChars
. This field contains all of the invalid
characters that could be entered into a path string. Both methods
return true
if there are illegal characters found,
but FindAnyIllegalChars
prints information to the
console only for the first one found, whereas
FindAllIllegalChars
prints out information for
every illegal character found.