如何从。net中的字符串中删除变音符(重音)?

小开

最佳答案

我没有使用过这种方法，但Michael Kaplan在他的博客文章(有一个令人困惑的标题)中描述了一种方法，谈论剥离变符号:剥离是一项有趣的工作(又名论无意义的意义，即一切 Mn字符是非空格的，但是有些更非间距比其他人)< / > < / p >

static string RemoveDiacritics(string text)
{
var normalizedString = text.Normalize(NormalizationForm.FormD);
var stringBuilder = new StringBuilder(capacity: normalizedString.Length);


for (int i = 0; i < normalizedString.Length; i++)
{
char c = normalizedString[i];
var unicodeCategory = CharUnicodeInfo.GetUnicodeCategory(c);
if (unicodeCategory != UnicodeCategory.NonSpacingMark)
{
stringBuilder.Append(c);
}
}


return stringBuilder
.ToString()
.Normalize(NormalizationForm.FormC);
}

注意，这是他之前帖子的后续:剥离附加符号……

该方法使用字符串。正常化将输入字符串分割为组成符号(基本上是将"base";变音符字符)，然后扫描结果并只保留基本字符。这只是有点复杂，但实际上你看到的是一个复杂的问题。

当然，如果你把自己限制在法语中，你可能会在如何在c++ std::字符串中删除重音和波浪号中使用简单的基于表的方法，就像@David Dibben推荐的那样。

小开

如果有人感兴趣，我正在寻找类似的东西，最后写了如下:

public static string NormalizeStringForUrl(string name)
{
String normalizedString = name.Normalize(NormalizationForm.FormD);
StringBuilder stringBuilder = new StringBuilder();


foreach (char c in normalizedString)
{
switch (CharUnicodeInfo.GetUnicodeCategory(c))
{
case UnicodeCategory.LowercaseLetter:
case UnicodeCategory.UppercaseLetter:
case UnicodeCategory.DecimalDigitNumber:
stringBuilder.Append(c);
break;
case UnicodeCategory.SpaceSeparator:
case UnicodeCategory.ConnectorPunctuation:
case UnicodeCategory.DashPunctuation:
stringBuilder.Append('_');
break;
}
}
string result = stringBuilder.ToString();
return String.Join("_", result.Split(new char[] { '_' }
, StringSplitOptions.RemoveEmptyEntries)); // remove duplicate underscores
}

小开

这招对我很管用……

string accentedStr;
byte[] tempBytes;
tempBytes = System.Text.Encoding.GetEncoding("ISO-8859-8").GetBytes(accentedStr);
string asciiStr = System.Text.Encoding.UTF8.GetString(tempBytes);

quick&短!

小开

这是VB版本(工作与希腊):

导入系统。文本

导入系统。全球化

Public Function RemoveDiacritics(ByVal s As String)
Dim normalizedString As String
Dim stringBuilder As New StringBuilder
normalizedString = s.Normalize(NormalizationForm.FormD)
Dim i As Integer
Dim c As Char
For i = 0 To normalizedString.Length - 1
c = normalizedString(i)
If CharUnicodeInfo.GetUnicodeCategory(c) <> UnicodeCategory.NonSpacingMark Then
stringBuilder.Append(c)
End If
Next
Return stringBuilder.ToString()
End Function

小开

