CODEWITHSUNDEEP
c#.netvalidationpathfilesystems
Diskdrive
Diskdrive

Reputation: 18825

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

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

The file path may or may not exist.

Upvotes: 66

Views: 115364

Answers (11)

Vladislav Mikkoev
Vladislav Mikkoev

Reputation: 21

// Main code here
public static class PathHelper
{
    private const string WindowsLongPathMark = "\\\\?";
    public static bool IsValidPath(string path)
    {
        if (string.IsNullOrWhiteSpace(path))
            return false;

        // You can remove these checks for the OS, leaving the check only for length, or add new ones with length
        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && path.Length > 260 && path.IndexOf(WindowsLongPathMark) == -1)
            return false;
        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) && path.Length > 4096)
            return false;

        if (path.IndexOfAny(Path.GetInvalidPathChars()) >= 0)
            return false;

        if(Uri.TryCreate(path, UriKind.Absolute, out Uri? uri) && uri != null && uri.IsUnc && uri.Host != string.Empty)
            path = uri.AbsolutePath;

        var clearedPath = path;
        if (clearedPath.IndexOf(WindowsLongPathMark) == 0)
            clearedPath = clearedPath.Replace(WindowsLongPathMark, string.Empty);

        if (Path.IsPathRooted(clearedPath))
        {
            var root = Path.GetPathRoot(clearedPath);
            if (clearedPath.IndexOf(root!) > 0)
                return false;

            // Relative path
            if (root!.Length == 1 && root[0] == Path.DirectorySeparatorChar)
                clearedPath = clearedPath.Substring(1);
            // Absolute path
            else
                clearedPath = clearedPath.Replace(root, string.Empty);
        }

        var segments = clearedPath.Split(new[] { Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar });
        if (segments.Any(string.IsNullOrWhiteSpace))
            return false;

        return segments.All(segment => segment.IndexOfAny(Path.GetInvalidFileNameChars()) == -1);
    }
}

// Tests (NUnit)
public class Tests
{
    [TestCase("C:\\SomeFolder")]
    [TestCase("\\\\?C:\\SomeFolder")]
    [TestCase("C:\\SomeFolder\\SomeFile.txt")]
    [TestCase(".\\SomeFolder\\SomeFolderInner")]
    [TestCase("SomeFolder\\SomeFolderInner")]
    [TestCase("SomeFolder")]
    [TestCase("SomeFile.txt")]
    public void Path_is_valid(string path)
    {
        // Act
        var result = PathHelper.IsValidPath(path);

        // Assert
        Assert.True(result);
    }

    [TestCase("C:\\SomeFolder>")]
    [TestCase("C:\\SomeFolder\\SomeF?ile.txt")]
    [TestCase("C:\\SomeFolder\\SomeF<ile.txt")]
    [TestCase("\\   \\SomeFolder")]
    [TestCase("\\\\SomeFolder")]
    [TestCase("\\SomeFolder?")]
    [TestCase("\\SomeFolder\\C:\\")]
    [TestCase("C:\\SomeFolder\\\\\\?")]
    public void Path_is_not_valid(string path)
    {
        // Act
        var result = PathHelper.IsValidPath(path);

        // Assert
        Assert.False(result);
    }
}

This approach without using Regex, try-catch, creating new folder/file. I can edit the code example if I find anything else to add.

Upvotes: 2

Matthew Flaschen
Matthew Flaschen

Reputation: 284786

EDIT: .NET later changed this API. This answer (particularly for ArgumentException), applies to ".NET Framework and .NET Core versions older than 2.1". Thank you to Simon Elms. See his comment below.

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;

Upvotes: 76

vCillusion
vCillusion

Reputation: 1799

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

Upvotes: 2

atamanroman
atamanroman

Reputation: 11808

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.

Upvotes: 4

Ghislain Zabatio
Ghislain Zabatio

Reputation: 214

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

Upvotes: 1

vaitrafra
vaitrafra

Reputation: 662

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

Upvotes: -3

Jerry
Jerry

Reputation: 4408

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.

Upvotes: 1

Stefan
Stefan

Reputation: 4317

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:

Upvotes: 29

Rox
Rox

Reputation: 2023

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.

Upvotes: 8

Jonas Stensved
Jonas Stensved

Reputation: 15276

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.

Upvotes: 0

Justin L.
Justin L.

Reputation: 13600

Have you tried regular expressions?

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

should work

Upvotes: 2

Related Questions