it-swarm.cn

如何在视窗下检查给定字符串是否是合法/有效的文件名?

我想在我的应用程序中包含批处理文件重命名功能。用户可以键入目标文件名模式和(在替换模式中的一些通配符之后)我需要检查它是否是Windows下的合法文件名。我尝试使用像[a-zA-Z0-9_]+这样的正则表达式,但它不包含来自各种语言的许多国家特定字符(例如变音符号等)。做这种检查的最佳方法是什么?

153
tomash

您可以从 Path.GetInvalidPathCharsGetInvalidFileNameChars 获取无效字符列表。

UPD: 请参阅 Steve Cooper的建议 关于如何在正则表达式中使用它们。

UPD2: 请注意,根据MSDN中的“备注”部分,“不保证从此方法返回的数组包含文件和目录名称中无效的完整字符集”。 由sixlettervaliables提供的答案 详细说明。

97
Eugene Katz

来自 MSDN的“命名文件或目录” 这里是Windows下合法文件名的一般约定:

您可以使用当前代码页中的任何字符(Unicode/ANSI高于127),除了:

  • <>:"/\|?*
  • 整数表示为0-31(小于ASCII空格)的字符
  • 目标文件系统不允许的任何其他字符(例如,尾随句点或空格)
  • 任何DOS名称:CON,PRN,AUX,NUL,COM0,COM1,COM2,COM3,COM4,COM5,COM6,COM7,COM8,COM9,LPT0,LPT1,LPT2,LPT3,LPT4,LPT5,LPT6,LPT7, LPT8,LPT9(并避免AUX.txt等)
  • 文件名是所有句点

一些可选的东西要检查:

  • 文件路径(包括文件名)不得超过260个字符(不使用\?\前缀)
  • 使用\?\时,Unicode文件路径(包括文件名)超过32,000个字符(注意前缀可能会扩展目录组件并导致它溢出32,000个限制)
119
user7116

对于 .Net框架之前的3.5 这应该工作:

正则表达式匹配应该可以帮到你。这是使用System.IO.Path.InvalidPathChars常量的片段;

bool IsValidFilename(string testName)
{
    Regex containsABadCharacter = new Regex("[" 
          + Regex.Escape(System.IO.Path.InvalidPathChars) + "]");
    if (containsABadCharacter.IsMatch(testName)) { return false; };

    // other checks for UNC, drive-path format, etc

    return true;
}

对于 .Net框架后3.0 这应该工作:

http://msdn.Microsoft.com/en-us/library/system.io.path.getinvalidpathchars(v=vs.90).aspx

正则表达式匹配应该可以帮到你。这是使用System.IO.Path.GetInvalidPathChars()常量的片段;

bool IsValidFilename(string testName)
{
    Regex containsABadCharacter = new Regex("["
          + Regex.Escape(new string(System.IO.Path.GetInvalidPathChars())) + "]");
    if (containsABadCharacter.IsMatch(testName)) { return false; };

    // other checks for UNC, drive-path format, etc

    return true;
}

一旦你知道,你还应该检查不同的格式,例如c:\my\drive\\server\share\dir\file.ext

63
Steve Cooper

尝试使用它,并捕获错误。允许的集可能会跨文件系统或跨不同版本的Windows进行更改。换句话说,如果您想知道Windows是否喜欢该名称,请将其命名并让它告诉您。

25
Dewayne Christensen

该类清除文件名和路径;用它就像

var myCleanPath = PathSanitizer.SanitizeFilename(myBadPath, ' ');

这是代码;

/// <summary>
/// Cleans paths of invalid characters.
/// </summary>
public static class PathSanitizer
{
    /// <summary>
    /// The set of invalid filename characters, kept sorted for fast binary search
    /// </summary>
    private readonly static char[] invalidFilenameChars;
    /// <summary>
    /// The set of invalid path characters, kept sorted for fast binary search
    /// </summary>
    private readonly static char[] invalidPathChars;

    static PathSanitizer()
    {
        // set up the two arrays -- sorted once for speed.
        invalidFilenameChars = System.IO.Path.GetInvalidFileNameChars();
        invalidPathChars = System.IO.Path.GetInvalidPathChars();
        Array.Sort(invalidFilenameChars);
        Array.Sort(invalidPathChars);

    }

    /// <summary>
    /// Cleans a filename of invalid characters
    /// </summary>
    /// <param name="input">the string to clean</param>
    /// <param name="errorChar">the character which replaces bad characters</param>
    /// <returns></returns>
    public static string SanitizeFilename(string input, char errorChar)
    {
        return Sanitize(input, invalidFilenameChars, errorChar);
    }

