Yol ve dosya adlarından yasadışı karakterler nasıl kaldırılır?

Basit bir dizeden yasadışı yol ve dosya karakterlerini kaldırmak için sağlam ve basit bir yol gerekir. Aşağıdaki kodu kullandım ama hiçbir şey yapmıyor gibi görünüyor, ne eksik?

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

Bunun yerine böyle bir şey deneyin;

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

Ama yorumlara katılıyorum, yasadışı bir yolu meşru ama muhtemelen istenmeyen bir yola dönüştürmek yerine, muhtemelen yasadışı yolların kaynağı ile uğraşmaya çalışacağım.

Düzenleme: Veya Regex kullanarak potansiyel olarak 'daha iyi' bir çözüm.

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

Yine de, soru ilk başta neden yaptığınızı sormaya yalvarmaktadır.

Orijinal soru "geçersiz karakterleri kaldırmak" istedi:

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

Bunun yerine bunları değiştirmek isteyebilirsiniz:

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

Bu cevap Ceres tarafından başka bir iş parçacığında oldu , ben gerçekten düzgün ve basit gibi.

Dosya adlarını temizlemek için Linq kullanıyorum. Geçerli yolları kontrol etmek için bunu kolayca genişletebilirsiniz.

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

Güncelleme

Bazı yorumlar bu yöntemin onlar için çalışmadığını gösterir, bu nedenle yöntemi doğrulayabilmeniz için bir DotNetFiddle snippet'ine bir bağlantı ekledim.

https://dotnetfiddle.net/nw1SWY

Linq kullanarak yasadışı karakterleri aşağıdaki gibi kaldırabilirsiniz:

var invalidChars = Path.GetInvalidFileNameChars();

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

DÜZENLE
yorumlarda belirtilen gerekli düzenleme ile şu şekilde görünür:

var invalidChars = Path.GetInvalidFileNameChars();

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

Bunların hepsi harika çözümlerdir, ancak hepsine güvenir Path.GetInvalidFileNameChars, ki bu düşündüğünüz kadar güvenilir olmayabilir. Aşağıdaki MSDN belgelerinde aşağıdaki açıklamaya dikkat edin Path.GetInvalidFileNameChars:

Bu yöntemden döndürülen dizinin , dosya ve dizin adlarında geçersiz olan tüm karakter kümesini içereceği garanti edilmez. Geçersiz karakterlerin tamamı dosya sistemine göre değişebilir. Örneğin, Windows tabanlı masaüstü platformlarında geçersiz yol karakterleri, 1'den 31'e kadar ASCII / Unicode karakterlerin yanı sıra (<), (<), (>), pipe (|), backspace ( \ b), null (\ 0) ve sekme (\ t).

Path.GetInvalidPathCharsYöntem ile daha iyi değil . Aynı ifadeyi içerir.

Dosya adları için:

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

Tam yollar için:

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

Bunu bir güvenlik özelliği olarak kullanmayı düşünüyorsanız, daha sağlam bir yaklaşım tüm yolları genişletmek ve daha sonra kullanıcı tarafından sağlanan yolun gerçekten kullanıcının erişmesi gereken bir dizinin alt öğesi olduğunu doğrulamak olacaktır.

Yeni başlayanlar için, Kırp yalnızca karakterleri dizenin başından veya sonundan kaldırır . İkinci olarak, rahatsız edici karakterleri gerçekten kaldırmak isteyip istemediğinizi veya hızlı bir şekilde başarısız olup olmadığınızı değerlendirmeli ve kullanıcıya dosya adının geçersiz olduğunu bildirmelisiniz. Seçimim ikincisidir, ancak cevabım en azından işleri doğru ve yanlış şekilde nasıl yapacağınızı göstermelidir:

Belirli bir dizenin geçerli bir dosya adı olup olmadığını nasıl kontrol edeceğinizi gösteren StackOverflow sorusu . Normal bir ifade değiştirme ile karakterleri kaldırmak için bu sorudaki normal ifadeyi kullanabileceğinizi unutmayın (gerçekten yapmanız gerekiyorsa).

Kullanıcı girdisinden yasadışı karakteri kaldırmanın en iyi yolu, Regex sınıfını kullanarak yasadışı karakteri değiştirmek, kodda yöntem oluşturmak veya RegularExpression denetimini kullanarak istemci tarafında doğrulamaktır.

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

VEYA

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

Bunu başarmak için düzenli ifadeler kullanıyorum. İlk olarak, regex dinamik olarak oluşturmak.

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

Sonra sadece bulmak ve değiştirmek için removeInvalidChars.Replace çağırıyorum. Bu açık bir şekilde yol karakterlerini de kapsayacak şekilde genişletilebilir.

Jeff Yates fikrini kesinlikle tercih ediyorum. Biraz değiştirirseniz mükemmel çalışır:

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

