كيفية إزالة الأحرف غير القانونية من المسار وأسماء الملفات؟

Question

أحتاج إلى طريقة قوية وبسيطة لإزالة المسار غير القانوني وأحرف الملف من سلسلة بسيطة.لقد استخدمت الكود أدناه ولكن يبدو أنه لا يفعل أي شيء، ما الذي أفتقده؟

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

Answer 1

جرب شيئا من هذا القبيل بدلا من ذلك؛

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

لكن يجب أن أتفق مع التعليقات، ربما سأحاول التعامل مع مصدر المسارات غير القانونية، بدلاً من محاولة تحويل مسار غير قانوني إلى مسار شرعي ولكن ربما غير مقصود.

يحرر:أو حل محتمل "أفضل" باستخدام 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, "");

ومع ذلك، فإن السؤال الذي يطرح نفسه، لماذا تفعل هذا في المقام الأول.

Answer 2

public string GetSafeFilename(string filename)
{

    return string.Join("_", filename.Split(Path.GetInvalidFileNameChars()));

}

كانت هذه الإجابة في موضوع آخر بواسطة سيريس, ، أنا حقا أحب ذلك أنيق وبسيط.

Answer 3

أستخدم Linq لتنظيف أسماء الملفات.يمكنك توسيع هذا بسهولة للتحقق من وجود مسارات صالحة أيضًا.

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

تحديث

تشير بعض التعليقات إلى أن هذه الطريقة لا تعمل معهم، لذا قمت بتضمين رابط لمقتطف DotNetFiddle حتى تتمكن من التحقق من صحة الطريقة.

https://dotnetfiddle.net/nw1SWY

Answer 4

يمكنك إزالة الأحرف غير القانونية باستخدام Linq مثل هذا:

var invalidChars = Path.GetInvalidFileNameChars();

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

يحرر
هكذا يبدو الأمر مع التعديل المطلوب المذكور في التعليقات:

var invalidChars = Path.GetInvalidFileNameChars();

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

Answer 5

هذه كلها حلول رائعة، ولكن جميعها تعتمد عليها Path.GetInvalidFileNameChars, ، والتي قد لا تكون موثوقة كما تظن.لاحظ الملاحظة التالية في وثائق MSDN على Path.GetInvalidFileNameChars:

المصفوفة التي تم إرجاعها من هذه الطريقة هي لا يمكن ضمان احتوائه على المجموعة الكاملة من الأحرف غير الصالحة في أسماء الملفات والدلائل. يمكن أن تختلف المجموعة الكاملة من الأحرف غير الصالحة حسب نظام الملفات.على سبيل المثال، في الأنظمة الأساسية لسطح المكتب المستندة إلى Windows، قد تتضمن أحرف المسار غير الصالحة أحرف ASCII/Unicode من 1 إلى 31، بالإضافة إلى علامة الاقتباس ()، وأقل من (<)، وأكبر من (>)، وتوجيه الأنبوب (|)، ومسافة للخلف ( \b)، فارغة (\0) وعلامة التبويب ( ).

انها ليست أفضل مع Path.GetInvalidPathChars طريقة.أنه يحتوي على نفس الملاحظة بالضبط.

Answer 6

بالنسبة لأسماء الملفات:

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

للمسارات الكاملة:

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

لاحظ أنه إذا كنت تنوي استخدام هذا كميزة أمان، فإن النهج الأكثر قوة هو توسيع جميع المسارات ثم التحقق من أن المسار الذي قدمه المستخدم هو بالفعل فرع من دليل يجب أن يكون للمستخدم حق الوصول إليه.

Answer 7

للمبتدئين، يؤدي القطع إلى إزالة الأحرف من بداية السلسلة أو نهايتها فقط.ثانيًا، يجب عليك تقييم ما إذا كنت تريد حقًا إزالة الأحرف المسيئة، أو تفشل بسرعة وتسمح للمستخدم بمعرفة أن اسم الملف الخاص به غير صالح.خياري هو الأخير، لكن إجابتي يجب أن توضح لك على الأقل كيفية القيام بالأشياء بالطريقة الصحيحة والخاطئة:

سؤال StackOverflow يوضح كيفية التحقق مما إذا كانت السلسلة المحددة هي اسم ملف صالح.لاحظ أنه يمكنك استخدام التعبير العادي من هذا السؤال لإزالة الأحرف باستخدام استبدال التعبير العادي (إذا كنت تريد فعل ذلك حقًا).

Answer 8

أستخدم التعبيرات العادية لتحقيق ذلك.أولاً، أقوم ببناء التعبير العادي ديناميكيًا.

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

ثم أقوم فقط بالاتصال بـ RemoveInvalidChars.Replace للقيام بالبحث والاستبدال.من الواضح أنه يمكن توسيع هذا ليشمل أحرف المسار أيضًا.

Answer 9

أفضل طريقة لإزالة الحرف غير القانوني من إدخال المستخدم هي استبدال الحرف غير القانوني باستخدام فئة Regex، أو إنشاء طريقة في التعليمات البرمجية خلفها أو أيضًا التحقق من صحتها من جانب العميل باستخدام التحكم RegularExpression.

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

أو

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

Answer 10

أنا أفضّل تمامًا فكرة جيف ييتس.سيعمل بشكل مثالي، إذا قمت بتعديله قليلاً:

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

