Windows Dev Center

Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original
Informationen
Das angeforderte Thema wird unten angezeigt. Es ist jedoch nicht in dieser Bibliothek vorhanden.

String.Normalize-Methode (NormalizationForm)

Gibt eine neue Zeichenfolge zurück, deren Textwert mit dieser Zeichenfolge übereinstimmt, deren binäre Darstellung jedoch in der angegebenen Unicode-Normalisierungsform vorliegt.

Namespace:  System
Assembly:  mscorlib (in mscorlib.dll)

public string Normalize(
	NormalizationForm normalizationForm
)

Parameter

normalizationForm
Typ: System.Text.NormalizationForm
Eine Unicode-Normalisierungsform.

Rückgabewert

Typ: System.String
Eine neue Zeichenfolge, deren Textwert mit dieser Zeichenfolge übereinstimmt, deren binäre Darstellung jedoch in der im normalizationForm-Parameter angegebenen Normalisierungsform vorliegt.

AusnahmeBedingung
ArgumentException

Die aktuelle Instanz enthält ungültige Unicodezeichen.

Einige Unicode-Zeichen haben mehrere entsprechende binäre Darstellungen, die aus Sätzen von verbindenden und/oder zusammengesetzten Unicode-Zeichen bestehen. Die Möglichkeit mehrerer Darstellungen für ein einzelnes Zeichen kompliziert das Suchen, Sortieren, Vergleichen und andere Operationen.

Im Unicode-Standard ist der so genannte Normalisierungsprozess definiert, durch den bei Eingabe einer der äquivalenten Binärdarstellungen eines Zeichens eine einzelne Binärdarstellung zurückgegeben wird. Die Normalisierung kann mit mehreren Algorithmen ausgeführt werden, den so genannten Normalisierungsformen, für die unterschiedlichen Regeln folgen. . .NET Framework unterstützt die vier Normalisierungsformen (C, D, KC und KD) die durch den Unicode-Standard definiert sind. Wenn zwei Zeichenfolgen in der gleichen Normalisierungsform dargestellt werden, können sie verglichen werden, indem Ordinalvergleich.

Um zwei Zeichenfolgen zu normalisieren und zu vergleichen, stellen Sie Folgendes:

  1. Sie benötigen die aus einer Eingabequelle ab, wie eine Datei oder einen Benutzereingabegerät verglichen werden Zeichenfolgen.

  2. Rufen Sie die Normalize(NormalizationForm)-Methode auf, um die Zeichenfolgen in einer Normalisierungsform angegebenen zu normalisieren.

  3. Um zwei Zeichenfolgen zu vergleichen, rufen Sie eine Methode auf die Zeichenfolgenvergleich nach Ordinalwerten, wie die Compare(String, String, StringComparison)-Methode unterstützt und einen Wert von StringComparison.Ordinal oder StringComparison.OrdinalIgnoreCase als Argument das StringComparison bereitstellt. Um normalisierte Zeichenfolgen ein Array zu sortieren, übergeben Sie einen comparer-Wert von StringComparer.Ordinal oder StringComparer.OrdinalIgnoreCase in eine entsprechende Überladung von Array.Sort.

  4. Geben Sie die Zeichenfolgen in der sortierten Ausgabe auf der Reihenfolge aus, die vom vorherigen Schritt angegeben wird.

Eine Beschreibung unterstützter Unicode-Normalisierungsformen finden Sie unter System.Text.NormalizationForm.

Hinweise zu Aufrufern

Die IsNormalized-Methode gibt false zurück, sobald das erste nicht normalisierte Zeichen in einer Zeichenfolge erkannt wird. Wenn daher eine Zeichenfolge nicht normalisierte Zeichen gefolgt von ungültigen Unicode-Zeichen enthält, löst die Normalize-Methode möglicherweise einen ArgumentException aus, obwohl IsNormalizedfalse zurückgibt.

Im folgenden Beispiel wird eine Zeichenfolge in jede der vier Normalisierungsformen normalisiert und die Normalisierung der Zeichenfolge in die angegebene Normalisierungsform bestätigt. Anschließend werden die Codepunkte in der normalisierten Zeichenfolge aufgeführt.


// This example demonstrates the String.Normalize method
//                       and the String.IsNormalized method

using System;
using System.Text;

