Wie vergleiche ich Unicode-Zeichen, die „gleich aussehen“?

Ich falle in ein überraschendes Problem.

Ich habe eine Textdatei in meine Anwendung geladen und habe eine Logik, die den Wert mit µ vergleicht.

Und mir wurde klar, dass selbst wenn die Texte gleich sind, der Vergleichswert falsch ist.

 Console.WriteLine("μ".Equals("µ")); // returns false
 Console.WriteLine("µ".Equals("µ")); // return true

In der späteren Zeile wird das Zeichen µ kopiert und eingefügt.

Dies sind jedoch möglicherweise nicht die einzigen Zeichen, die so sind.

Gibt es in C # eine Möglichkeit, die Zeichen zu vergleichen, die gleich aussehen, aber tatsächlich unterschiedlich sind?

In vielen Fällen können Sie normalisieren beide der Unicode - Zeichen auf eine gewisse Normalisierung Form vor ihnen zu vergleichen, und sie sollten übereinstimmen können. Welche Normalisierungsform Sie verwenden müssen, hängt natürlich von den Zeichen selbst ab. Nur weil sie gleich aussehen , heißt das nicht unbedingt, dass sie denselben Charakter repräsentieren. Sie müssen auch überlegen, ob es für Ihren Anwendungsfall geeignet ist - siehe den Kommentar von Jukka K. Korpela.

Wenn Sie sich in dieser speziellen Situation auf die Links in Tonys Antwort beziehen , sehen Sie, dass in der Tabelle für U + 00B5 Folgendes angegeben ist :

Zerlegung <Kompat> GRIECHISCHER KLEINBUCHSTABE MU (U + 03BC)

Dies bedeutet, dass U + 00B5, das zweite Zeichen in Ihrem ursprünglichen Vergleich, in U + 03BC, das erste Zeichen, zerlegt werden kann.

Sie normalisieren also die Zeichen mit vollständiger Kompatibilitätszerlegung mit den Normalisierungsformularen KC oder KD. Hier ist ein kurzes Beispiel, das ich geschrieben habe, um zu demonstrieren:

using System;
using System.Text;

class Program
{
    static void Main(string[] args)
    {
        char first = 'μ';
        char second = 'µ';

        // Technically you only need to normalize U+00B5 to obtain U+03BC, but
        // if you're unsure which character is which, you can safely normalize both
        string firstNormalized = first.ToString().Normalize(NormalizationForm.FormKD);
        string secondNormalized = second.ToString().Normalize(NormalizationForm.FormKD);

        Console.WriteLine(first.Equals(second));                     // False
        Console.WriteLine(firstNormalized.Equals(secondNormalized)); // True
    }
}

Einzelheiten zu Unicode - Normalisierung und die unterschiedlichen Normalisierungsformen beziehen sie auf System.Text.NormalizationFormund die Unicode - Spezifikation .

Da es sich wirklich um verschiedene Symbole handelt, auch wenn sie gleich aussehen, ist der erste der eigentliche Buchstabe und hat code = 956 (0x3BC)Zeichen und der zweite ist das Mikrozeichen und hat 181 (0xB5).

Verweise:

• Unicode-Zeichen 'GREEK SMALL LETTER MU' (U + 03BC)
• Unicode-Zeichen 'MICRO SIGN' (U + 00B5)

Wenn Sie sie also vergleichen möchten und sie gleich sein müssen, müssen Sie sie manuell behandeln oder vor dem Vergleich ein Zeichen durch ein anderes ersetzen. Oder verwenden Sie den folgenden Code:

public void Main()
{
    var s1 = "μ";
    var s2 = "µ";

    Console.WriteLine(s1.Equals(s2));  // false
    Console.WriteLine(RemoveDiacritics(s1).Equals(RemoveDiacritics(s2))); // true 
}

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

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

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

Und die Demo

Beide haben unterschiedliche Zeichencodes: Weitere Informationen finden Sie hier

Console.WriteLine((int)'μ');  //956
Console.WriteLine((int)'µ');  //181

Wo, 1. ist:

Display     Friendly Code   Decimal Code    Hex Code    Description
====================================================================
μ           μ            μ          μ     Lowercase Mu
µ           µ         µ          µ      micro sign Mu

Für das spezifische Beispiel von μ(mu) und µ(Mikrozeichen) hat das letztere eine Kompatibilitätszerlegung mit dem ersteren, so dass Sie den String auf oder normalisieren könnenFormKCFormKD die Mikrozeichen in mus umwandeln können.