Bu iyileştirme sadece otomatik olarak oluşturulan normal ifadeden kaçmaktır.

İşte .NET 3 ve üstü için yardımcı olması gereken bir kod snippet'i.

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

Yukarıdaki çözümlerin çoğu, hem yol hem de dosya adı için yasadışı karakterleri birleştirir ve bu da yanlıştır (her iki çağrı da şu anda aynı karakter kümesini döndürse bile). Önce path + dosya adını yola ve dosya adına bölerdim, sonra uygun kümeyi ya varsa uygular, sonra ikisini tekrar birleştiririm.

wvd_vegt

Geçersiz karakterleri tek bir karakterle kaldırır veya değiştirirseniz, çakışmalar olabilir:

<abc -> abc
>abc -> abc

Bunu önlemek için basit bir yöntem:

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

Sonuç:

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

Bir istisna atın.

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

Bu canavarı eğlence için yazdım, size gidiş-dönüş sağlar:

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

Tüm kötü karakterleri kontrol etmeye çalışmak yerine, normal ifade kullanarak ve hangi karakterlere izin verildiğini belirterek doğrulamanın çok daha kolay olduğunu düşünüyorum. Bu bağlantılara bakın: http://www.c-sharpcorner.com/UploadFile/prasad_1/RegExpPSD12062005021717AM/RegExpPSD.aspx http://www.windowsdevcenter.com/pub/a/oreilly/windows/news/csharp_0101.html

Ayrıca, "düzenli ifade editörleri" için bir arama yapmak, onlar çok yardımcı olur. Hatta bazı kodlar bile c # çıktı sizin için vardır.

Bu O (n) gibi görünüyor ve dizelere çok fazla bellek harcamıyor:

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

Buradaki cevapları tarayarak, hepsi ** geçersiz dosya adı karakterlerinin char dizisini kullanmayı içeriyor gibi görünüyor.

Kabul edilirse, bu mikro optimizasyon olabilir - ancak geçerli dosya adları olarak çok sayıda değeri kontrol etmek isteyen herkesin yararına, geçersiz karakterlerin bir karma kümesini oluşturmanın önemli ölçüde daha iyi performans getireceğini belirtmek gerekir.

Geçmişte bir hashset (veya sözlük) bir liste üzerinden yineleme ne kadar hızlı performans çok şaşırdım (şok). Dizelerle gülünç derecede düşük bir sayıdır (bellekten yaklaşık 5-7 öğe). Diğer basit verilerle (nesne referansları, sayılar vb.) Sihirli geçiş yaklaşık 20 öğedir.

Path.InvalidFileNameChars "listesinde" 40 geçersiz karakter var. Bugün bir arama yaptı ve burada StackOverflow'da 40 öğenin bir dizinin / listenin yarısından biraz daha uzun süreceğini gösteren oldukça iyi bir kıyaslama var: https://stackoverflow.com/a/10762995/949129

İşte yolları sterilize etmek için kullandığım yardımcı sınıf. Şimdi neden fantezi değiştirme seçeneği olduğunu unuttum, ama orada şirin bir bonus olarak.

Ek bonus yöntemi "IsValidLocalPath" da :)

(** düzenli ifadeler kullanmayanlar)

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

Yöntemi açıkça kullanabilirsiniz.

Dosya adı karakterleri içeremez Path.GetInvalidPathChars(), +ve #sembolleri ve diğer özel isimler. Tüm kontrolleri tek bir sınıfta birleştirdik:

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

Yöntem, GetValidFileNametüm yanlış verilerin yerine geçer _.

Windows dosya adlandırma için herhangi bir yasadışı karakterden dizeyi temizlemek için bir astar:

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

Bu istediğinizi isteyecek ve çarpışmalardan kaçınacaktır

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

    }

Sanırım soru zaten tam olarak cevaplanmadı ... Cevaplar sadece temiz dosya adını VEYA yolu açıklıyor ... ikisini birden değil. İşte benim çözümüm:

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

Birkaç öneriyi birleştiren bir uzantı yöntemi oluşturdum:

1. Karma kümesinde karma karakterleri tutma
2. Path.GetInvalidFileNameChars yana ASCII 127. Aşağıdaki karakterleri filtreleyerek 0'dan 255 ASCII kodları ile mümkün tüm geçersiz karakterler içermeyen burada See ve MSDN
3. Değiştirme karakterini tanımlama imkanı

Kaynak:

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

Bir dosya adındaki tüm yasadışı karakterleri yeni bir karakterle değiştiren bir işlev şunlardır:

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

Örneğin, alt çizgi yedek karakter olarak kullanılabilir:

NewFileName = ReplaceIllegalFileChars(FileName, '_');

Veya sadece yapabilirsin

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