Comment vérifier si une chaîne donnée est un nom de fichier légal / valide sous Windows?

Je souhaite inclure une fonctionnalité de changement de nom de fichier de commandes dans mon application. Un utilisateur peut taper un modèle de nom de fichier de destination et (après avoir remplacé certains caractères génériques dans le modèle), je dois vérifier si ce sera un nom de fichier légal sous Windows. J'ai essayé d'utiliser des expressions régulières comme [a-zA-Z0-9_]+mais cela n'inclut pas beaucoup de caractères nationaux spécifiques de différentes langues (par exemple, des trémas, etc.). Quelle est la meilleure façon de procéder à une telle vérification?

Vous pouvez obtenir une liste de caractères non valides à partir de Path.GetInvalidPathCharset GetInvalidFileNameChars.

UPD: Voir la suggestion de Steve Cooper sur la façon de les utiliser dans une expression régulière.

UPD2: Notez que selon la section Remarques dans MSDN "Le tableau renvoyé par cette méthode n'est pas garanti pour contenir le jeu complet de caractères qui ne sont pas valides dans les noms de fichiers et de répertoires." La réponse fournie par sixlettervaliables entre dans plus de détails.

À partir de «Nommer un fichier ou un répertoire» de MSDN, voici les conventions générales pour définir ce qu'est un nom de fichier légal sous Windows:

Vous pouvez utiliser n'importe quel caractère de la page de codes actuelle (Unicode / ANSI supérieur à 127), sauf:

• < > : " / \ | ? *
• Caractères dont les représentations entières sont comprises entre 0 et 31 (inférieurs à l'espace ASCII)
• Tout autre caractère que le système de fichiers cible n'autorise pas (par exemple, des points ou des espaces de fin)
• Tous les noms 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 (et évitez AUX.txt, etc.)
• Le nom du fichier est toutes les périodes

Quelques éléments facultatifs à vérifier:

• Les chemins de fichier (y compris le nom de fichier) ne doivent pas comporter plus de 260 caractères (qui n'utilisent pas le \?\préfixe)
• Chemins de fichier Unicode (y compris le nom de fichier) avec plus de 32 000 caractères lors de l'utilisation \?\(notez que le préfixe peut développer les composants du répertoire et provoquer le dépassement de la limite de 32 000)

Pour les frameworks .Net antérieurs à la version 3.5, cela devrait fonctionner:

La correspondance d'expressions régulières devrait vous aider. Voici un extrait de code utilisant la System.IO.Path.InvalidPathCharsconstante;

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

Pour .Net Frameworks après 3.0, cela devrait fonctionner:

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

La correspondance d'expressions régulières devrait vous aider. Voici un extrait de code utilisant la System.IO.Path.GetInvalidPathChars()constante;

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

Une fois que vous savez cela, vous devriez également vérifier les différents formats, par exemple c:\my\driveet\\server\share\dir\file.ext

Essayez de l'utiliser et piègez l'erreur. L'ensemble autorisé peut changer entre les systèmes de fichiers ou entre les différentes versions de Windows. En d'autres termes, si vous voulez savoir si Windows aime le nom, donnez-lui le nom et laissez-le vous dire.

Cette classe nettoie les noms de fichiers et les chemins; utilisez-le comme

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

Voici le code;

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

}

Voici ce que j'utilise:

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

Le premier modèle crée une expression régulière contenant les noms de fichiers et les caractères non valides / illégaux pour les plates-formes Windows uniquement. Le second fait de même mais garantit que le nom est légal pour n'importe quelle plateforme.

Un cas d'angle à garder à l'esprit, ce qui m'a surpris lorsque j'ai découvert cela pour la première fois: Windows autorise les caractères d'espace de début dans les noms de fichiers! Par exemple, les noms de fichiers suivants sont tous légaux et distincts sous Windows (moins les guillemets):

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

Une chose à retenir: soyez prudent lorsque vous écrivez du code qui supprime les espaces de début / de fin d'une chaîne de nom de fichier.

Simplifier la réponse d'Eugene Katz:

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

Ou

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

Microsoft Windows: le noyau Windows interdit l'utilisation de caractères compris entre 1 et 31 (c'est-à-dire 0x01-0x1F) et les caractères "*: <>? \ |. Bien que NTFS autorise chaque composant de chemin (répertoire ou nom de fichier) à 255 caractères et jusqu'à environ 32 767 caractères, le noyau Windows ne prend en charge que les chemins jusqu'à 259 caractères. De plus, Windows interdit l'utilisation des noms de périphérique MS-DOS AUX, CLOCK $, COM1, COM2, COM3, COM4, ​​COM5, COM6, COM7, COM8, COM9, CON, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, LPT9, NUL et PRN, ainsi que ces noms avec n'importe quelle extension (par exemple, AUX.txt), sauf lors de l'utilisation Chemins UNC longs (ex. \. \ C: \ nul.txt ou \? \ D: \ aux \ con). (En fait, CLOCK $ peut être utilisé si une extension est fournie.) Ces restrictions s'appliquent uniquement à Windows - Linux, par exemple, autorise l'utilisation de "*: <>? \ | même en NTFS.

