This article shows a way of verifying a path for invalid characters before it can be used in your application. The path information can be possibly entered by the user. It does not verify that the directory or path exists; use the Directory.Exists or File.Exists methods to perform this verification.

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

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.

Popularity: 2% [?]