我经常使用基于我在这里找到的另一个版本的扩展方法 (见替换c# (ascii)中的字符) 一个简单的解释:

归一化形成D将诸如e这样的字符分割为e和非空格｀
由此，nospacing字符被移除
结果归一化回形式C(我不确定这是否有必要)

代码:

using System.Linq;
using System.Text;
using System.Globalization;


// namespace here
public static class Utility
{
public static string RemoveDiacritics(this string str)
{
if (null == str) return null;
var chars =
from c in str.Normalize(NormalizationForm.FormD).ToCharArray()
let uc = CharUnicodeInfo.GetUnicodeCategory(c)
where uc != UnicodeCategory.NonSpacingMark
select c;


var cleanStr = new string(chars.ToArray()).Normalize(NormalizationForm.FormC);


return cleanStr;
}


// or, alternatively
public static string RemoveDiacritics2(this string str)
{
if (null == str) return null;
var chars = str
.Normalize(NormalizationForm.FormD)
.ToCharArray()
.Where(c=> CharUnicodeInfo.GetUnicodeCategory(c) != UnicodeCategory.NonSpacingMark)
.ToArray();


return new string(chars).Normalize(NormalizationForm.FormC);
}
}

小开

HelperSharp包试试。

有一个方法removeaccent:

 public static string RemoveAccents(this string source)
{
//8 bit characters
byte[] b = Encoding.GetEncoding(1251).GetBytes(source);


// 7 bit characters
string t = Encoding.ASCII.GetString(b);
Regex re = new Regex("[^a-zA-Z0-9]=-_/");
string c = re.Replace(t, " ");
return c;
}

小开

这就是我如何在所有的。net程序中替换变音符字符为非变音符字符

c#:

//Transforms the culture of a letter to its equivalent representation in the 0-127 ascii table, such as the letter 'é' is substituted by an 'e'
public string RemoveDiacritics(string s)
{
string normalizedString = null;
StringBuilder stringBuilder = new StringBuilder();
normalizedString = s.Normalize(NormalizationForm.FormD);
int i = 0;
char c = '\0';


for (i = 0; i <= normalizedString.Length - 1; i++)
{
c = normalizedString[i];
if (CharUnicodeInfo.GetUnicodeCategory(c) != UnicodeCategory.NonSpacingMark)
{
stringBuilder.Append(c);
}
}


return stringBuilder.ToString().ToLower();
}

VB . net:

'Transforms the culture of a letter to its equivalent representation in the 0-127 ascii table, such as the letter "é" is substituted by an "e"'
Public Function RemoveDiacritics(ByVal s As String) As String
Dim normalizedString As String
Dim stringBuilder As New StringBuilder
normalizedString = s.Normalize(NormalizationForm.FormD)
Dim i As Integer
Dim c As Char


For i = 0 To normalizedString.Length - 1
c = normalizedString(i)
If CharUnicodeInfo.GetUnicodeCategory(c) <> UnicodeCategory.NonSpacingMark Then
stringBuilder.Append(c)
End If
Next
Return stringBuilder.ToString().ToLower()
End Function

小开

你可以从MMLib中使用字符串扩展。扩展nuget包:

using MMLib.RapidPrototyping.Generators;
public void ExtensionsExample()
{
string target = "aácčeéií";
Assert.AreEqual("aacceeii", target.RemoveDiacritics());
}

Nuget page: https://www.nuget.org/packages/MMLib.Extensions/ Codeplex项目站点https://mmlib.codeplex.com/

小开

Imports System.Text
Imports System.Globalization


Public Function DECODE(ByVal x As String) As String
Dim sb As New StringBuilder
For Each c As Char In x.Normalize(NormalizationForm.FormD).Where(Function(a) CharUnicodeInfo.GetUnicodeCategory(a) <> UnicodeCategory.NonSpacingMark)
sb.Append(c)
Next
Return sb.ToString()
End Function

小开

这个人说的是: .

Encoding.ASCII.GetString(Encoding.GetEncoding(1251).GetBytes(text));

它实际上把å这样的一个字符(它是字符代码00E5，不 0061加上修饰符030A，看起来是一样的)分割成a加上某种修饰符，然后ASCII转换删除修饰符，只留下a。

小开

我需要一些东西来转换所有主要的unicode字符和投票的答案留下了一些，所以我已经创建了CodeIgniter的convert_accented_characters($str)到c#的一个版本，很容易自定义:

using System;
using System.Text;
using System.Collections.Generic;


public static class Strings
{
static Dictionary<string, string> foreign_characters = new Dictionary<string, string>
{
{ "äæǽ", "ae" },
{ "öœ", "oe" },
{ "ü", "ue" },
{ "Ä", "Ae" },
{ "Ü", "Ue" },
{ "Ö", "Oe" },
{ "ÀÁÂÃÄÅǺĀĂĄǍΑΆẢẠẦẪẨẬẰẮẴẲẶА", "A" },
{ "àáâãåǻāăąǎªαάảạầấẫẩậằắẵẳặа", "a" },
{ "Б", "B" },
{ "б", "b" },
{ "ÇĆĈĊČ", "C" },
{ "çćĉċč", "c" },
{ "Д", "D" },
{ "д", "d" },
{ "ÐĎĐΔ", "Dj" },
{ "ðďđδ", "dj" },
{ "ÈÉÊËĒĔĖĘĚΕΈẼẺẸỀẾỄỂỆЕЭ", "E" },
{ "èéêëēĕėęěέεẽẻẹềếễểệеэ", "e" },
{ "Ф", "F" },
{ "ф", "f" },
{ "ĜĞĠĢΓГҐ", "G" },
{ "ĝğġģγгґ", "g" },
{ "ĤĦ", "H" },
{ "ĥħ", "h" },
{ "ÌÍÎÏĨĪĬǏĮİΗΉΊΙΪỈỊИЫ", "I" },
{ "ìíîïĩīĭǐįıηήίιϊỉịиыї", "i" },
{ "Ĵ", "J" },
{ "ĵ", "j" },
{ "ĶΚК", "K" },
{ "ķκк", "k" },
{ "ĹĻĽĿŁΛЛ", "L" },
{ "ĺļľŀłλл", "l" },
{ "М", "M" },
{ "м", "m" },
{ "ÑŃŅŇΝН", "N" },
{ "ñńņňŉνн", "n" },
{ "ÒÓÔÕŌŎǑŐƠØǾΟΌΩΏỎỌỒỐỖỔỘỜỚỠỞỢО", "O" },
{ "òóôõōŏǒőơøǿºοόωώỏọồốỗổộờớỡởợо", "o" },
{ "П", "P" },
{ "п", "p" },
{ "ŔŖŘΡР", "R" },
{ "ŕŗřρр", "r" },
{ "ŚŜŞȘŠΣС", "S" },
{ "śŝşșšſσςс", "s" },
{ "ȚŢŤŦτТ", "T" },
{ "țţťŧт", "t" },
{ "ÙÚÛŨŪŬŮŰŲƯǓǕǗǙǛŨỦỤỪỨỮỬỰУ", "U" },
{ "ùúûũūŭůűųưǔǖǘǚǜυύϋủụừứữửựу", "u" },
{ "ÝŸŶΥΎΫỲỸỶỴЙ", "Y" },
{ "ýÿŷỳỹỷỵй", "y" },
{ "В", "V" },
{ "в", "v" },
{ "Ŵ", "W" },
{ "ŵ", "w" },
{ "ŹŻŽΖЗ", "Z" },
{ "źżžζз", "z" },
{ "ÆǼ", "AE" },
{ "ß", "ss" },
{ "Ĳ", "IJ" },
{ "ĳ", "ij" },
{ "Œ", "OE" },
{ "ƒ", "f" },
{ "ξ", "ks" },
{ "π", "p" },
{ "β", "v" },
{ "μ", "m" },
{ "ψ", "ps" },
{ "Ё", "Yo" },
{ "ё", "yo" },
{ "Є", "Ye" },
{ "є", "ye" },
{ "Ї", "Yi" },
{ "Ж", "Zh" },
{ "ж", "zh" },
{ "Х", "Kh" },
{ "х", "kh" },
{ "Ц", "Ts" },
{ "ц", "ts" },
{ "Ч", "Ch" },
{ "ч", "ch" },
{ "Ш", "Sh" },
{ "ш", "sh" },
{ "Щ", "Shch" },
{ "щ", "shch" },
{ "ЪъЬь", "" },
{ "Ю", "Yu" },
{ "ю", "yu" },
{ "Я", "Ya" },
{ "я", "ya" },
};


public static char RemoveDiacritics(this char c){
foreach(KeyValuePair<string, string> entry in foreign_characters)
{
if(entry.Key.IndexOf (c) != -1)
{
return entry.Value[0];
}
}
return c;
}


public static string RemoveDiacritics(this string s)
{
//StringBuilder sb = new StringBuilder ();
string text = "";




foreach (char c in s)
{
int len = text.Length;


foreach(KeyValuePair<string, string> entry in foreign_characters)
{
if(entry.Key.IndexOf (c) != -1)
{
text += entry.Value;
break;
}
}


if (len == text.Length) {
text += c;
}
}
return text;
}
}

使用

// for strings
"crème brûlée".RemoveDiacritics (); // creme brulee


// for chars
"Ã"[0].RemoveDiacritics (); // A

小开

希腊(ISO)的CodePage可以做到这一点

关于这个代码页的信息是System.Text.Encoding.GetEncodings()。了解in: https://msdn.microsoft.com/pt-br/library/system.text.encodinginfo.getencoding (v = vs.110) . aspx

希腊语(ISO)有代码页28597和名称iso - 8859 - 7。

进入代码…\ o /

string text = "Você está numa situação lamentável";


string textEncode = System.Web.HttpUtility.UrlEncode(text, Encoding.GetEncoding("iso-8859-7"));
//result: "Voce+esta+numa+situacao+lamentavel"


string textDecode = System.Web.HttpUtility.UrlDecode(textEncode);
//result: "Voce esta numa situacao lamentavel"

那么，写这个函数…

public string RemoveAcentuation(string text)
{
return
System.Web.HttpUtility.UrlDecode(
System.Web.HttpUtility.UrlEncode(
text, Encoding.GetEncoding("iso-8859-7")));
}

请注意,…Encoding.GetEncoding("iso-8859-7")等价于Encoding.GetEncoding(28597)，因为第一个是名称，第二个是Encoding的代码页。

小开

有趣的是，这样的问题可以得到这么多答案，但没有一个符合我的要求:)周围有这么多语言，一个完全语言不可知的解决方案是不可能的，因为其他人已经提到FormC或FormD正在给出问题。