Es gibt jedoch viele Zeichensätze, die ähnlich aussehen, aber unter keinem Unicode-Normalisierungsformular gleichwertig sind. Zum Beispiel A(lateinisch), Α(griechisch) und А(kyrillisch). Die Unicode-Website enthält eine Datei confusables.txt mit einer Liste dieser Dateien, die Entwicklern helfen soll, sich vor Homograph-Angriffen zu schützen . Bei Bedarf können Sie diese Datei analysieren und eine Tabelle zur „visuellen Normalisierung“ von Zeichenfolgen erstellen.

Suchen Sie beide Zeichen in einer Unicode-Datenbank und sehen Sie den Unterschied .

Einer ist der griechische Kleinbuchstabe µ und der andere ist das Mikrozeichen µ .

Name            : MICRO SIGN
Block           : Latin-1 Supplement
Category        : Letter, Lowercase [Ll]
Combine         : 0
BIDI            : Left-to-Right [L]
Decomposition   : <compat> GREEK SMALL LETTER MU (U+03BC)
Mirror          : N
Index entries   : MICRO SIGN
Upper case      : U+039C
Title case      : U+039C
Version         : Unicode 1.1.0 (June, 1993)

---

Name            : GREEK SMALL LETTER MU
Block           : Greek and Coptic
Category        : Letter, Lowercase [Ll]
Combine         : 0
BIDI            : Left-to-Right [L]
Mirror          : N
Upper case      : U+039C
Title case      : U+039C
See Also        : micro sign U+00B5
Version         : Unicode 1.1.0 (June, 1993)

BEARBEITEN Nach dem Zusammenführen dieser Frage mit Wie man 'μ' und 'µ' in C # vergleicht
Originalantwort gepostet:

 "μ".ToUpper().Equals("µ".ToUpper()); //This always return true.

BEARBEITEN Nach dem Lesen der Kommentare ist es nicht gut, die obige Methode zu verwenden, da sie möglicherweise falsche Ergebnisse für eine andere Art von Eingaben liefert. Dazu sollten wir Normalisieren mit vollständiger Kompatibilitätszerlegung verwenden, wie im Wiki erwähnt . (Dank der Antwort von BoltClock )

    static string GREEK_SMALL_LETTER_MU = new String(new char[] { '\u03BC' });
    static string MICRO_SIGN = new String(new char[] { '\u00B5' });

    public static void Main()
    {
        string Mus = "µμ";
        string NormalizedString = null;
        int i = 0;
        do
        {
            string OriginalUnicodeString = Mus[i].ToString();
            if (OriginalUnicodeString.Equals(GREEK_SMALL_LETTER_MU))
                Console.WriteLine(" INFORMATIO ABOUT GREEK_SMALL_LETTER_MU");
            else if (OriginalUnicodeString.Equals(MICRO_SIGN))
                Console.WriteLine(" INFORMATIO ABOUT MICRO_SIGN");

            Console.WriteLine();
            ShowHexaDecimal(OriginalUnicodeString);                
            Console.WriteLine("Unicode character category " + CharUnicodeInfo.GetUnicodeCategory(Mus[i]));

            NormalizedString = OriginalUnicodeString.Normalize(NormalizationForm.FormC);
            Console.Write("Form C Normalized: ");
            ShowHexaDecimal(NormalizedString);               

            NormalizedString = OriginalUnicodeString.Normalize(NormalizationForm.FormD);
            Console.Write("Form D Normalized: ");
            ShowHexaDecimal(NormalizedString);               

            NormalizedString = OriginalUnicodeString.Normalize(NormalizationForm.FormKC);
            Console.Write("Form KC Normalized: ");
            ShowHexaDecimal(NormalizedString);                

            NormalizedString = OriginalUnicodeString.Normalize(NormalizationForm.FormKD);
            Console.Write("Form KD Normalized: ");
            ShowHexaDecimal(NormalizedString);                
            Console.WriteLine("_______________________________________________________________");
            i++;
        } while (i < 2);
        Console.ReadLine();
    }

    private static void ShowHexaDecimal(string UnicodeString)
    {
        Console.Write("Hexa-Decimal Characters of " + UnicodeString + "  are ");
        foreach (short x in UnicodeString.ToCharArray())
        {
            Console.Write("{0:X4} ", x);
        }
        Console.WriteLine();
    }

Ausgabe