Source: http://en.wikipedia.org/wiki/Filename

Plutôt que d'inclure explicitement tous les caractères possibles, vous pouvez faire une regex pour vérifier la présence de caractères illégaux et signaler une erreur ensuite. Idéalement, votre application doit nommer les fichiers exactement comme l'utilisateur le souhaite, et ne crier au scandale que si elle tombe sur une erreur.

La question est de savoir si vous essayez de déterminer si un nom de chemin est un chemin Windows légal ou s'il est légal sur le système sur lequel le code est exécuté. ? Je pense que ce dernier est plus important, donc personnellement, je décomposerais probablement le chemin complet et essayerais d'utiliser _mkdir pour créer le répertoire auquel appartient le fichier, puis essayer de créer le fichier.

De cette façon, vous savez non seulement si le chemin contient uniquement des caractères Windows valides, mais s'il représente en fait un chemin qui peut être écrit par ce processus.

J'utilise ceci pour me débarrasser des caractères invalides dans les noms de fichiers sans lever d'exceptions:

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

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

De plus, CON, PRN, AUX, NUL, COM # et quelques autres ne sont jamais des noms de fichiers légaux dans aucun répertoire avec une extension.

Pour compléter les autres réponses, voici quelques cas supplémentaires que vous voudrez peut-être envisager.

• Excel peut rencontrer des problèmes si vous enregistrez un classeur dans un fichier dont le nom contient les caractères «[» ou «]». Voir http://support.microsoft.com/kb/215205 pour plus de détails.

• Sharepoint a tout un ensemble de restrictions supplémentaires. Voir http://support.microsoft.com/kb/905231 pour plus de détails.

Depuis MSDN , voici une liste de caractères non autorisés:

Utilisez presque tous les caractères de la page de codes actuelle pour un nom, y compris les caractères Unicode et les caractères du jeu de caractères étendu (128–255), à l'exception des éléments suivants:

• Les caractères réservés suivants ne sont pas autorisés: <>: "/ \ |? *
• Les caractères dont les représentations entières sont comprises entre zéro et 31 ne sont pas autorisés.
• Tout autre caractère non autorisé par le système de fichiers cible.

Le système de fichiers de destination est également important.

Sous NTFS, certains fichiers ne peuvent pas être créés dans des répertoires spécifiques. EG $ Boot en root

C'est une question déjà répondue, mais juste pour le plaisir des "Autres options", en voici une non idéale:

(non idéal car l'utilisation d'exceptions comme contrôle de flux est généralement une mauvaise chose)

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

Les expressions régulières sont excessives pour cette situation. Vous pouvez utiliser la String.IndexOfAny()méthode en combinaison avec Path.GetInvalidPathChars()et Path.GetInvalidFileNameChars().

Notez également que les deux Path.GetInvalidXXX()méthodes clonent un tableau interne et renvoient le clone. Donc, si vous comptez faire cela beaucoup (des milliers et des milliers de fois), vous pouvez mettre en cache une copie du tableau de caractères invalides pour une réutilisation.

