Wie entferne ich unzulässige Zeichen aus Pfad und Dateinamen?

Ich brauche eine robuste und einfache Methode, um unzulässige Pfad- und Dateizeichen aus einer einfachen Zeichenfolge zu entfernen. Ich habe den folgenden Code verwendet, aber er scheint nichts zu bewirken. Was fehlt mir?

using System;
using System.IO;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string illegal = "\"M<>\"\\a/ry/ h**ad:>> a\\/:*?\"<>| li*tt|le|| la\"mb.?";

            illegal = illegal.Trim(Path.GetInvalidFileNameChars());
            illegal = illegal.Trim(Path.GetInvalidPathChars());

            Console.WriteLine(illegal);
            Console.ReadLine();
        }
    }
}

Versuchen Sie stattdessen so etwas;

string illegal = "\"M\"\\a/ry/ h**ad:>> a\\/:*?\"| li*tt|le|| la\"mb.?";
string invalid = new string(Path.GetInvalidFileNameChars()) + new string(Path.GetInvalidPathChars());

foreach (char c in invalid)
{
    illegal = illegal.Replace(c.ToString(), ""); 
}

Aber ich muss den Kommentaren zustimmen, ich würde wahrscheinlich versuchen, mit der Quelle der illegalen Pfade umzugehen, anstatt zu versuchen, einen illegalen Pfad in einen legitimen, aber wahrscheinlich unbeabsichtigten Pfad zu verwandeln.

Bearbeiten: Oder eine potenziell "bessere" Lösung mit Regex.

string illegal = "\"M\"\\a/ry/ h**ad:>> a\\/:*?\"| li*tt|le|| la\"mb.?";
string regexSearch = new string(Path.GetInvalidFileNameChars()) + new string(Path.GetInvalidPathChars());
Regex r = new Regex(string.Format("[{0}]", Regex.Escape(regexSearch)));
illegal = r.Replace(illegal, "");

Dennoch muss die Frage gestellt werden, warum Sie dies überhaupt tun.

Die ursprüngliche Frage lautete "Unzulässige Zeichen entfernen":

public string RemoveInvalidChars(string filename)
{
    return string.Concat(filename.Split(Path.GetInvalidFileNameChars()));
}

Möglicherweise möchten Sie sie stattdessen ersetzen:

public string ReplaceInvalidChars(string filename)
{
    return string.Join("_", filename.Split(Path.GetInvalidFileNameChars()));    
}

Diese Antwort war in einem anderen Thread von Ceres , ich mag es wirklich ordentlich und einfach.

Ich benutze Linq, um Dateinamen zu bereinigen. Sie können dies problemlos erweitern, um auch nach gültigen Pfaden zu suchen.

private static string CleanFileName(string fileName)
{
    return Path.GetInvalidFileNameChars().Aggregate(fileName, (current, c) => current.Replace(c.ToString(), string.Empty));
}

Aktualisieren

Einige Kommentare weisen darauf hin, dass diese Methode für sie nicht funktioniert. Daher habe ich einen Link zu einem DotNetFiddle-Snippet eingefügt, damit Sie die Methode validieren können.

https://dotnetfiddle.net/nw1SWY

Sie können illegale Zeichen mit Linq folgendermaßen entfernen:

var invalidChars = Path.GetInvalidFileNameChars();

var invalidCharsRemoved = stringWithInvalidChars
.Where(x => !invalidChars.Contains(x))
.ToArray();

BEARBEITEN
So sieht es mit der erforderlichen Bearbeitung aus, die in den Kommentaren erwähnt wird:

var invalidChars = Path.GetInvalidFileNameChars();

string invalidCharsRemoved = new string(stringWithInvalidChars
  .Where(x => !invalidChars.Contains(x))
  .ToArray());

Dies sind alles großartige Lösungen, auf die sich jedoch alle verlassen Path.GetInvalidFileNameChars, die möglicherweise nicht so zuverlässig sind, wie Sie denken. Beachten Sie die folgende Bemerkung in der MSDN-Dokumentation zu Path.GetInvalidFileNameChars:

Es wird nicht garantiert, dass das von dieser Methode zurückgegebene Array den vollständigen Satz von Zeichen enthält, die in Datei- und Verzeichnisnamen ungültig sind. Der vollständige Satz ungültiger Zeichen kann je nach Dateisystem variieren. Auf Windows-basierten Desktop-Plattformen können ungültige Pfadzeichen beispielsweise ASCII / Unicode-Zeichen 1 bis 31 sowie Anführungszeichen ("), kleiner als (<), größer als (>), Pipe (|), Rücktaste () enthalten. \ b), null (\ 0) und tab (\ t).

Es ist nicht besser mit Path.GetInvalidPathChars Methode . Es enthält genau die gleiche Bemerkung.

Für Dateinamen:

var cleanFileName = string.Join("", fileName.Split(Path.GetInvalidFileNameChars()));

Für vollständige Pfade:

var cleanPath = string.Join("", path.Split(Path.GetInvalidPathChars()));

Beachten Sie, dass, wenn Sie dies als Sicherheitsfunktion verwenden möchten, ein robusterer Ansatz darin besteht, alle Pfade zu erweitern und dann zu überprüfen, ob der vom Benutzer angegebene Pfad tatsächlich ein untergeordnetes Element eines Verzeichnisses ist, auf das der Benutzer Zugriff haben sollte.

Für den Anfang entfernt Trim nur Zeichen vom Anfang oder Ende der Zeichenfolge . Zweitens sollten Sie prüfen, ob Sie die anstößigen Zeichen wirklich entfernen möchten oder schnell fehlschlagen möchten, und dem Benutzer mitteilen, dass sein Dateiname ungültig ist. Meine Wahl ist die letztere, aber meine Antwort sollte Ihnen zumindest zeigen, wie man die Dinge richtig und falsch macht:

StackOverflow-Frage, die zeigt, wie überprüft wird, ob eine bestimmte Zeichenfolge ein gültiger Dateiname ist . Beachten Sie, dass Sie den regulären Ausdruck aus dieser Frage verwenden können, um Zeichen mit einem Ersatz für reguläre Ausdrücke zu entfernen (falls Sie dies wirklich tun müssen).

Der beste Weg, um unzulässige Zeichen aus Benutzereingaben zu entfernen, besteht darin, unzulässige Zeichen mithilfe der Regex-Klasse zu ersetzen, eine Methode im Code dahinter zu erstellen oder sie auf der Clientseite mithilfe des RegularExpression-Steuerelements zu validieren.

public string RemoveSpecialCharacters(string str)
{
    return Regex.Replace(str, "[^a-zA-Z0-9_]+", "_", RegexOptions.Compiled);
}

ODER

<asp:RegularExpressionValidator ID="regxFolderName" 
                                runat="server" 
                                ErrorMessage="Enter folder name with  a-z A-Z0-9_" 
                                ControlToValidate="txtFolderName" 
                                Display="Dynamic" 
                                ValidationExpression="^[a-zA-Z0-9_]*$" 
                                ForeColor="Red">

Ich benutze reguläre Ausdrücke, um dies zu erreichen. Zuerst baue ich den regulären Ausdruck dynamisch.

string regex = string.Format(
                   "[{0}]",
                   Regex.Escape(new string(Path.GetInvalidFileNameChars())));
Regex removeInvalidChars = new Regex(regex, RegexOptions.Singleline | RegexOptions.Compiled | RegexOptions.CultureInvariant);

Dann rufe ich einfach removeInvalidChars.Replace auf, um das Suchen und Ersetzen durchzuführen. Dies kann natürlich auch auf Pfadzeichen ausgedehnt werden.

Ich bevorzuge die Idee von Jeff Yates. Es wird perfekt funktionieren, wenn Sie es leicht modifizieren:

string regex = String.Format("[{0}]", Regex.Escape(new string(Path.GetInvalidFileNameChars())));
Regex removeInvalidChars = new Regex(regex, RegexOptions.Singleline | RegexOptions.Compiled | RegexOptions.CultureInvariant);

Die Verbesserung besteht nur darin, dem automatisch erzeugten regulären Ausdruck zu entkommen.

Hier ist ein Code-Snippet, das für .NET 3 und höher hilfreich sein sollte.

using System.IO;
using System.Text.RegularExpressions;

public static class PathValidation
{
    private static string pathValidatorExpression = "^[^" + string.Join("", Array.ConvertAll(Path.GetInvalidPathChars(), x => Regex.Escape(x.ToString()))) + "]+$";
    private static Regex pathValidator = new Regex(pathValidatorExpression, RegexOptions.Compiled);

    private static string fileNameValidatorExpression = "^[^" + string.Join("", Array.ConvertAll(Path.GetInvalidFileNameChars(), x => Regex.Escape(x.ToString()))) + "]+$";
    private static Regex fileNameValidator = new Regex(fileNameValidatorExpression, RegexOptions.Compiled);

    private static string pathCleanerExpression = "[" + string.Join("", Array.ConvertAll(Path.GetInvalidPathChars(), x => Regex.Escape(x.ToString()))) + "]";
    private static Regex pathCleaner = new Regex(pathCleanerExpression, RegexOptions.Compiled);

    private static string fileNameCleanerExpression = "[" + string.Join("", Array.ConvertAll(Path.GetInvalidFileNameChars(), x => Regex.Escape(x.ToString()))) + "]";
    private static Regex fileNameCleaner = new Regex(fileNameCleanerExpression, RegexOptions.Compiled);

    public static bool ValidatePath(string path)
    {
        return pathValidator.IsMatch(path);
    }

    public static bool ValidateFileName(string fileName)
    {
        return fileNameValidator.IsMatch(fileName);
    }

    public static string CleanPath(string path)
    {
        return pathCleaner.Replace(path, "");
    }

    public static string CleanFileName(string fileName)
    {
        return fileNameCleaner.Replace(fileName, "");
    }
}

Die meisten der oben genannten Lösungen kombinieren unzulässige Zeichen für Pfad und Dateinamen, was falsch ist (selbst wenn beide Aufrufe derzeit denselben Zeichensatz zurückgeben). Ich würde zuerst den Pfad + Dateinamen in Pfad und Dateiname aufteilen, dann den entsprechenden Satz auf einen der beiden anwenden und dann die beiden erneut kombinieren.

wvd_vegt

Wenn Sie die ungültigen Zeichen entfernen oder durch ein einzelnes Zeichen ersetzen, können Kollisionen auftreten:

<abc -> abc
>abc -> abc

Hier ist eine einfache Methode, um dies zu vermeiden:

public static string ReplaceInvalidFileNameChars(string s)
{
    char[] invalidFileNameChars = System.IO.Path.GetInvalidFileNameChars();
    foreach (char c in invalidFileNameChars)
        s = s.Replace(c.ToString(), "[" + Array.IndexOf(invalidFileNameChars, c) + "]");
    return s;
}

Das Ergebnis:

 <abc -> [1]abc
 >abc -> [2]abc

Eine Ausnahme auslösen.

if ( fileName.IndexOfAny(Path.GetInvalidFileNameChars()) > -1 )
            {
                throw new ArgumentException();
            }

Ich habe dieses Monster zum Spaß geschrieben, damit kannst du eine Rundreise machen:

public static class FileUtility
{
    private const char PrefixChar = '%';
    private static readonly int MaxLength;
    private static readonly Dictionary<char,char[]> Illegals;
    static FileUtility()
    {
        List<char> illegal = new List<char> { PrefixChar };
        illegal.AddRange(Path.GetInvalidFileNameChars());
        MaxLength = illegal.Select(x => ((int)x).ToString().Length).Max();
        Illegals = illegal.ToDictionary(x => x, x => ((int)x).ToString("D" + MaxLength).ToCharArray());
    }

    public static string FilenameEncode(string s)
    {
        var builder = new StringBuilder();
        char[] replacement;
        using (var reader = new StringReader(s))
        {
            while (true)
            {
                int read = reader.Read();
                if (read == -1)
                    break;
                char c = (char)read;
                if(Illegals.TryGetValue(c,out replacement))
                {
                    builder.Append(PrefixChar);
                    builder.Append(replacement);
                }
                else
                {
                    builder.Append(c);
                }
            }
        }
        return builder.ToString();
    }

    public static string FilenameDecode(string s)
    {
        var builder = new StringBuilder();
        char[] buffer = new char[MaxLength];
        using (var reader = new StringReader(s))
        {
            while (true)
            {
                int read = reader.Read();
                if (read == -1)
                    break;
                char c = (char)read;
                if (c == PrefixChar)
                {
                    reader.Read(buffer, 0, MaxLength);
                    var encoded =(char) ParseCharArray(buffer);
                    builder.Append(encoded);
                }
                else
                {
                    builder.Append(c);
                }
            }
        }
        return builder.ToString();
    }

    public static int ParseCharArray(char[] buffer)
    {
        int result = 0;
        foreach (char t in buffer)
        {
            int digit = t - '0';
            if ((digit < 0) || (digit > 9))
            {
                throw new ArgumentException("Input string was not in the correct format");
            }
            result *= 10;
            result += digit;
        }
        return result;
    }
}

Ich denke, es ist viel einfacher, mit einem regulären Ausdruck zu validieren und anzugeben, welche Zeichen zulässig sind, anstatt zu versuchen, nach allen schlechten Zeichen zu suchen. Siehe diese Links: http://www.c-sharpcorner.com/UploadFile/prasad_1/RegExpPSD12062005021717AM/RegExpPSD.aspx http://www.windowsdevcenter.com/pub/a/oreilly/windows/news/csharp_0101.html

Suchen Sie auch nach "Editor für reguläre Ausdrücke", sie helfen sehr. Es gibt einige, die sogar den Code in c # für Sie ausgeben.

Dies scheint O (n) zu sein und verbraucht nicht zu viel Speicher für Zeichenfolgen:

    private static readonly HashSet<char> invalidFileNameChars = new HashSet<char>(Path.GetInvalidFileNameChars());

    public static string RemoveInvalidFileNameChars(string name)
    {
        if (!name.Any(c => invalidFileNameChars.Contains(c))) {
            return name;
        }

        return new string(name.Where(c => !invalidFileNameChars.Contains(c)).ToArray());
    }

Beim Durchsuchen der Antworten hier scheinen alle ** die Verwendung eines char-Arrays ungültiger Dateinamenzeichen zu beinhalten.

Zugegeben, dies mag eine Mikrooptimierung sein - aber für alle, die eine große Anzahl von Werten auf gültige Dateinamen überprüfen möchten, ist es erwähnenswert, dass das Erstellen eines Hash-Sets ungültiger Zeichen zu einer deutlich besseren Leistung führt.

Ich war in der Vergangenheit sehr überrascht (schockiert), wie schnell ein Hashset (oder Wörterbuch) die Iteration über eine Liste übertrifft. Mit Strings ist es eine lächerlich niedrige Zahl (ungefähr 5-7 Elemente aus dem Speicher). Bei den meisten anderen einfachen Daten (Objektreferenzen, Zahlen usw.) scheint die magische Überkreuzung etwa 20 Elemente zu betragen.

Die "Liste" von Path.InvalidFileNameChars enthält 40 ungültige Zeichen. Habe heute eine Suche durchgeführt und es gibt hier auf StackOverflow einen ziemlich guten Benchmark, der zeigt, dass das Hashset etwas mehr als die Hälfte der Zeit eines Arrays / einer Liste für 40 Elemente benötigt: https://stackoverflow.com/a/10762995/949129

Hier ist die Hilfsklasse, mit der ich Pfade bereinige. Ich vergesse jetzt, warum ich die ausgefallene Ersatzoption darin hatte, aber es ist als süßer Bonus da.

Zusätzliche Bonusmethode "IsValidLocalPath" auch :)

