Determine via C# whether a string is a valid file path

Question

I would like to know how to determine whether string is valid file path.

The file path may or may not exist.

Answer 1

You can use the FileInfo constructor. It will throw a ArgumentException if "The file name is empty, contains only white spaces, or contains invalid characters." It can also throw SecurityException or UnauthorizedAccessException, which I think you can ignore if you're only concerned about format.

Another option is to check against Path.GetInvalidPathChars directly. E.g.:

boolean possiblePath = pathString.IndexOfAny(Path.GetInvalidPathChars()) == -1;

Answer 2

A 100% accurate checking of a path's string format is quite difficult, since it will depend on the filesystem on which it is used (and network protocols if its not on the same computer).

Even within windows or even NTFS its not simple since it still depends on the API .NET is using in the background to communicate with the kernel.

And since most filesystems today support unicode, one might also need to check for all the rules for correcly encoded unicode, normalization, etc etc.

What I'd do is to make some basic checks only, and then handle exceptions properly once the path is used. For possible rules see:

• Wikipedia - Filename for an overview of the rules used by different file systems
• Naming Files, Paths, and Namespaces for windows specific rules

Answer 3

Here are some things you might use:

• to check if the drive is correct (for example on one computer the drive X:\ exists, but not on yours): use Path.IsPathRooted to see if it's not a relative path and then use the drives from Environment.GetLogicalDrives() to see if your path contains one of the valid drives.
• To check for valid characters, you have two methods: Path.GetInvalidFileNameChars() and Path.GetInvalidPathChars() which don't overlap completely. You can also use Path.GetDirectoryName(path) and Path.GetFileName(fileName) with your input name, which will throw an exception if

The path parameter contains invalid characters, is empty, or contains only white spaces.

Answer 4

You can't really be sure until you try to create that file. Maybe the path is valid but the security settings won't allow creation of the file. The only instance that could tell you if the path is REALLY valid would be the OS, so why don't you try to create that file an catch the IOException which indicates it's not valid? In my humble opinion, this is an approach: Assume the input is valid, use it, and catch an IOException when it isn't valid.

Answer 5

Try out this method which would try to cover for all the possible Exceptions scenarios. It would work for almost all the Windows related Paths.

/// <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 fewer than 248 characters, and file names must be fewer 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;
}

Answer 6

Have you tried regular expressions?

^([a-zA-Z]\:)(\\[^\\/:*?<>"|]*(?<![ ]))*(\.[a-zA-Z]{2,6})$

should work

Answer 7

Regex driveCheck = new Regex(@"^[a-zA-Z]:\\$");
      if (string.IsNullOrWhiteSpace(path) || path.Length < 3)
      {
        return false;
      }

      if (!driveCheck.IsMatch(path.Substring(0, 3)))
      {
        return false;
      }
      string strTheseAreInvalidFileNameChars = new string(Path.GetInvalidPathChars());
      strTheseAreInvalidFileNameChars += @":/?*" + "\"";
      Regex containsABadCharacter = new Regex("[" + Regex.Escape(strTheseAreInvalidFileNameChars) + "]");
      if (containsABadCharacter.IsMatch(path.Substring(3, path.Length - 3)))
      {
        return false;
      }

      DirectoryInfo directoryInfo = new DirectoryInfo(Path.GetFullPath(path));
      try
      {
        if (!directoryInfo.Exists)
        {
          directoryInfo.Create();
        }
      }
      catch (Exception ex)
      {
        if (Log.IsErrorEnabled)
        {
          Log.Error(ex.Message);
        }
        return false;
      }`enter code here`

      return true;
    }

Answer 8

You can simply use Path.Combine() inside a try catch statement:

string path = @" your path ";
try
{
    Path.Combine(path);
}
catch
{
    MessageBox.Show("Invalid path");
}

Edit: Note that this function doesn't throw an exception if path contains wildcard characters ('*' and '?') since they can be used in search strings.

Answer 9

I found this at regexlib.com (http://regexlib.com/REDetails.aspx?regexp_id=345) by Dmitry Borysov.

"File Name Validator. Validates both UNC (\server\share\file) and regular MS path (c:\file)"

^(([a-zA-Z]:|\\)\\)?(((\.)|(\.\.)|([^\\/:\*\?"\|<>\. ](([^\\/:\*\?"\|<>\. ])|([^\\/:\*\?"\|<>]*[^\\/:\*\?"\|<>\. ]))?))\\)*[^\\/:\*\?"\|<>\. ](([^\\/:\*\?"\|<>\. ])|([^\\/:\*\?"\|<>]*[^\\/:\*\?"\|<>\. ]))?$

Run it with a Regex.IsMatch and you'll get a bool indicating if it's valid or not. I think regular expressions is the way to go since the file may not exist.

Answer 10

The static class System.IO.Path can do what you're asking for.