INFORMATIO ABOUT MICRO_SIGN    
Hexa-Decimal Characters of µ  are 00B5
Unicode character category LowercaseLetter
Form C Normalized: Hexa-Decimal Characters of µ  are 00B5
Form D Normalized: Hexa-Decimal Characters of µ  are 00B5
Form KC Normalized: Hexa-Decimal Characters of µ  are 03BC
Form KD Normalized: Hexa-Decimal Characters of µ  are 03BC
 ________________________________________________________________
 INFORMATIO ABOUT GREEK_SMALL_LETTER_MU    
Hexa-Decimal Characters of µ  are 03BC
Unicode character category LowercaseLetter
Form C Normalized: Hexa-Decimal Characters of µ  are 03BC
Form D Normalized: Hexa-Decimal Characters of µ  are 03BC
Form KC Normalized: Hexa-Decimal Characters of µ  are 03BC
Form KD Normalized: Hexa-Decimal Characters of µ  are 03BC
 ________________________________________________________________

Beim Lesen von Informationen in Unicode_equivalence habe ich gefunden

Die Auswahl der Äquivalenzkriterien kann sich auf die Suchergebnisse auswirken. Zum Beispiel einig typografische Ligatur wie U + FB03 (ffi), ..... so eine Suche nach U + 0066 (f) als Teilkette würde gelingt in einer NFKC Normalisierung der U + FB03 aber nicht in NFC Normalisierung der U + FB03.

Um die Äquivalenz zu vergleichen, sollten wir normalerweise die FormKCNFKC-Normalisierung oder die FormKDNFKD-Normalisierung verwenden.
Ich war wenig neugierig, mehr über alle Unicode-Zeichen zu erfahren, also habe ich ein Beispiel erstellt, das über alle Unicode-Zeichen in iteriert, UTF-16und ich habe einige Ergebnisse erhalten, die ich diskutieren möchte

• Informationen zu Zeichen, deren FormCund FormDnormalisierte Werte nicht äquivalent waren
  Total: 12,118
Character (int value): 192-197, 199-207, 209-214, 217-221, 224-253, ..... 44032-55203
• Informationen zu Zeichen, deren FormKCund FormKDnormalisierte Werte nicht äquivalent waren
  Total: 12,245
Character (int value): 192-197, 199-207, 209-214, 217-221, 224-228, ..... 44032-55203, 64420-64421, 64432-64433, 64490-64507, 64512-64516, 64612-64617, 64663-64667, 64735-64736, 65153-65164, 65269-65274
• Alle Zeichen, deren FormCund FormDnormalisierter Wert nicht äquivalent waren, FormKCund FormKDnormalisierte Werte waren ebenfalls nicht äquivalent, mit Ausnahme dieser Zeichen.
  Zeichen:901 '΅', 8129 '῁', 8141 '῍', 8142 '῎', 8143 '῏', 8157 '῝', 8158 '῞'
, 8159 '῟', 8173 '῭', 8174 '΅'
• Zusätzliches Zeichen, dessen FormKCund FormKDnormalisierter Wert nicht äquivalent waren, aber dort FormCund FormDnormalisierte Werte waren äquivalente
  Total: 119
  Zeichen:452 'DŽ' 453 'Dž' 454 'dž' 12814 '㈎' 12815 '㈏' 12816 '㈐' 12817 '㈑' 12818 '㈒' 12819 '㈓' 12820 '㈔' 12821 '㈕', 12822 '㈖' 12823 '㈗' 12824 '㈘' 12825 '㈙' 12826 '㈚' 12827 '㈛' 12828 '㈜' 12829 '㈝' 12830 '㈞' 12910 '㉮' 12911 '㉯' 12912 '㉰' 12913 '㉱' 12914 '㉲' 12915 '㉳' 12916 '㉴' 12917 '㉵' 12918 '㉶' 12919 '㉷' 12920 '㉸' 12921 '㉹' 12922 '㉺' 12923 '㉻' 12924 '㉼' 12925 '㉽' 12926 '㉾' 13056 '㌀' 13058 '㌂' 13060 '㌄' 13063 '㌇' 13070 '㌎' 13071 '㌏' 13072 '㌐' 13073 '㌑' 13075 '㌓' 13077 '㌕' 13080 '㌘' 13081 '㌙' 13082 '㌚' 13086 '㌞' 13089 '㌡' 13092 '㌤' 13093 '㌥' 13094 '㌦' 13099 '㌫' 13100 '㌬' 13101 '㌭' 13102 '㌮' 13103 '㌯' 13104 '㌰' 13105 '㌱' 13106 '㌲' 13108 '㌴' 13111 '㌷' 13112 '㌸' 13114 '㌺' 13115 '㌻' 13116 '㌼' 13117 '㌽' 13118 '㌾' 13120 '㍀' 13130 '㍊' 13131 '㍋' 13132 '㍌' 13134 '㍎' 13139 '㍓' 13140 '㍔' 13142 '㍖' .......... ﺋ' 65164 'ﺌ' 65269 'ﻵ' 65270 'ﻶ' 65271 'ﻷ' 65272 'ﻸ' 65273 'ﻹ' 65274'