(** diejenigen, die keine regulären Ausdrücke verwenden)

public static class PathExtensions
{
    private static HashSet<char> _invalidFilenameChars;
    private static HashSet<char> InvalidFilenameChars
    {
        get { return _invalidFilenameChars ?? (_invalidFilenameChars = new HashSet<char>(Path.GetInvalidFileNameChars())); }
    }


    /// <summary>Replaces characters in <c>text</c> that are not allowed in file names with the 
    /// specified replacement character.</summary>
    /// <param name="text">Text to make into a valid filename. The same string is returned if 
    /// it is valid already.</param>
    /// <param name="replacement">Replacement character, or NULL to remove bad characters.</param>
    /// <param name="fancyReplacements">TRUE to replace quotes and slashes with the non-ASCII characters ” and ⁄.</param>
    /// <returns>A string that can be used as a filename. If the output string would otherwise be empty, "_" is returned.</returns>
    public static string ToValidFilename(this string text, char? replacement = '_', bool fancyReplacements = false)
    {
        StringBuilder sb = new StringBuilder(text.Length);
        HashSet<char> invalids = InvalidFilenameChars;
        bool changed = false;

        for (int i = 0; i < text.Length; i++)
        {
            char c = text[i];
            if (invalids.Contains(c))
            {
                changed = true;
                char repl = replacement ?? '\0';
                if (fancyReplacements)
                {
                    if (c == '"') repl = '”'; // U+201D right double quotation mark
                    else if (c == '\'') repl = '’'; // U+2019 right single quotation mark
                    else if (c == '/') repl = '⁄'; // U+2044 fraction slash
                }
                if (repl != '\0')
                    sb.Append(repl);
            }
            else
                sb.Append(c);
        }

        if (sb.Length == 0)
            return "_";

        return changed ? sb.ToString() : text;
    }


