Jak sprawdzić, czy podany ciąg jest prawidłową / prawidłową nazwą pliku w systemie Windows?

Chcę dołączyć funkcję zmiany nazwy pliku wsadowego do mojej aplikacji. Użytkownik może wpisać wzorzec docelowej nazwy pliku i (po zastąpieniu niektórych symboli wieloznacznych we wzorcu) muszę sprawdzić, czy będzie to poprawna nazwa pliku w systemie Windows. Próbowałem użyć wyrażenia regularnego, takiego jak, [a-zA-Z0-9_]+ale nie zawiera ono wielu znaków narodowych z różnych języków (np. Umlauty i tak dalej). Jaki jest najlepszy sposób wykonania takiej kontroli?

Możesz pobrać listę nieprawidłowych znaków z Path.GetInvalidPathCharsi GetInvalidFileNameChars.

UPD: Zobacz sugestię Steve'a Coopera, jak używać ich w wyrażeniu regularnym.

UPD2: Należy zauważyć, że zgodnie z sekcją Uwagi w witrynie MSDN „Nie gwarantuje się, że tablica zwrócona przez tę metodę będzie zawierała pełny zestaw znaków, które są nieprawidłowe w nazwach plików i katalogów”. Odpowiedź udzielona przez sixlettervaliables zawiera więcej szczegółów.

Z artykułu „Nazywanie pliku lub katalogu” w witrynie MSDN można zapoznać się z ogólnymi konwencjami określającymi prawidłową nazwę pliku w systemie Windows:

Możesz użyć dowolnego znaku w bieżącej stronie kodowej (Unicode / ANSI powyżej 127), z wyjątkiem:

• < > : " / \ | ? *
• Znaki, których reprezentacje liczb całkowitych mieszczą się w zakresie 0-31 (mniej niż spacja ASCII)
• Każdy inny znak, na który docelowy system plików nie zezwala (np. Końcowe kropki lub spacje)
• Dowolna z nazw 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 (unikaj plików AUX.txt itp.)
• Nazwa pliku to wszystkie kropki

Kilka opcjonalnych rzeczy do sprawdzenia:

• Ścieżki plików (w tym nazwa pliku) nie mogą mieć więcej niż 260 znaków (bez \?\prefiksu)
• Ścieżki plików Unicode (w tym nazwa pliku) zawierające ponad 32 000 znaków \?\(należy pamiętać, że prefiks może rozszerzyć składniki katalogu i spowodować przekroczenie limitu 32 000)

W przypadku .Net Frameworks starszych niż 3.5 powinno to działać:

Dopasowywanie wyrażeń regularnych powinno ci pomóc. Oto fragment używający System.IO.Path.InvalidPathCharsstałej;

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

W przypadku .Net Frameworks po wersji 3.0 powinno to działać:

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

Dopasowywanie wyrażeń regularnych powinno ci pomóc. Oto fragment używający System.IO.Path.GetInvalidPathChars()stałej;

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

Gdy już to wiesz, powinieneś również sprawdzić różne formaty, np. c:\my\driveI\\server\share\dir\file.ext

Spróbuj go użyć i wyłapuj błąd. Dozwolony zestaw może się zmieniać w różnych systemach plików lub w różnych wersjach systemu Windows. Innymi słowy, jeśli chcesz wiedzieć, czy Windows lubi tę nazwę, podaj jej nazwę i pozwól jej powiedzieć.

Ta klasa czyści nazwy plików i ścieżki; użyj go jak

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

Oto kod;

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

}

Oto czego używam:

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

Pierwszy wzorzec tworzy wyrażenie regularne zawierające nieprawidłowe / niedozwolone nazwy plików i znaki tylko dla platform Windows. Drugi robi to samo, ale zapewnia, że ​​nazwa jest legalna dla każdej platformy.

Jeden narożny przypadek, o którym należy pamiętać, który mnie zaskoczył, gdy się o tym dowiedziałem: Windows pozwala na wprowadzanie spacji w nazwach plików! Na przykład wszystkie poniższe są poprawnymi i różnymi nazwami plików w systemie Windows (bez cudzysłowów):

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

Jeden wniosek z tego: zachowaj ostrożność podczas pisania kodu, który odcina początkowe / końcowe białe znaki z ciągu znaków nazwy pliku.

Upraszczając odpowiedź Eugene'a Katza:

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

Lub

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