由于最初的问题与法语有关，最简单的答案确实是

    public static string ConvertWesternEuropeanToASCII(this string str)
{
return Encoding.ASCII.GetString(Encoding.GetEncoding(1251).GetBytes(str));
}

1251应该被输入语言的编码代码所取代。

但是，这只能用一个字符替换一个字符。由于我也使用德语作为输入，所以我进行了手动转换

    public static string LatinizeGermanCharacters(this string str)
{
StringBuilder sb = new StringBuilder(str.Length);
foreach (char c in str)
{
switch (c)
{
case 'ä':
sb.Append("ae");
break;
case 'ö':
sb.Append("oe");
break;
case 'ü':
sb.Append("ue");
break;
case 'Ä':
sb.Append("Ae");
break;
case 'Ö':
sb.Append("Oe");
break;
case 'Ü':
sb.Append("Ue");
break;
case 'ß':
sb.Append("ss");
break;
default:
sb.Append(c);
break;
}
}
return sb.ToString();
}

它可能不能提供最好的性能，但至少它非常易于阅读和扩展。 Regex是一个NO GO，比任何字符/字符串的东西慢得多

我还有一个非常简单的方法来删除空间:

    public static string RemoveSpace(this string str)
{
return str.Replace(" ", string.Empty);
}

最终，我使用以上3个扩展的组合:

    public static string LatinizeAndConvertToASCII(this string str, bool keepSpace = false)
{
str = str.LatinizeGermanCharacters().ConvertWesternEuropeanToASCII();
return keepSpace ? str : str.RemoveSpace();
}