    /// <summary>
    /// Returns TRUE if the specified path is a valid, local filesystem path.
    /// </summary>
    /// <param name="pathString"></param>
    /// <returns></returns>
    public static bool IsValidLocalPath(this string pathString)
    {
        // From solution at https://stackoverflow.com/a/11636052/949129
        Uri pathUri;
        Boolean isValidUri = Uri.TryCreate(pathString, UriKind.Absolute, out pathUri);
        return isValidUri && pathUri != null && pathUri.IsLoopback;
    }
}

public static class StringExtensions
      {
        public static string RemoveUnnecessary(this string source)
        {
            string result = string.Empty;
            string regex = new string(Path.GetInvalidFileNameChars()) + new string(Path.GetInvalidPathChars());
            Regex reg = new Regex(string.Format("[{0}]", Regex.Escape(regex)));
            result = reg.Replace(source, "");
            return result;
        }
    }

Sie können die Methode klar anwenden.

Dateiname kann nicht enthalten Zeichen aus Path.GetInvalidPathChars(), +und #Symbole und andere spezifische Namen. Wir haben alle Schecks in einer Klasse zusammengefasst:

public static class FileNameExtensions
{
    private static readonly Lazy<string[]> InvalidFileNameChars =
        new Lazy<string[]>(() => Path.GetInvalidPathChars()
            .Union(Path.GetInvalidFileNameChars()
            .Union(new[] { '+', '#' })).Select(c => c.ToString(CultureInfo.InvariantCulture)).ToArray());