Si vous essayez seulement de vérifier si une chaîne contenant votre nom / chemin de fichier contient des caractères non valides, la méthode la plus rapide que j'ai trouvée consiste Split()à diviser le nom de fichier en un tableau de parties partout où il y a un caractère non valide. Si le résultat n'est qu'un tableau de 1, il n'y a pas de caractères non valides. :-)

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;

J'ai essayé d'exécuter cette méthode et d'autres méthodes mentionnées ci-dessus sur un nom de fichier / chemin 1 000 000 fois dans LinqPad.

L'utilisation Split()ne dure que ~ 850 ms.

L'utilisation Regex("[" + Regex.Escape(new string(System.IO.Path.GetInvalidPathChars())) + "]")est d'environ 6 secondes.

Les expressions régulières les plus compliquées sont bien pires, tout comme certaines des autres options, comme l'utilisation des différentes méthodes de la Pathclasse pour obtenir le nom de fichier et laisser leur validation interne faire le travail (probablement en raison de la surcharge de la gestion des exceptions).

Certes, il n'est pas très souvent nécessaire de valider 1 million de noms de fichiers, donc une seule itération convient de toute façon pour la plupart de ces méthodes. Mais c'est toujours assez efficace et efficace si vous ne recherchez que des caractères invalides.

beaucoup de ces réponses ne fonctionneront pas si le nom de fichier est trop long et s'exécute dans un environnement antérieur à Windows 10. De même, pensez à ce que vous voulez faire avec les points - autoriser le début ou la fin est techniquement valide, mais peut créer des problèmes si vous ne voulez pas que le fichier soit difficile à voir ou à supprimer respectivement.

C'est un attribut de validation que j'ai créé pour vérifier un nom de fichier valide.

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

et les tests

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

Ma tentative:

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

Ce n'est pas parfait car Path.GetInvalidPathChars ne renvoie pas le jeu complet de caractères invalides dans les noms de fichiers et de répertoires et bien sûr, il y a beaucoup plus de subtilités.

J'utilise donc cette méthode en complément:

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

Il essaie de créer le fichier et renvoie false s'il y a une exception. Bien sûr, je dois créer le fichier, mais je pense que c'est le moyen le plus sûr de le faire. Veuillez également noter que je ne supprime pas les répertoires qui ont été créés.

Vous pouvez également utiliser la première méthode pour effectuer une validation de base, puis gérer soigneusement les exceptions lorsque le chemin est utilisé.

Je suggère simplement d'utiliser le Path.GetFullPath ()

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

J'ai eu cette idée de quelqu'un. - ne sais pas qui. Laissez le système d'exploitation faire le gros du travail.

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

Cette vérification

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

filtre les noms avec les caractères non valides ( <>:"/\|?*et ASCII 0-31), ainsi que des dispositifs DOS réservés ( CON, NUL, COMx). Il permet des espaces de début et des noms de points, cohérents avec Path.GetFullPath. (La création d'un fichier avec des espaces de début réussit sur mon système).

Utilisé .NET Framework 4.7.1, testé sur Windows 7.

Une doublure pour vérifier les caractères illigaux dans la chaîne:

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

À mon avis, la seule réponse appropriée à cette question est d'essayer d'utiliser le chemin et de laisser le système d'exploitation et le système de fichiers le valider. Sinon, vous ne faites que réimplémenter (et probablement mal) toutes les règles de validation que le système d'exploitation et le système de fichiers utilisent déjà et si ces règles sont modifiées à l'avenir, vous devrez modifier votre code pour les faire correspondre.

Windows sont assez les noms de fichiers non restrictive, si vraiment il pourrait même ne pas être que beaucoup d'une question. Les caractères non autorisés par Windows sont:

\ / : * ? " < > |

Vous pouvez facilement écrire une expression pour vérifier si ces caractères sont présents. Une meilleure solution serait cependant d'essayer de nommer les fichiers comme l'utilisateur le souhaite et de les alerter lorsqu'un nom de fichier ne colle pas.