并对其进行了一个小单元测试(不详尽)，以成功通过。

    [TestMethod()]
public void LatinizeAndConvertToASCIITest()
{
string europeanStr = "Bonjour ça va? C'est l'été! Ich möchte ä Ä á à â ê é è ë Ë É ï Ï î í ì ó ò ô ö Ö Ü ü ù ú û Û ý Ý ç Ç ñ Ñ";
string expected = "Bonjourcava?C'estl'ete!IchmoechteaeAeaaaeeeeEEiIiiiooooeOeUeueuuuUyYcCnN";
string actual = europeanStr.LatinizeAndConvertToASCII();
Assert.AreEqual(expected, actual);
}

小开

我真的很喜欢azrafe7提供的简洁而实用的代码。因此，我稍微改变了一下，将它转换为一个扩展方法:

public static class StringExtensions
{
public static string RemoveDiacritics(this string text)
{
const string SINGLEBYTE_LATIN_ASCII_ENCODING = "ISO-8859-8";


if (string.IsNullOrEmpty(text))
{
return string.Empty;
}


return Encoding.ASCII.GetString(
Encoding.GetEncoding(SINGLEBYTE_LATIN_ASCII_ENCODING).GetBytes(text));
}
}

小开

在这里弹出这个库，如果您还没有考虑过的话。看起来有一个完整的单元测试。

https://github.com/thomasgalliker/Diacritics.NET

小开

没有足够的声誉，显然我不能评论亚历山大的优秀链接。Lucene似乎是唯一的解决方案在合理的通用情况下工作。

对于那些想要一个简单的复制粘贴解决方案的人，这里是利用Lucene中的代码:

字符串试验台= " AAAACEIIOOØUUÞaaaaaaæceeeeiiiið人参公鸡øUUāăčĐęğıŁłńŌōřŞşšźžșțệủ”;