class Sample 
{
    public static void Main() 
    {
// Character c; combining characters acute and cedilla; character 3/4
    string s1 = new String( new char[] {'\u0063', '\u0301', '\u0327', '\u00BE'});
    string s2 = null;
    string divider = new String('-', 80);
    divider = String.Concat(Environment.NewLine, divider, Environment.NewLine);

    try 
    {
    Show("s1", s1);
    Console.WriteLine();
    Console.WriteLine("U+0063 = LATIN SMALL LETTER C");
    Console.WriteLine("U+0301 = COMBINING ACUTE ACCENT");
    Console.WriteLine("U+0327 = COMBINING CEDILLA");
    Console.WriteLine("U+00BE = VULGAR FRACTION THREE QUARTERS");
    Console.WriteLine(divider);

    Console.WriteLine("A1) Is s1 normalized to the default form (Form C)?: {0}", 
                                 s1.IsNormalized());
    Console.WriteLine("A2) Is s1 normalized to Form C?:  {0}", 
                                 s1.IsNormalized(NormalizationForm.FormC));
    Console.WriteLine("A3) Is s1 normalized to Form D?:  {0}", 
                                 s1.IsNormalized(NormalizationForm.FormD));
    Console.WriteLine("A4) Is s1 normalized to Form KC?: {0}", 
                                 s1.IsNormalized(NormalizationForm.FormKC));
    Console.WriteLine("A5) Is s1 normalized to Form KD?: {0}", 
                                 s1.IsNormalized(NormalizationForm.FormKD));

    Console.WriteLine(divider);

    Console.WriteLine("Set string s2 to each normalized form of string s1.");
    Console.WriteLine();
    Console.WriteLine("U+1E09 = LATIN SMALL LETTER C WITH CEDILLA AND ACUTE");
    Console.WriteLine("U+0033 = DIGIT THREE");
    Console.WriteLine("U+2044 = FRACTION SLASH");
    Console.WriteLine("U+0034 = DIGIT FOUR");
    Console.WriteLine(divider);

    s2 = s1.Normalize();
    Console.Write("B1) Is s2 normalized to the default form (Form C)?: ");
    Console.WriteLine(s2.IsNormalized());
    Show("s2", s2);
    Console.WriteLine();

    s2 = s1.Normalize(NormalizationForm.FormC);
    Console.Write("B2) Is s2 normalized to Form C?: ");
    Console.WriteLine(s2.IsNormalized(NormalizationForm.FormC));
    Show("s2", s2);
    Console.WriteLine();

    s2 = s1.Normalize(NormalizationForm.FormD);
    Console.Write("B3) Is s2 normalized to Form D?: ");
    Console.WriteLine(s2.IsNormalized(NormalizationForm.FormD));
    Show("s2", s2);
    Console.WriteLine();

    s2 = s1.Normalize(NormalizationForm.FormKC);
    Console.Write("B4) Is s2 normalized to Form KC?: ");
    Console.WriteLine(s2.IsNormalized(NormalizationForm.FormKC));
    Show("s2", s2);
    Console.WriteLine();

    s2 = s1.Normalize(NormalizationForm.FormKD);
    Console.Write("B5) Is s2 normalized to Form KD?: ");
    Console.WriteLine(s2.IsNormalized(NormalizationForm.FormKD));
    Show("s2", s2);
    Console.WriteLine();
    }

    catch (Exception e) 
        {
        Console.WriteLine(e.Message);
        }
    }

    private static void Show(string title, string s)
    {
    Console.Write("Characters in string {0} = ", title);
    foreach(short x in s.ToCharArray())
        {
        Console.Write("{0:X4} ", x);
        }
    Console.WriteLine();
    }
}
/*
This example produces the following results:

Characters in string s1 = 0063 0301 0327 00BE

U+0063 = LATIN SMALL LETTER C
U+0301 = COMBINING ACUTE ACCENT
U+0327 = COMBINING CEDILLA
U+00BE = VULGAR FRACTION THREE QUARTERS

--------------------------------------------------------------------------------

A1) Is s1 normalized to the default form (Form C)?: False
A2) Is s1 normalized to Form C?:  False
A3) Is s1 normalized to Form D?:  False
A4) Is s1 normalized to Form KC?: False
A5) Is s1 normalized to Form KD?: False

--------------------------------------------------------------------------------

Set string s2 to each normalized form of string s1.

U+1E09 = LATIN SMALL LETTER C WITH CEDILLA AND ACUTE
U+0033 = DIGIT THREE
U+2044 = FRACTION SLASH
U+0034 = DIGIT FOUR

--------------------------------------------------------------------------------

B1) Is s2 normalized to the default form (Form C)?: True
Characters in string s2 = 1E09 00BE

B2) Is s2 normalized to Form C?: True
Characters in string s2 = 1E09 00BE

B3) Is s2 normalized to Form D?: True
Characters in string s2 = 0063 0327 0301 00BE

B4) Is s2 normalized to Form KC?: True
Characters in string s2 = 1E09 0033 2044 0034

B5) Is s2 normalized to Form KD?: True
Characters in string s2 = 0063 0327 0301 0033 2044 0034

*/


.NET Framework

Unterstützt in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Community-Beiträge

Anzeigen:
© 2015 Microsoft