Microsoft Windows: jądro systemu Windows zabrania używania znaków z zakresu 1-31 (tj. 0x01-0x1F) i znaków „*: <>? \ |. Chociaż system NTFS dopuszcza, aby każdy składnik ścieżki (katalog lub nazwa pliku) miał 255 znaków i o długości do około 32767 znaków, jądro Windows obsługuje tylko ścieżki o długości do 259 znaków. Dodatkowo Windows zabrania używania nazw urządzeń MS-DOS AUX, CLOCK $, COM1, COM2, COM3, COM4, ​​COM5, COM6, COM7, COM8, COM9, CON, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, LPT9, NUL i PRN, a także te nazwy z dowolnym rozszerzeniem (na przykład AUX.txt), z wyjątkiem używania Długie ścieżki UNC (np. \. \ C: \ nul.txt lub \? \ D: \ aux \ con). (W rzeczywistości CLOCK $ może być używany, jeśli podano rozszerzenie). Te ograniczenia dotyczą tylko systemu Windows - Na przykład Linux pozwala na użycie „*: <>? \ | nawet w NTFS.

Źródło: http://en.wikipedia.org/wiki/Filename

Zamiast jawnie uwzględniać wszystkie możliwe znaki, możesz użyć wyrażenia regularnego, aby sprawdzić obecność niedozwolonych znaków, a następnie zgłosić błąd. W idealnym przypadku aplikacja powinna nazywać pliki dokładnie tak, jak sobie tego życzy użytkownik, i płakać tylko wtedy, gdy natknie się na błąd.

Pytanie brzmi, czy próbujesz ustalić, czy nazwa ścieżki jest prawidłową ścieżką systemu Windows, czy też jest legalna w systemie, w którym działa kod. ? Myślę, że to drugie jest ważniejsze, więc osobiście prawdopodobnie zdekomponowałbym pełną ścieżkę i spróbowałbym użyć _mkdir do utworzenia katalogu, do którego należy plik, a następnie spróbuję utworzyć plik.

W ten sposób wiesz nie tylko, czy ścieżka zawiera tylko prawidłowe znaki systemu Windows, ale także czy faktycznie reprezentuje ścieżkę, którą można zapisać w tym procesie.

Używam tego, aby pozbyć się nieprawidłowych znaków w nazwach plików bez rzucania wyjątków:

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

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

Również CON, PRN, AUX, NUL, COM # i kilka innych nigdy nie są legalnymi nazwami plików w żadnym katalogu z jakimkolwiek rozszerzeniem.

Aby uzupełnić inne odpowiedzi, oto kilka dodatkowych skrajnych przypadków, które warto rozważyć.

• Program Excel może mieć problemy, jeśli zapiszesz skoroszyt w pliku, którego nazwa zawiera znaki „[” lub „]”. Szczegółowe informacje można znaleźć pod adresem http://support.microsoft.com/kb/215205 .

• Sharepoint ma cały dodatkowy zestaw ograniczeń. Widzieć informacje można adresem http://support.microsoft.com/kb/905231 .

W witrynie MSDN znajduje się lista niedozwolonych znaków:

Użyj prawie każdego znaku w bieżącej stronie kodowej dla nazwy, w tym znaków Unicode i znaków z rozszerzonego zestawu znaków (128–255), z wyjątkiem następujących:

• Następujące znaki zastrzeżone są niedozwolone: ​​<>: "/ \ |? *
• Znaki, których reprezentacje liczb całkowitych mieszczą się w zakresie od zera do 31, są niedozwolone.
• Każdy inny znak, na który nie zezwala docelowy system plików.

Ważny jest również docelowy system plików.

W systemie NTFS niektórych plików nie można tworzyć w określonych katalogach. EG $ Uruchom w katalogu głównym

To jest już pytanie, na które udzielono już odpowiedzi, ale ze względu na „Inne opcje”, oto pytanie nie idealne:

(nie jest to idealne rozwiązanie, ponieważ używanie wyjątków jako kontroli przepływu jest ogólnie „złą rzeczą”)

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

W tej sytuacji wyrażenia regularne są przesadą. Możesz użyć tej String.IndexOfAny()metody w połączeniu z Path.GetInvalidPathChars()i Path.GetInvalidFileNameChars().

Zauważ również, że obie Path.GetInvalidXXX()metody klonują wewnętrzną tablicę i zwracają clone. Więc jeśli zamierzasz robić to dużo (tysiące i tysiące razy), możesz buforować kopię nieprawidłowej tablicy znaków w celu ponownego wykorzystania.