    private static readonly HashSet<string> ProhibitedNames = new HashSet<string>
    {
        @"aux",
        @"con",
        @"clock$",
        @"nul",
        @"prn",

        @"com1",
        @"com2",
        @"com3",
        @"com4",
        @"com5",
        @"com6",
        @"com7",
        @"com8",
        @"com9",

        @"lpt1",
        @"lpt2",
        @"lpt3",
        @"lpt4",
        @"lpt5",
        @"lpt6",
        @"lpt7",
        @"lpt8",
        @"lpt9"
    };

    public static bool IsValidFileName(string fileName)
    {
        return !string.IsNullOrWhiteSpace(fileName)
            && fileName.All(o => !IsInvalidFileNameChar(o))
            && !IsProhibitedName(fileName);
    }

    public static bool IsProhibitedName(string fileName)
    {
        return ProhibitedNames.Contains(fileName.ToLower(CultureInfo.InvariantCulture));
    }

    private static string ReplaceInvalidFileNameSymbols([CanBeNull] this string value, string replacementValue)
    {
        if (value == null)
        {
            return null;
        }

        return InvalidFileNameChars.Value.Aggregate(new StringBuilder(value),
            (sb, currentChar) => sb.Replace(currentChar, replacementValue)).ToString();
    }

    public static bool IsInvalidFileNameChar(char value)
    {
        return InvalidFileNameChars.Value.Contains(value.ToString(CultureInfo.InvariantCulture));
    }

    public static string GetValidFileName([NotNull] this string value)
    {
        return GetValidFileName(value, @"_");
    }

    public static string GetValidFileName([NotNull] this string value, string replacementValue)
    {
        if (string.IsNullOrWhiteSpace(value))
        {
            throw new ArgumentException(@"value should be non empty", nameof(value));
        }

        if (IsProhibitedName(value))
        {
            return (string.IsNullOrWhiteSpace(replacementValue) ? @"_" : replacementValue) + value; 
        }

        return ReplaceInvalidFileNameSymbols(value, replacementValue);
    }

    public static string GetFileNameError(string fileName)
    {
        if (string.IsNullOrWhiteSpace(fileName))
        {
            return CommonResources.SelectReportNameError;
        }

        if (IsProhibitedName(fileName))
        {
            return CommonResources.FileNameIsProhibited;
        }

        var invalidChars = fileName.Where(IsInvalidFileNameChar).Distinct().ToArray();

        if(invalidChars.Length > 0)
        {
            return string.Format(CultureInfo.CurrentCulture,
                invalidChars.Length == 1 ? CommonResources.InvalidCharacter : CommonResources.InvalidCharacters,
                StringExtensions.JoinQuoted(@",", @"'", invalidChars.Select(c => c.ToString(CultureInfo.CurrentCulture))));
        }

        return string.Empty;
    }
}