    /// <summary>
    /// Cleans a path of invalid characters
    /// </summary>
    /// <param name="input">the string to clean</param>
    /// <param name="errorChar">the character which replaces bad characters</param>
    /// <returns></returns>
    public static string SanitizePath(string input, char errorChar)
    {
        return Sanitize(input, invalidPathChars, errorChar);
    }

    /// <summary>
    /// Cleans a string of invalid characters.
    /// </summary>
    /// <param name="input"></param>
    /// <param name="invalidChars"></param>
    /// <param name="errorChar"></param>
    /// <returns></returns>
    private static string Sanitize(string input, char[] invalidChars, char errorChar)
    {
        // null always sanitizes to null
        if (input == null) { return null; }
        StringBuilder result = new StringBuilder();
        foreach (var characterToTest in input)
        {
            // we binary search for the character in the invalid set. This should be lightning fast.
            if (Array.BinarySearch(invalidChars, characterToTest) >= 0)
            {
                // we found the character in the array of 
                result.Append(errorChar);
            }
            else
            {
                // the character was not found in invalid, so it is valid.
                result.Append(characterToTest);
            }
        }

        // we're done.
        return result.ToString();
    }

}
23
Steve Cooper

这是我使用的:

    public static bool IsValidFileName(this string expression, bool platformIndependent)
    {
        string sPattern = @"^(?!^(PRN|AUX|CLOCK\$|NUL|CON|COM\d|LPT\d|\..*)(\..+)?$)[^\x00-\x1f\\?*:\"";|/]+$";
        if (platformIndependent)
        {
           sPattern = @"^(([a-zA-Z]:|\\)\\)?(((\.)|(\.\.)|([^\\/:\*\?""\|<>\. ](([^\\/:\*\?""\|<>\. ])|([^\\/:\*\?""\|<>]*[^\\/:\*\?""\|<>\. ]))?))\\)*[^\\/:\*\?""\|<>\. ](([^\\/:\*\?""\|<>\. ])|([^\\/:\*\?""\|<>]*[^\\/:\*\?""\|<>\. ]))?$";
        }
        return (Regex.IsMatch(expression, sPattern, RegexOptions.CultureInvariant));
    }

第一个模式创建一个正则表达式,其中仅包含Windows平台的无效/非法文件名和字符。第二个做同样的事情,但确保该名称对任何平台都是合法的。

22
Scott Dorman

记住一个角落的情况,当我第一次发现它时让我感到惊讶:Windows允许文件名中的前导空格字符!例如,以下是Windows上的所有合法且不同的文件名(减去引号):

"file.txt"
" file.txt"
"  file.txt"

从中可以看出:在编写用于修剪文件名字符串中的前导/尾随空格的代码时要小心。

18
Jon Schneider

简化Eugene Katz的答案:

bool IsFileNameCorrect(string fileName){
    return !fileName.Any(f=>Path.GetInvalidFileNameChars().Contains(f))
}

要么

bool IsFileNameCorrect(string fileName){
    return fileName.All(f=>!Path.GetInvalidFileNameChars().Contains(f))
}
9
tmt

Microsoft Windows:Windows内核禁止使用范围1-31(即0x01-0x1F)和字符“*:<>?\ |中的字符。虽然NTFS允许每个路径组件(目录或文件名)长度为255个字符,最长约32767个字符的路径,Windows内核仅支持长达259个字符的路径。此外,Windows禁止使用MS-DOS设备名称AUX,CLOCK $,COM1,COM2,COM3,COM4,COM5,COM6, COM7,COM8,COM9,CON,LPT1,LPT2,LPT3,LPT4,LPT5,LPT6,LPT7,LPT8,LPT9,NUL和PRN,以及带有任何扩展名的这些名称(例如,AUX.txt),使用时除外长UNC路径(例如\。\ C:\ nul.txt或\?\ D:\ aux\con)。(实际上,如果提供了扩展,则可以使用CLOCK $。)这些限制仅适用于Windows - 例如,Linux允许使用“*:<>?\|甚至在NTFS。

资料来源: http://en.wikipedia.org/wiki/Filename

8
Martin Faartoft

您可以使用正则表达式检查是否存在非法字符,然后报告错误,而不是明确包含所有可能的字符。理想情况下,您的应用程序应该按照用户的意愿命名文件,并且只有在遇到错误时才会犯规。

7
ConroyP

我使用它来摆脱文件名中的无效字符而不抛出异常:

private static readonly Regex InvalidFileRegex = new Regex(
    string.Format("[{0}]", Regex.Escape(@"<>:""/\|?*")));

public static string SanitizeFileName(string fileName)
{
    return InvalidFileRegex.Replace(fileName, string.Empty);
}
6
JoelFan

此外,CON,PRN,AUX,NUL,COM#和其他一些内容在任何具有任何扩展名的目录中都不是合法的文件名。

5
Roland Rabien