التحسين هو فقط للهروب من التعبير العادي الذي تم إنشاؤه تلقائيًا.

Answer 11

فيما يلي مقتطف التعليمات البرمجية الذي من المفترض أن يساعد في استخدام .NET 3 والإصدارات الأحدث.

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

Answer 12

تجمع معظم الحلول المذكورة أعلاه بين الأحرف غير القانونية لكل من المسار واسم الملف وهو أمر خاطئ (حتى عندما تقوم كلا الاستدعاءات حاليًا بإرجاع نفس مجموعة الأحرف).أود أولاً تقسيم المسار + اسم الملف في المسار واسم الملف، ثم تطبيق المجموعة المناسبة عليهما ثم دمج الاثنين مرة أخرى.

wvd_vegt

Answer 13

إذا قمت بإزالة الأحرف غير الصالحة أو استبدالها بحرف واحد، فقد يكون لديك تصادمات:

<abc -> abc
>abc -> abc

إليك طريقة بسيطة لتجنب ذلك:

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

النتائج:

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

Answer 14

رمي استثناء.

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

Answer 15

لقد كتبت هذا الوحش من أجل المتعة، فهو يتيح لك رحلة ذهابًا وإيابًا:

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

Answer 16

أعتقد أنه من الأسهل بكثير التحقق من صحة استخدام التعبير العادي وتحديد الأحرف المسموح بها، بدلاً من محاولة التحقق من جميع الأحرف السيئة.انظر هذه الروابط:http://www.c-sharpcorner.com/UploadFile/prasad_1/RegExpPSD12062005021717AM/RegExpPSD.aspx http://www.windowsdevcenter.com/pub/a/oreilly/windows/news/csharp_0101.html

قم أيضًا بالبحث عن "محرر التعبير العادي"، فهو يساعد كثيرًا.هناك بعض الأشياء التي يمكنك من خلالها إخراج الكود بلغة c# لك.

Answer 17

يبدو أن هذا هو O(n) ولا يستهلك الكثير من الذاكرة على السلاسل:

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

Answer 18

من خلال فحص الإجابات هنا، يبدو أنها جميعًا ** تتضمن استخدام مصفوفة أحرف من أحرف اسم الملف غير الصالحة.

من المؤكد أن هذا قد يكون تحسينًا دقيقًا - ولكن لصالح أي شخص قد يتطلع إلى التحقق من عدد كبير من القيم لكونها أسماء ملفات صالحة، تجدر الإشارة إلى أن إنشاء مجموعة تجزئة من الأحرف غير الصالحة سيؤدي إلى أداء أفضل بشكل ملحوظ.

لقد فوجئت (صدمت) جدًا في الماضي بمدى سرعة تفوق مجموعة التصنيف (أو القاموس) في التكرار على القائمة.مع السلاسل، إنه رقم منخفض بشكل يبعث على السخرية (حوالي 5-7 عناصر من الذاكرة).مع معظم البيانات البسيطة الأخرى (مراجع الكائنات والأرقام وما إلى ذلك) يبدو أن التقاطع السحري يبلغ حوالي 20 عنصرًا.

يوجد 40 حرفًا غير صالح في "قائمة" Path.InvalidFileNameChars.قمت بالبحث اليوم وهناك معيار جيد جدًا هنا على StackOverflow يُظهر أن مجموعة التجزئة ستستغرق ما يزيد قليلاً عن نصف وقت المصفوفة/القائمة لـ 40 عنصرًا: https://stackoverflow.com/a/10762995/949129

هذه هي الفئة المساعدة التي أستخدمها لتعقيم المسارات.لقد نسيت الآن سبب وجود خيار الاستبدال الرائع فيه، ولكنه موجود كمكافأة لطيفة.

طريقة المكافأة الإضافية "IsValidLocalPath" أيضًا :)

(** تلك التي لا تستخدم التعبيرات العادية)

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

Answer 19

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

يمكنك استخدام الطريقة بوضوح.

Answer 20

لا يمكن أن يحتوي اسم الملف على أحرف من Path.GetInvalidPathChars(), + و # الرموز والأسماء المحددة الأخرى.قمنا بدمج جميع الشيكات في فئة واحدة:

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

طريقة GetValidFileName يستبدل كافة البيانات غير الصحيحة ل _.

Answer 21

بطانة واحدة لتنظيف السلسلة من أي أحرف غير قانونية لتسمية ملفات Windows:

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, "");

Answer 22

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

Answer 23

وهذا سوف تفعل ما تريد، وتجنب الاصطدامات

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

    }

Answer 24

أعتقد أن السؤال لم تتم الإجابة عليه بالكامل بعد ...الإجابات تصف فقط اسم الملف النظيف أو المسار ...ليس كليهما.هنا هو الحل الخاص بي:

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

Answer 25

لقد قمت بإنشاء طريقة تمديد تجمع بين عدة اقتراحات:

1. عقد أحرف غير قانونية في مجموعة التجزئة
2. تصفية الأحرف أدناه ascii 127.نظرًا لأن Path.GetInvalidFileNameChars لا يتضمن جميع الأحرف غير الصالحة الممكنة مع رموز ascii من 0 إلى 255. انظر هنا و MSDN
3. إمكانية تحديد الحرف البديل

مصدر:

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

Answer 26

أو يمكنك أن تفعل فقط

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