Methode GetValidFileNameersetzt alle falschen Daten zu _.

Ein Liner zum Bereinigen der Zeichenfolge von unzulässigen Zeichen für die Benennung von Windows-Dateien:

public static string CleanIllegalName(string p_testName) => new Regex(string.Format("[{0}]", Regex.Escape(new string(Path.GetInvalidFileNameChars()) + new string(Path.GetInvalidPathChars())))).Replace(p_testName, "");

public static bool IsValidFilename(string testName)
{
    return !new Regex("[" + Regex.Escape(new String(System.IO.Path.GetInvalidFileNameChars())) + "]").IsMatch(testName);
}

Dies wird Sie wollen und Kollisionen vermeiden

 static string SanitiseFilename(string key)
    {
        var invalidChars = Path.GetInvalidFileNameChars();
        var sb = new StringBuilder();
        foreach (var c in key)
        {
            var invalidCharIndex = -1;
            for (var i = 0; i < invalidChars.Length; i++)
            {
                if (c == invalidChars[i])
                {
                    invalidCharIndex = i;
                }
            }
            if (invalidCharIndex > -1)
            {
                sb.Append("_").Append(invalidCharIndex);
                continue;
            }

            if (c == '_')
            {
                sb.Append("__");
                continue;
            }

            sb.Append(c);
        }
        return sb.ToString();

    }

Ich denke, die Frage ist bereits nicht vollständig beantwortet ... Die Antworten beschreiben nur den sauberen Dateinamen ODER den Pfad ... nicht beide. Hier ist meine Lösung:

private static string CleanPath(string path)
{
    string regexSearch = new string(Path.GetInvalidFileNameChars()) + new string(Path.GetInvalidPathChars());
    Regex r = new Regex(string.Format("[{0}]", Regex.Escape(regexSearch)));
    List<string> split = path.Split('\\').ToList();
    string returnValue = split.Aggregate(string.Empty, (current, s) => current + (r.Replace(s, "") + @"\"));
    returnValue = returnValue.TrimEnd('\\');
    return returnValue;
}

Ich habe eine Erweiterungsmethode erstellt, die mehrere Vorschläge kombiniert:

1. Unzulässige Zeichen in einem Hash-Set halten
2. Herausfiltern von Zeichen unter ASCII 127. Da Path.GetInvalidFileNameChars nicht alle ungültigen Zeichen enthält, die mit ASCII-Codes von 0 bis 255 möglich sind. Siehe hier und MSDN
3. Möglichkeit, das Ersatzzeichen zu definieren

Quelle:

public static class FileNameCorrector
{
    private static HashSet<char> invalid = new HashSet<char>(Path.GetInvalidFileNameChars());

    public static string ToValidFileName(this string name, char replacement = '\0')
    {
        var builder = new StringBuilder();
        foreach (var cur in name)
        {
            if (cur > 31 && cur < 128 && !invalid.Contains(cur))
            {
                builder.Append(cur);
            }
            else if (replacement != '\0')
            {
                builder.Append(replacement);
            }
        }

        return builder.ToString();
    }
}

Hier ist eine Funktion, die alle unzulässigen Zeichen in einem Dateinamen durch ein Ersatzzeichen ersetzt:

public static string ReplaceIllegalFileChars(string FileNameWithoutPath, char ReplacementChar)
{
  const string IllegalFileChars = "*?/\\:<>|\"";
  StringBuilder sb = new StringBuilder(FileNameWithoutPath.Length);
  char c;

  for (int i = 0; i < FileNameWithoutPath.Length; i++)
  {
    c = FileNameWithoutPath[i];
    if (IllegalFileChars.IndexOf(c) >= 0)
    {
      c = ReplacementChar;
    }
    sb.Append(c);
  }
  return (sb.ToString());
}

Zum Beispiel kann der Unterstrich als Ersatzzeichen verwendet werden:

NewFileName = ReplaceIllegalFileChars(FileName, '_');

Oder du kannst es einfach tun

[YOUR STRING].Replace('\\', ' ').Replace('/', ' ').Replace('"', ' ').Replace('*', ' ').Replace(':', ' ').Replace('?', ' ').Replace('<', ' ').Replace('>', ' ').Replace('|', ' ').Trim();