Jeśli próbujesz tylko sprawdzić, czy ciąg zawierający nazwę / ścieżkę pliku zawiera nieprawidłowe znaki, najszybszą metodą, jaką znalazłem, jest Split()podzielenie nazwy pliku na tablicę części, gdziekolwiek jest nieprawidłowy znak. Jeśli wynik jest tylko tablicą 1, nie ma nieprawidłowych znaków. :-)

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;

Próbowałem uruchomić tę i inne metody wymienione powyżej na nazwie pliku / ścieżki 1000000 razy w LinqPad.

Używanie Split()trwa tylko ~ 850 ms.

Użycie Regex("[" + Regex.Escape(new string(System.IO.Path.GetInvalidPathChars())) + "]")trwa około 6 sekund.

Bardziej skomplikowane wyrażenia regularne są DUŻO gorzej, podobnie jak niektóre inne opcje, takie jak użycie różnych metod Pathklasy w celu uzyskania nazwy pliku i umożliwienia ich wewnętrznej walidacji (najprawdopodobniej z powodu narzutu obsługi wyjątków).

To prawda, że ​​niezbyt często trzeba sprawdzać poprawność 1 miliona nazw plików, więc i tak pojedyncza iteracja jest odpowiednia dla większości tych metod. Ale nadal jest dość wydajny i skuteczny, jeśli szukasz tylko nieprawidłowych znaków.

wiele z tych odpowiedzi nie zadziała, jeśli nazwa pliku jest zbyt długa i działa w środowisku starszym niż Windows 10. Podobnie zastanów się, co chcesz zrobić z kropkami - zezwalanie na początkowe lub końcowe jest poprawne technicznie, ale może powodować problemy, jeśli nie chcesz, aby plik był odpowiednio trudny do zobaczenia lub usunięcia.

To jest atrybut walidacji, który utworzyłem, aby sprawdzić poprawną nazwę pliku.

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

i testy

[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"));
}

Moja próba:

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

To nie jest idealne, ponieważ Path.GetInvalidPathCharsnie zwraca pełnego zestawu znaków, które są nieprawidłowe w nazwach plików i katalogów, i oczywiście jest o wiele więcej subtelności.

Więc używam tej metody jako uzupełnienia:

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

Próbuje utworzyć plik i zwrócić false, jeśli wystąpi wyjątek. Oczywiście muszę utworzyć plik, ale myślę, że to najbezpieczniejszy sposób. Należy również pamiętać, że nie usuwam utworzonych katalogów.

Możesz również użyć pierwszej metody, aby przeprowadzić podstawową walidację, a następnie ostrożnie obsłużyć wyjątki, gdy używana jest ścieżka.

Proponuję po prostu użyć Path.GetFullPath ()

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

Dostałem od kogoś ten pomysł. - nie wiem kto. Niech system operacyjny wykona ciężkie prace.

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

Ten czek

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

odfiltrowuje nazw z nieprawidłowych znaków ( <>:"/\|?*i ASCII 0-31), a także zastrzeżonych urządzeń DOS ( CON, NUL, COMx). Pozwala na wiodące spacje i wszystkie kropki, zgodnie z Path.GetFullPath. (Utworzenie pliku ze spacjami wiodącymi kończy się pomyślnie w moim systemie).

Używany .NET Framework 4.7.1, testowany w systemie Windows 7.

Jedna linijka do weryfikacji nielegalnych znaków w ciągu:

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

Moim zdaniem jedyną właściwą odpowiedzią na to pytanie jest próba użycia ścieżki i pozwolenie systemowi operacyjnemu i systemowi plików na jej walidację. W przeciwnym razie po prostu ponownie zaimplementujesz (i prawdopodobnie źle) wszystkie reguły walidacji, których system operacyjny i system plików już używają, a jeśli te reguły zostaną zmienione w przyszłości, będziesz musiał zmienić kod, aby je dopasować.

Nazwy plików Windows są dość unrestrictive, tak naprawdę to nie może być nawet , że wiele kwestii. Znaki niedozwolone przez system Windows to:

\ / : * ? " < > |

Możesz łatwo napisać wyrażenie, aby sprawdzić, czy te znaki są obecne. Lepszym rozwiązaniem byłaby jednak próba nazwania plików zgodnie z życzeniem użytkownika i ostrzeganie ich, gdy nazwa pliku się nie przykleja.