Console.WriteLine (Lucene.latinizeLucene(实验);

AAAACEIIOOOUUTHaaaaaaaeceeeeiiiidnoooouuaacDegiLlnOorSsszzsteu

//////////

public static class Lucene
{
// source: https://raw.githubusercontent.com/apache/lucenenet/master/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/ASCIIFoldingFilter.cs
// idea: https://stackoverflow.com/questions/249087/how-do-i-remove-diacritics-accents-from-a-string-in-net (scroll down, search for lucene by Alexander)
public static string latinizeLucene(string arg)
{
char[] argChar = arg.ToCharArray();


// latinizeLuceneImpl can expand one char up to four chars - e.g. Þ to TH, or æ to ae, or in fact ⑽ to (10)
char[] resultChar = new String(' ', arg.Length * 4).ToCharArray();


int outputPos = Lucene.latinizeLuceneImpl(argChar, 0, ref resultChar, 0, arg.Length);


string ret = new string(resultChar);
ret = ret.Substring(0, outputPos);


return ret;
}


/// <summary>
/// Converts characters above ASCII to their ASCII equivalents.  For example,
/// accents are removed from accented characters.
/// <para/>
/// @lucene.internal
/// </summary>
/// <param name="input">     The characters to fold </param>
/// <param name="inputPos">  Index of the first character to fold </param>
/// <param name="output">    The result of the folding. Should be of size >= <c>length * 4</c>. </param>
/// <param name="outputPos"> Index of output where to put the result of the folding </param>
/// <param name="length">    The number of characters to fold </param>
/// <returns> length of output </returns>
private static int latinizeLuceneImpl(char[] input, int inputPos, ref char[] output, int outputPos, int length)
{
int end = inputPos + length;
for (int pos = inputPos; pos < end; ++pos)
{
char c = input[pos];


// Quick test: if it's not in range then just keep current character
if (c < '\u0080')
{
output[outputPos++] = c;
}
else
{
switch (c)
{
case '\u00C0': // À  [LATIN CAPITAL LETTER A WITH GRAVE]
case '\u00C1': // Á  [LATIN CAPITAL LETTER A WITH ACUTE]
case '\u00C2': // Â  [LATIN CAPITAL LETTER A WITH CIRCUMFLEX]
case '\u00C3': // Ã  [LATIN CAPITAL LETTER A WITH TILDE]
case '\u00C4': // Ä  [LATIN CAPITAL LETTER A WITH DIAERESIS]
case '\u00C5': // Å  [LATIN CAPITAL LETTER A WITH RING ABOVE]
case '\u0100': // Ā  [LATIN CAPITAL LETTER A WITH MACRON]
case '\u0102': // Ă  [LATIN CAPITAL LETTER A WITH BREVE]
case '\u0104': // Ą  [LATIN CAPITAL LETTER A WITH OGONEK]
case '\u018F': // Ə  http://en.wikipedia.org/wiki/Schwa  [LATIN CAPITAL LETTER SCHWA]
case '\u01CD': // Ǎ  [LATIN CAPITAL LETTER A WITH CARON]
case '\u01DE': // Ǟ  [LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON]
case '\u01E0': // Ǡ  [LATIN CAPITAL LETTER A WITH DOT ABOVE AND MACRON]
case '\u01FA': // Ǻ  [LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE]
case '\u0200': // Ȁ  [LATIN CAPITAL LETTER A WITH DOUBLE GRAVE]
case '\u0202': // Ȃ  [LATIN CAPITAL LETTER A WITH INVERTED BREVE]
case '\u0226': // Ȧ  [LATIN CAPITAL LETTER A WITH DOT ABOVE]
case '\u023A': // Ⱥ  [LATIN CAPITAL LETTER A WITH STROKE]
case '\u1D00': // ᴀ  [LATIN LETTER SMALL CAPITAL A]
case '\u1E00': // Ḁ  [LATIN CAPITAL LETTER A WITH RING BELOW]
case '\u1EA0': // Ạ  [LATIN CAPITAL LETTER A WITH DOT BELOW]
case '\u1EA2': // Ả  [LATIN CAPITAL LETTER A WITH HOOK ABOVE]
case '\u1EA4': // Ấ  [LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE]
case '\u1EA6': // Ầ  [LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND GRAVE]
case '\u1EA8': // Ẩ  [LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE]
case '\u1EAA': // Ẫ  [LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND TILDE]
case '\u1EAC': // Ậ  [LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND DOT BELOW]
case '\u1EAE': // Ắ  [LATIN CAPITAL LETTER A WITH BREVE AND ACUTE]
case '\u1EB0': // Ằ  [LATIN CAPITAL LETTER A WITH BREVE AND GRAVE]
case '\u1EB2': // Ẳ  [LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE]
case '\u1EB4': // Ẵ  [LATIN CAPITAL LETTER A WITH BREVE AND TILDE]
case '\u1EB6': // Ặ  [LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW]
case '\u24B6': // Ⓐ  [CIRCLED LATIN CAPITAL LETTER A]
case '\uFF21': // Ａ  [FULLWIDTH LATIN CAPITAL LETTER A]
output[outputPos++] = 'A';
break;
case '\u00E0': // à  [LATIN SMALL LETTER A WITH GRAVE]
case '\u00E1': // á  [LATIN SMALL LETTER A WITH ACUTE]
case '\u00E2': // â  [LATIN SMALL LETTER A WITH CIRCUMFLEX]
case '\u00E3': // ã  [LATIN SMALL LETTER A WITH TILDE]
case '\u00E4': // ä  [LATIN SMALL LETTER A WITH DIAERESIS]
case '\u00E5': // å  [LATIN SMALL LETTER A WITH RING ABOVE]
case '\u0101': // ā  [LATIN SMALL LETTER A WITH MACRON]
case '\u0103': // ă  [LATIN SMALL LETTER A WITH BREVE]
case '\u0105': // ą  [LATIN SMALL LETTER A WITH OGONEK]
case '\u01CE': // ǎ  [LATIN SMALL LETTER A WITH CARON]
case '\u01DF': // ǟ  [LATIN SMALL LETTER A WITH DIAERESIS AND MACRON]
case '\u01E1': // ǡ  [LATIN SMALL LETTER A WITH DOT ABOVE AND MACRON]
case '\u01FB': // ǻ  [LATIN SMALL LETTER A WITH RING ABOVE AND ACUTE]
case '\u0201': // ȁ  [LATIN SMALL LETTER A WITH DOUBLE GRAVE]
case '\u0203': // ȃ  [LATIN SMALL LETTER A WITH INVERTED BREVE]
case '\u0227': // ȧ  [LATIN SMALL LETTER A WITH DOT ABOVE]
case '\u0250': // ɐ  [LATIN SMALL LETTER TURNED A]
case '\u0259': // ə  [LATIN SMALL LETTER SCHWA]
case '\u025A': // ɚ  [LATIN SMALL LETTER SCHWA WITH HOOK]
case '\u1D8F': // ᶏ  [LATIN SMALL LETTER A WITH RETROFLEX HOOK]
case '\u1D95': // ᶕ  [LATIN SMALL LETTER SCHWA WITH RETROFLEX HOOK]
case '\u1E01': // ạ  [LATIN SMALL LETTER A WITH RING BELOW]
case '\u1E9A': // ả  [LATIN SMALL LETTER A WITH RIGHT HALF RING]
case '\u1EA1': // ạ  [LATIN SMALL LETTER A WITH DOT BELOW]
case '\u1EA3': // ả  [LATIN SMALL LETTER A WITH HOOK ABOVE]
case '\u1EA5': // ấ  [LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE]
case '\u1EA7': // ầ  [LATIN SMALL LETTER A WITH CIRCUMFLEX AND GRAVE]
case '\u1EA9': // ẩ  [LATIN SMALL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE]
case '\u1EAB': // ẫ  [LATIN SMALL LETTER A WITH CIRCUMFLEX AND TILDE]
case '\u1EAD': // ậ  [LATIN SMALL LETTER A WITH CIRCUMFLEX AND DOT BELOW]
case '\u1EAF': // ắ  [LATIN SMALL LETTER A WITH BREVE AND ACUTE]
case '\u1EB1': // ằ  [LATIN SMALL LETTER A WITH BREVE AND GRAVE]
case '\u1EB3': // ẳ  [LATIN SMALL LETTER A WITH BREVE AND HOOK ABOVE]
case '\u1EB5': // ẵ  [LATIN SMALL LETTER A WITH BREVE AND TILDE]
case '\u1EB7': // ặ  [LATIN SMALL LETTER A WITH BREVE AND DOT BELOW]
case '\u2090': // ₐ  [LATIN SUBSCRIPT SMALL LETTER A]
case '\u2094': // ₔ  [LATIN SUBSCRIPT SMALL LETTER SCHWA]
case '\u24D0': // ⓐ  [CIRCLED LATIN SMALL LETTER A]
case '\u2C65': // ⱥ  [LATIN SMALL LETTER A WITH STROKE]
case '\u2C6F': // Ɐ  [LATIN CAPITAL LETTER TURNED A]
case '\uFF41': // ａ  [FULLWIDTH LATIN SMALL LETTER A]
output[outputPos++] = 'a';
break;
case '\uA732': // Ꜳ  [LATIN CAPITAL LETTER AA]
output[outputPos++] = 'A';
output[outputPos++] = 'A';
break;
case '\u00C6': // Æ  [LATIN CAPITAL LETTER AE]
case '\u01E2': // Ǣ  [LATIN CAPITAL LETTER AE WITH MACRON]
case '\u01FC': // Ǽ  [LATIN CAPITAL LETTER AE WITH ACUTE]
case '\u1D01': // ᴁ  [LATIN LETTER SMALL CAPITAL AE]
output[outputPos++] = 'A';
output[outputPos++] = 'E';
break;
case '\uA734': // Ꜵ  [LATIN CAPITAL LETTER AO]
output[outputPos++] = 'A';
output[outputPos++] = 'O';
break;
case '\uA736': // Ꜷ  [LATIN CAPITAL LETTER AU]
output[outputPos++] = 'A';
output[outputPos++] = 'U';
break;


// etc. etc. etc.
// see link above for complete source code
//
// unfortunately, postings are limited, as in
// "Body is limited to 30000 characters; you entered 136098."


[...]


case '\u2053': // ⁓  [SWUNG DASH]
case '\uFF5E': // ～  [FULLWIDTH TILDE]
output[outputPos++] = '~';
break;
default:
output[outputPos++] = c;
break;
}
}
}
return outputPos;
}
}

小开

Tl; dr - __abc0

我认为保留字符串含义的最佳解决方案是转换字符，而不是剥离它们，这在示例crème brûlée到crme brle vs. creme brulee中得到了很好的说明。

我检查了上面亚历山大的评论，看到了Lucene。Net代码是Apache 2.0许可的，因此我将该类修改为一个简单的字符串扩展方法。你可以这样使用它:

var originalString = "crème brûlée";
var maxLength = originalString.Length; // limit output length as necessary
var foldedString = originalString.FoldToASCII(maxLength);
// "creme brulee"

该函数太长，不能在StackOverflow回答中发布(~139k字符的30k允许lol)，因此我写了一个要点，并注明了作者:

/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements.  See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License.  You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/


/// <summary>
/// This class converts alphabetic, numeric, and symbolic Unicode characters
/// which are not in the first 127 ASCII characters (the "Basic Latin" Unicode
/// block) into their ASCII equivalents, if one exists.
/// <para/>
/// Characters from the following Unicode blocks are converted; however, only
/// those characters with reasonable ASCII alternatives are converted:
///
/// <ul>
///   <item><description>C1 Controls and Latin-1 Supplement: <a href="http://www.unicode.org/charts/PDF/U0080.pdf">http://www.unicode.org/charts/PDF/U0080.pdf</a></description></item>
///   <item><description>Latin Extended-A: <a href="http://www.unicode.org/charts/PDF/U0100.pdf">http://www.unicode.org/charts/PDF/U0100.pdf</a></description></item>
///   <item><description>Latin Extended-B: <a href="http://www.unicode.org/charts/PDF/U0180.pdf">http://www.unicode.org/charts/PDF/U0180.pdf</a></description></item>
///   <item><description>Latin Extended Additional: <a href="http://www.unicode.org/charts/PDF/U1E00.pdf">http://www.unicode.org/charts/PDF/U1E00.pdf</a></description></item>
///   <item><description>Latin Extended-C: <a href="http://www.unicode.org/charts/PDF/U2C60.pdf">http://www.unicode.org/charts/PDF/U2C60.pdf</a></description></item>
///   <item><description>Latin Extended-D: <a href="http://www.unicode.org/charts/PDF/UA720.pdf">http://www.unicode.org/charts/PDF/UA720.pdf</a></description></item>
///   <item><description>IPA Extensions: <a href="http://www.unicode.org/charts/PDF/U0250.pdf">http://www.unicode.org/charts/PDF/U0250.pdf</a></description></item>
///   <item><description>Phonetic Extensions: <a href="http://www.unicode.org/charts/PDF/U1D00.pdf">http://www.unicode.org/charts/PDF/U1D00.pdf</a></description></item>
///   <item><description>Phonetic Extensions Supplement: <a href="http://www.unicode.org/charts/PDF/U1D80.pdf">http://www.unicode.org/charts/PDF/U1D80.pdf</a></description></item>
///   <item><description>General Punctuation: <a href="http://www.unicode.org/charts/PDF/U2000.pdf">http://www.unicode.org/charts/PDF/U2000.pdf</a></description></item>
///   <item><description>Superscripts and Subscripts: <a href="http://www.unicode.org/charts/PDF/U2070.pdf">http://www.unicode.org/charts/PDF/U2070.pdf</a></description></item>
///   <item><description>Enclosed Alphanumerics: <a href="http://www.unicode.org/charts/PDF/U2460.pdf">http://www.unicode.org/charts/PDF/U2460.pdf</a></description></item>
///   <item><description>Dingbats: <a href="http://www.unicode.org/charts/PDF/U2700.pdf">http://www.unicode.org/charts/PDF/U2700.pdf</a></description></item>
///   <item><description>Supplemental Punctuation: <a href="http://www.unicode.org/charts/PDF/U2E00.pdf">http://www.unicode.org/charts/PDF/U2E00.pdf</a></description></item>
///   <item><description>Alphabetic Presentation Forms: <a href="http://www.unicode.org/charts/PDF/UFB00.pdf">http://www.unicode.org/charts/PDF/UFB00.pdf</a></description></item>
///   <item><description>Halfwidth and Fullwidth Forms: <a href="http://www.unicode.org/charts/PDF/UFF00.pdf">http://www.unicode.org/charts/PDF/UFF00.pdf</a></description></item>
/// </ul>
/// <para/>
/// See: <a href="http://en.wikipedia.org/wiki/Latin_characters_in_Unicode">http://en.wikipedia.org/wiki/Latin_characters_in_Unicode</a>
/// <para/>
/// For example, '&amp;agrave;' will be replaced by 'a'.
/// </summary>
public static partial class StringExtensions
{
/// <summary>
/// Converts characters above ASCII to their ASCII equivalents.  For example,
/// accents are removed from accented characters.
/// </summary>
/// <param name="input">     The string of characters to fold </param>
/// <param name="length">    The length of the folded return string </param>
/// <returns> length of output </returns>
public static string FoldToASCII(this string input, int? length = null)
{
// See https://gist.github.com/andyraddatz/e6a396fb91856174d4e3f1bf2e10951c
}
}

希望这能帮助到其他人，这是我发现的最强大的解决方案!

小开

这段代码对我很有用:

var updatedText = text.Normalize(NormalizationForm.FormD)
.Where(c => CharUnicodeInfo.GetUnicodeCategory(c) != UnicodeCategory.NonSpacingMark)
.ToArray();

这不仅是对名字中有变音/口音的人的侮辱，在某些情况下也可能是危险的错误(见下文)。除了去掉重音，还有其他的写法。

此外，这是错误和危险的，例如，如果用户必须准确地提供他的名字在护照上的出现方式。

例如，我的名字是Zuberbühler，在我护照的机器可读部分，你会发现Zuberbuehler。去掉变音后，名字将与两个部分都不匹配。这可能会给用户带来问题。

你应该禁止变音/重音在输入表单的名称中，这样用户就可以正确地写出他的名字，不带变音或重音。

例如，如果申请ESTA (https://www.application-esta.co.uk/special-characters-and)的web服务使用上述代码，而不是正确转换变音，ESTA申请将被拒绝，或者旅行者将在进入美国时与美国边境控制出现问题。

另一个例子是机票。假设您有一个机票预订web应用程序，用户提供带有重音的名字，您的实现只是删除重音，然后使用航空公司的web服务预订机票!您的客户可能不被允许登机，因为姓名与他/她护照的任何部分不匹配。

小开

与接受的答案相同，但更快，使用Span而不是StringBuilder。
要求。net Core 3.1或更新的。net

static string RemoveDiacritics(string text)
{
ReadOnlySpan<char> normalizedString = text.Normalize(NormalizationForm.FormD);
int i = 0;
Span<char> span = text.Length < 1000
? stackalloc char[text.Length]
: new char[text.Length];


foreach (char c in normalizedString)
{
if (CharUnicodeInfo.GetUnicodeCategory(c) != UnicodeCategory.NonSpacingMark)
span[i++] = c;
}


return new string(span).Normalize(NormalizationForm.FormC);
}

此外，这是可扩展的额外字符替换，如抛光Ł。

span[i++] = c switch
{
'Ł' => 'L',
'ł' => 'l',
_ => c
};

一个小提示:堆栈分配stackalloc比堆分配new快得多，而且它为垃圾收集器节省了更少的工作。1000是一个阈值，以避免在堆栈上分配可能导致StackOverflowException的大结构。虽然1000是一个相当安全的值，但在大多数情况下10000甚至100000也可以(100k在堆栈上分配最多200kB，而默认堆栈大小为1mb)。然而10万对我来说有点危险。

小开

公认的答案是完全正确的，但现在，它应该更新为使用符文类而不是CharUnicodeInfo，如c# &. net更新了在最新版本中分析字符串的方法(在。net Core 3.0中添加了符文类)。

下面的代码现在推荐用于。net 5+，因为它可以进一步用于非拉丁字符:

static string RemoveDiacritics(string text)
{
var normalizedString = text.Normalize(NormalizationForm.FormD);
var stringBuilder = new StringBuilder();


foreach (var c in normalizedString.EnumerateRunes())
{
var unicodeCategory = Rune.GetUnicodeCategory(c);
if (unicodeCategory != UnicodeCategory.NonSpacingMark)
{
stringBuilder.Append(c);
}
}


return stringBuilder.ToString().Normalize(NormalizationForm.FormC);
}

小开

为了像最初的问题一样简单地删除法语加拿大重音标记，这里有一个使用正则表达式而不是硬编码转换和For/Next循环的替代方法。根据您的需要，它可以被压缩成一行代码;但是，我将它添加到一个扩展类中，以便于重用。

Visual Basic

Imports System.Text
Imports System.Text.RegularExpressions


Public MustInherit Class StringExtension
Public Shared Function RemoveDiacritics(Text As String) As String
Return New Regex("\p{Mn}", RegexOptions.Compiled).Replace(Text.Normalize(NormalizationForm.FormD), String.Empty)
End Function
End Class

实现

    Private Shared Sub DoStuff()
MsgBox(StringExtension.RemoveDiacritics(inputString))
End Sub

c#

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


namespace YourApplication
{
public abstract class StringExtension
{
public static string RemoveDiacritics(string Text)
{
return new Regex(@"\p{Mn}", RegexOptions.Compiled).Replace(Text.Normalize(NormalizationForm.FormD), string.Empty);
}
}
}

实现

        private static void DoStuff()
{
MessageBox.Show(StringExtension.RemoveDiacritics(inputString));
}

输入: äáčďěéíľľňôóřŕšťúůýž ÄÁČĎĚÉÍĽĽŇÔÓŘŔŠŤÚŮÝŽ ÖÜË łŁđĐ ţŢşŞçÇ øı

输出: aacdeeillnoorrstuuyz AACDEEILLNOORRSTUUYZ OUE łŁđĐ tTsScC øı

我加入了无法转换的字符，以帮助可视化接收到意外输入时会发生什么。

如果你还需要它来转换其他类型的字符，比如波兰语的warsaw和Ł，那么根据你的需要，考虑合并这个答案(。NET Core友好的)，使用CodePagesEncodingProvider到你的解决方案。

小开

为所有找到Lucene的人。Net作为一个多余的删除变音符，我设法找到这个小库，利用ASCII音译为您。

https://github.com/anyascii/anyascii