问题是你试图确定路径名是否是合法的Windows路径,或者它是否合法在代码运行的系统上。?我认为后者更重要,所以个人而言,我可能会分解完整路径并尝试使用_mkdir来创建文件所属的目录,然后尝试创建该文件。

这样,您不仅知道路径是否仅包含有效的窗口字符,而且它实际上是否表示此进程可以写入的路径。

5
kfh

为了补充其他答案,您可能需要考虑以下几个其他Edge案例。

4
Joe

_ msdn _ ,这是一个不允许的字符列表:

使用当前代码页中的几乎任何字符作为名称,包括扩展字符集(128-255)中的Unicode字符和字符,但以下情况除外:

  • 不允许使用以下保留字符:<>:“/\|?*
  • 不允许整数表示在0到31范围内的字符。
  • 目标文件系统不允许的任何其他字符。
3
Mark Biek

对于这种情况,正则表达式是过度的。您可以将String.IndexOfAny()方法与Path.GetInvalidPathChars()Path.GetInvalidFileNameChars()结合使用。

另请注意,两个Path.GetInvalidXXX()方法都克隆内部数组并返回克隆。因此,如果您要执行此操作(成千上万次),则可以缓存无效字符数组的副本以供重用。

2
s n

目标文件系统也很重要。

在NTFS下,某些文件无法在特定目录中创建。例如。 $ root用户启动

2
Dominik Weber

这是一个已经回答的问题,但仅仅是为了“其他选项”,这里有一个非理想的问题:

(非理想,因为使用Exceptions作为流量控制是一种“坏事”,一般而言)

public static bool IsLegalFilename(string name)
{
    try 
    {
        var fileInfo = new FileInfo(name);
        return true;
    }
    catch
    {
        return false;
    }
}
2
JerKimball

如果您只是想检查一个包含文件名/路径的字符串是否包含任何无效字符,我发现最快的方法是使用Split()将文件名分解为一个部分数组,无论哪里有无效字符。如果结果只是1的数组,则没有无效字符。 :-)

var nameToTest = "Best file name \"ever\".txt";
bool isInvalidName = nameToTest.Split(System.IO.Path.GetInvalidFileNameChars()).Length > 1;

var pathToTest = "C:\\My Folder <secrets>\\";
bool isInvalidPath = pathToTest.Split(System.IO.Path.GetInvalidPathChars()).Length > 1;

我尝试在LinqPad中在文件/路径名上运行这个和上面提到的其他方法1,000,000次。

使用Split()只有~850ms。

使用Regex("[" + Regex.Escape(new string(System.IO.Path.GetInvalidPathChars())) + "]")约为6秒。

更复杂的正则表达式更糟糕,正如其他一些选项一样,比如使用Path类上的各种方法来获取文件名并让它们的内部验证完成工作(很可能是由于异常处理的开销)。

当然,您不需要经常验证100万个文件名,因此无论如何,对于大多数这些方法来说,单次迭代就可以了。但是如果你只是在寻找无效的字符,它仍然非常高效和有效。

1
Nick Albrecht

如果文件名太长并且在Windows 10之前的环境中运行,则许多答案将无效。类似地,考虑一下你想用句点做什么 - 允许前导或尾随在技术上是有效的,但如果你不希望文件分别难以看到或删除,可能会产生问题。

这是我为检查有效文件名而创建的验证属性。

public class ValidFileNameAttribute : ValidationAttribute
{
    public ValidFileNameAttribute()
    {
        RequireExtension = true;
        ErrorMessage = "{0} is an Invalid Filename";
        MaxLength = 255; //superseeded in modern windows environments
    }
    public override bool IsValid(object value)
    {
        //http://stackoverflow.com/questions/422090/in-c-sharp-check-that-filename-is-possibly-valid-not-that-it-exists
        var fileName = (string)value;
        if (string.IsNullOrEmpty(fileName)) { return true;  }
        if (fileName.IndexOfAny(Path.GetInvalidFileNameChars()) > -1 ||
            (!AllowHidden && fileName[0] == '.') ||
            fileName[fileName.Length - 1]== '.' ||
            fileName.Length > MaxLength)
        {
            return false;
        }
        string extension = Path.GetExtension(fileName);
        return (!RequireExtension || extension != string.Empty)
            && (ExtensionList==null || ExtensionList.Contains(extension));
    }
    private const string _sepChar = ",";
    private IEnumerable<string> ExtensionList { get; set; }
    public bool AllowHidden { get; set; }
    public bool RequireExtension { get; set; }
    public int MaxLength { get; set; }
    public string AllowedExtensions {
        get { return string.Join(_sepChar, ExtensionList); } 
        set {
            if (string.IsNullOrEmpty(value))
            { ExtensionList = null; }
            else {
                ExtensionList = value.Split(new char[] { _sepChar[0] })
                    .Select(s => s[0] == '.' ? s : ('.' + s))
                    .ToList();
            }
    } }