• Es gibt einige Charaktere, die nicht normalisiert werden können. Sie werfen, ArgumentExceptionwenn sie es versuchen
  Total:2081 Characters(int value): 55296-57343, 64976-65007, 65534

Diese Links können sehr hilfreich sein, um zu verstehen, welche Regeln für die Unicode-Äquivalenz gelten

1. Unicode_Equivalenz
2. Unicode_Kompatibilitätszeichen

Höchstwahrscheinlich gibt es zwei verschiedene Zeichencodes, die (sichtbar) dasselbe Zeichen bilden. Obwohl sie technisch nicht gleich sind, sehen sie gleich aus. Schauen Sie sich die Zeichentabelle an und prüfen Sie, ob es mehrere Instanzen dieses Zeichens gibt. Oder drucken Sie den Zeichencode der beiden Zeichen in Ihrem Code aus.

Sie fragen "wie man sie vergleicht", sagen uns aber nicht, was Sie tun möchten.

Es gibt mindestens zwei Möglichkeiten, sie zu vergleichen:

Entweder Sie vergleichen sie direkt so wie Sie sind und sie sind unterschiedlich

Oder Sie verwenden die Unicode-Kompatibilitätsnormalisierung, wenn Sie einen Vergleich benötigen, der übereinstimmt.

Es könnte jedoch ein Problem geben, da durch die Normalisierung der Unicode-Kompatibilität viele andere Zeichen gleich verglichen werden. Wenn Sie möchten, dass nur diese beiden Zeichen gleich behandelt werden, sollten Sie Ihre eigenen Normalisierungs- oder Vergleichsfunktionen ausführen.

Für eine spezifischere Lösung müssen wir Ihr spezifisches Problem kennen. In welchem ​​Kontext sind Sie auf dieses Problem gestoßen?

Wenn ich pedantisch sein möchte, würde ich sagen, dass Ihre Frage keinen Sinn ergibt, aber da wir uns Weihnachten nähern und die Vögel singen, werde ich damit fortfahren.

Zunächst einmal, die 2 Einheiten , die Sie vergleichen versuchen , sind glyphs, eine Glyphe Teil einer Reihe von Glyphen durch das, was vorgesehen ist , in der Regel wissen , als „font“, die Sache , die in der Regel in eine kommt ttf, otfoder was auch immer Dateiformat Sie sind mit.

Die Glyphen sind eine Darstellung eines bestimmten Symbols, und da es sich um eine Darstellung handelt, die von einer bestimmten Menge abhängt, können Sie nicht einfach zwei ähnliche oder sogar "bessere" identische Symbole erwarten. Diese Phrase ist nicht sinnvoll Wenn Sie den Kontext berücksichtigen, sollten Sie zumindest angeben, welche Schriftart oder welchen Satz von Glyphen Sie bei der Formulierung einer solchen Frage berücksichtigen.

Was normalerweise verwendet wird, um ein Problem zu lösen, das demjenigen ähnelt, auf das Sie stoßen, ist eine OCR, im Wesentlichen eine Software, die Glyphen erkennt und vergleicht, wenn C # eine OCR bereitstellt standardmäßig weiß ich das nicht, aber es ist im Allgemeinen eine wirklich schlechte Idee, wenn Sie keine OCR wirklich brauchen und wissen, was Sie damit machen sollen.

Möglicherweise interpretieren Sie ein Physikbuch als ein altes griechisches Buch, ohne die Tatsache zu erwähnen, dass OCR im Allgemeinen ressourcenintensiv sind.

Es gibt einen Grund, warum diese Zeichen so lokalisiert sind, wie sie lokalisiert sind. Tun Sie das einfach nicht.

Mit der DrawStringMethode können beide Zeichen mit demselben Schriftstil und derselben Schriftgröße gezeichnet werden. Nachdem zwei Bitmaps mit Symbolen generiert wurden, können diese Pixel für Pixel verglichen werden.

Vorteil dieser Methode ist, dass Sie nicht nur absolut gleiche Zeichen vergleichen können, sondern auch ähnliche (mit definitiver Toleranz).