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

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

Answer 2

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 3

Have you tried regular expressions?

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

should work

Answer 4

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 5

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 6

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.