    public override bool RequiresValidationContext => false;
}

和测试

[TestMethod]
public void TestFilenameAttribute()
{
    var rxa = new ValidFileNameAttribute();
    Assert.IsFalse(rxa.IsValid("pptx."));
    Assert.IsFalse(rxa.IsValid("pp.tx."));
    Assert.IsFalse(rxa.IsValid("."));
    Assert.IsFalse(rxa.IsValid(".pp.tx"));
    Assert.IsFalse(rxa.IsValid(".pptx"));
    Assert.IsFalse(rxa.IsValid("pptx"));
    Assert.IsFalse(rxa.IsValid("a/abc.pptx"));
    Assert.IsFalse(rxa.IsValid("a\\abc.pptx"));
    Assert.IsFalse(rxa.IsValid("c:abc.pptx"));
    Assert.IsFalse(rxa.IsValid("c<abc.pptx"));
    Assert.IsTrue(rxa.IsValid("abc.pptx"));
    rxa = new ValidFileNameAttribute { AllowedExtensions = ".pptx" };
    Assert.IsFalse(rxa.IsValid("abc.docx"));
    Assert.IsTrue(rxa.IsValid("abc.pptx"));
}
1
Brent

我的尝试:

using System.IO;

static class PathUtils
{
  public static string IsValidFullPath([NotNull] string fullPath)
  {
    if (string.IsNullOrWhiteSpace(fullPath))
      return "Path is null, empty or white space.";

    bool pathContainsInvalidChars = fullPath.IndexOfAny(Path.GetInvalidPathChars()) != -1;
    if (pathContainsInvalidChars)
      return "Path contains invalid characters.";

    string fileName = Path.GetFileName(fullPath);
    if (fileName == "")
      return "Path must contain a file name.";

    bool fileNameContainsInvalidChars = fileName.IndexOfAny(Path.GetInvalidFileNameChars()) != -1;
    if (fileNameContainsInvalidChars)
      return "File name contains invalid characters.";

    if (!Path.IsPathRooted(fullPath))
      return "The path must be absolute.";

    return "";
  }
}

这并不完美,因为Path.GetInvalidPathChars不会返回文件和目录名称中无效的完整字符集,当然还有更多细微之处。

所以我用这个方法作为补充:

public static bool TestIfFileCanBeCreated([NotNull] string fullPath)
{
  if (string.IsNullOrWhiteSpace(fullPath))
    throw new ArgumentException("Value cannot be null or whitespace.", "fullPath");

  string directoryName = Path.GetDirectoryName(fullPath);
  if (directoryName != null) Directory.CreateDirectory(directoryName);
  try
  {
    using (new FileStream(fullPath, FileMode.CreateNew)) { }
    File.Delete(fullPath);
    return true;
  }
  catch (IOException)
  {
    return false;
  }
}

它尝试创建文件,如果有异常则返回false。当然,我需要创建文件,但我认为这是最安全的方法。另请注意,我没有删除已创建的目录。

您还可以使用第一种方法进行基本验证,然后在使用路径时仔细处理异常。

1
Maxence

这个检查

static bool IsValidFileName(string name)
{
    return
        !string.IsNullOrWhiteSpace(name) &&
        name.IndexOfAny(Path.GetInvalidFileNameChars()) < 0 &&
        !Path.GetFullPath(name).StartsWith(@"\\.\");
}

过滤掉带有无效字符的名称(<>:"/\|?*和ASCII 0-31),以及保留的DOS设备(CONNULCOMx)。它允许前导空格和全点名称,与Path.GetFullPath一致。 (在我的系统上创建带有前导空格的文件成功)。


使用的.NET Framework 4.7.1,在Windows 7上测试过。

0
Vlad

我从某人那里得到了这个想法。 - 不知道是谁。让操作系统做繁重的工作。

public bool IsPathFileNameGood(string fname)
{
    bool rc = Constants.Fail;
    try
    {
        this._stream = new StreamWriter(fname, true);
        rc = Constants.Pass;
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message, "Problem opening file");
        rc = Constants.Fail;
    }
    return rc;
}
0
KenR

一个用于验证字符串中非法字符的班轮:

public static bool IsValidFilename(string testName) => !Regex.IsMatch(testName, "[" + Regex.Escape(new string(System.IO.Path.InvalidPathChars)) + "]");
0
Zananok

我建议只使用Path.GetFullPath()

string tagetFileFullNameToBeChecked;
try
{
  Path.GetFullPath(tagetFileFullNameToBeChecked)
}
catch(AugumentException ex)
{
  // invalid chars found
}
0
Tony Sun