特定の文字列がWindowsで有効なファイル名であるかどうかを確認するにはどうすればよいですか？

アプリケーションにバッチファイルの名前変更機能を含めたいのですが。ユーザーは宛先ファイル名のパターンを入力できます（パターン内のいくつかのワイルドカードを置き換えた後）、それがWindowsで有効なファイル名になるかどうかを確認する必要があります。のように正規表現を使用しようとしました[a-zA-Z0-9_]+が、さまざまな言語（ウムラウトなど）からの国固有の文字が多く含まれていません。そのようなチェックを行う最良の方法は何ですか？

Path.GetInvalidPathCharsおよびから無効な文字のリストを取得できますGetInvalidFileNameChars。

UPD：正規表現でこれらを使用する方法に関するSteve Cooperの提案を参照してください。

UPD2： MSDNの備考セクションによると、「このメソッドから返される配列には、ファイル名とディレクトリ名で無効な文字の完全なセットが含まれているとは限りません。」sixlettervaliablesによって提供される答えは、より詳細になります。

MSDNの「ファイルまたはディレクトリの命名」から、 Windowsでの正当なファイル名の一般的な規則は次のとおりです。

現在のコードページ（127を超えるUnicode / ANSI）では、次の文字を除く任意の文字を使用できます。

• < > : " / \ | ? *
• 整数表現が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文字以下にする必要があります（\?\プレフィックスを使用しません）
• 使用時に32,000文字を超えるUnicodeファイルパス（ファイル名を含む）\?\（接頭辞がディレクトリコンポーネントを展開し、32,000の制限をオーバーフローさせる可能性があることに注意してください）

3.5より前の.Net Frameworksの場合、これは機能するはずです。

正規表現のマッチングにより、何らかの方法が得られるはずです。これは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

それを使用してみて、エラーをトラップしてください。許可されたセットは、ファイルシステム間で、またはWindowsの異なるバージョン間で変更される可能性があります。つまり、Windowsがその名前を気に入っているかどうかを知りたい場合は、その名前を渡して教えてもらいます。

このクラスは、ファイル名とパスをクリーンアップします。好きに使う

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

}

これは私が使用するものです：

    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プラットフォームの場合のみ、無効/不正なファイル名と文字を含む正規表現を作成します。2番目のものも同じことを行いますが、名前がどのプラットフォームでも合法であることを確認します。

Windowsでファイル名の先頭にスペース文字を使用できるようになりました。たとえば、以下はすべてWindowsでの合法で明確なファイル名です（引用符を除く）。

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

これからの1つの要点：ファイル名の文字列から先頭/末尾の空白を削除するコードを書くときは注意してください。

ユージーン・カッツの答えを単純化する：

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

または

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

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

考えられるすべての文字を明示的に含めるのではなく、正規表現を使用して不正な文字の存在を確認し、エラーを報告することができます。理想的には、アプリケーションはユーザーの希望どおりにファイルに名前を付け、エラーに遭遇した場合にのみ反則する必要があります。

問題は、パス名が有効なWindowsパスであるかどうか、またはコードが実行されているシステムで有効かどうかを判断しようとしていることです。？後者の方が重要だと思うので、個人的にはおそらくフルパスを分解し、_mkdirを使用してファイルが属するディレクトリを作成してから、ファイルを作成してみます。

これにより、パスに有効なWindows文字のみが含まれるかどうかだけでなく、実際にこのプロセスで書き込めるパスを表すかどうかもわかります。

これを使用して、例外をスローせずにファイル名の無効な文字を削除します。

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

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

また、CON、PRN、AUX、NUL、COM＃およびその他のいくつかは、任意の拡張子を持つディレクトリ内の正当なファイル名にはなりません。

他の回答を補足するために、考慮すべき追加のエッジケースをいくつか示します。

• 名前に「[」または「]」の文字が含まれるファイルにブックを保存すると、Excelで問題が発生する可能性があります。詳細については、http：//support.microsoft.com/kb/215205を参照してください。

• SharePointには、追加の一連の制限があります。詳細については、http：//support.microsoft.com/kb/905231を参照してください。

MSDNから、許可されていない文字のリストを次に示します。

Unicode文字や拡張文字セット（128〜255）の文字を含む、現在のコードページのほとんどすべての文字を名前に使用します。ただし、次のものは除きます。

• 次の予約文字は使用できません：<>： "/ \ |？*
• 整数表現が0から31の範囲にある文字は許可されません。
• ターゲットファイルシステムで許可されていないその他の文字。

また、宛先ファイルシステムも重要です。

NTFSでは、特定のディレクトリに作成できないファイルがあります。EG $ Boot in root

これは既に回答済みの質問ですが、「その他のオプション」のために、理想的ではないものを次に示します。

（例外をフロー制御として使用することは一般的に「悪いこと」であるため、理想的ではありません）

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

正規表現は、この状況ではやりすぎです。このString.IndexOfAny()メソッドは、Path.GetInvalidPathChars()およびと組み合わせて使用できますPath.GetInvalidFileNameChars()。

また、どちらのPath.GetInvalidXXX()メソッドも内部配列を複製し、その複製を返すことにも注意してください。そのため、これを何度も（数千回、数千回）行う場合は、無効な文字配列のコピーをキャッシュして再利用できます。

ファイル名/パスを保持する文字列に無効な文字が含まれているかどうかを確認するだけの場合、私が見つけた最も速い方法は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回の反復で問題ありません。しかし、無効な文字だけを探している場合でも、かなり効率的で効果的です。

ファイル名が長すぎて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"));
}

私の試み：

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を返します。もちろん、ファイルを作成する必要がありますが、それが最も安全な方法だと思います。また、作成されたディレクトリは削除しないことに注意してください。

最初の方法を使用して基本的な検証を行い、パスが使用されている場合は例外を注意深く処理することもできます。

Path.GetFullPath（）を使用することをお勧めします

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

私は誰かからこのアイデアを得ました。-誰だかわからない。OSに大仕事を任せましょう。

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

このチェック

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

無効な文字（と名前出フィルタ<>:"/\|?*およびASCII 0〜31）と同様に、予約済みのDOSデバイス（CON、NUL、COMx）。と一致して、先行スペースとすべてドット名を許​​可しPath.GetFullPathます。（先頭のスペースを含むファイルの作成は、私のシステムでは成功しています）。

Windows 7でテストされた.NET Framework 4.7.1を使用。

文字列内の不正な文字を検証するための1つのライナー：

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

私の意見では、この質問に対する唯一の適切な答えは、パスを使用して、OSとファイルシステムに検証させることです。それ以外の場合は、OSとファイルシステムがすでに使用しているすべての検証ルールを再実装しているだけで（おそらく不十分です）、それらのルールが将来変更される場合は、それらに一致するようにコードを変更する必要があります。

Windowsのファイル名はそう実際にそれがさえないかもしれない、かなり制限のないされているという問題の多く。Windowsで許可されていない文字は次のとおりです。

\ / : * ? " < > |

これらの文字が存在するかどうかを確認する式を簡単に作成できます。しかし、より良い解決策は、ユーザーが望むようにファイルに名前を付けて、ファイル名が付かないときに警告することです。