String.Normalize Metoda

Definice

Obor názvů:
System
Sestavení:
netstandard.dll, System.Runtime.dll
Sestavení:
System.Runtime.dll
Sestavení:
mscorlib.dll
Sestavení:
netstandard.dll

Vrátí nový řetězec, jehož binární reprezentace je v určité formě normalizace Unicode.

Přetížení

Name Description
Normalize()

Vrátí nový řetězec, jehož textová hodnota je stejná jako tento řetězec, ale jehož binární reprezentace je ve formátu normalizace Unicode C.
Normalize(NormalizationForm)

Vrátí nový řetězec, jehož textová hodnota je stejná jako tento řetězec, ale jehož binární reprezentace je v zadaném formátu normalizace Unicode.

Příklady

Následující příklad normalizuje řetězec na každý ze čtyř formulářů normalizace, potvrdí, že byl řetězec normalizován do zadaného formuláře normalizace a potom vypíše body kódu v normalizovaném řetězci.

using System;
using System.Text;

class Example
{
    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);

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

    private static void Show(string title, string s)
    {
       Console.Write("Characters in string {0} = ", title);
       foreach(short x in s) {
           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

*/

open System
open System.Text

let show title (s: string) =
    printf $"Characters in string %s{title} = "
    for x in s do
        printf $"{int16 x:X4} "
    printfn ""


[<EntryPoint>]
let main _ =
    // Character c; combining characters acute and cedilla; character 3/4
    let s1 = String [| '\u0063'; '\u0301'; '\u0327'; '\u00BE' |]
    let divider = String('-', 80)
    let divider = String.Concat(Environment.NewLine, divider, Environment.NewLine)

    show "s1" s1
    printfn "\nU+0063 = LATIN SMALL LETTER C"
    printfn "U+0301 = COMBINING ACUTE ACCENT"
    printfn "U+0327 = COMBINING CEDILLA"
    printfn "U+00BE = VULGAR FRACTION THREE QUARTERS"
    printfn $"{divider}"

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

    printfn $"{divider}"

    printfn "Set string s2 to each normalized form of string s1.\n"
    printfn "U+1E09 = LATIN SMALL LETTER C WITH CEDILLA AND ACUTE"
    printfn"U+0033 = DIGIT THREE"
    printfn"U+2044 = FRACTION SLASH"
    printfn"U+0034 = DIGIT FOUR"
    printfn $"{divider}"
 
    let s2 = s1.Normalize()
    printf "B1) Is s2 normalized to the default form (Form C)?: "
    printfn $"{s2.IsNormalized()}"
    show "s2" s2
    printfn ""

    let s2 = s1.Normalize NormalizationForm.FormC
    printf "B2) Is s2 normalized to Form C?: "
    printfn $"{s2.IsNormalized NormalizationForm.FormC}"
    show "s2" s2
    printfn ""

    let s2 = s1.Normalize NormalizationForm.FormD
    printf "B3) Is s2 normalized to Form D?: "
    printfn $"{s2.IsNormalized NormalizationForm.FormD}"
    show "s2" s2
    printfn ""

    let s2 = s1.Normalize(NormalizationForm.FormKC)
    printf "B4) Is s2 normalized to Form KC?: "
    printfn $"{s2.IsNormalized NormalizationForm.FormKC}"
    show "s2" s2
    printfn ""

    let s2 = s1.Normalize(NormalizationForm.FormKD)
    printf "B5) Is s2 normalized to Form KD?: "
    printfn $"{s2.IsNormalized NormalizationForm.FormKD}"
    show "s2" s2
    0

(*
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

*)

Imports System.Text

Class Example
   Public Shared Sub Main()
      ' Character c; combining characters acute and cedilla; character 3/4
      Dim s1 = New [String](New Char() {ChrW(&H0063), ChrW(&H0301), ChrW(&H0327), ChrW(&H00BE)})
      Dim s2 As String = Nothing
      Dim divider = New [String]("-"c, 80)
      divider = [String].Concat(Environment.NewLine, divider, Environment.NewLine)
      
      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()
   End Sub 
   
   Private Shared Sub Show(title As String, s As String)
      Console.Write("Characters in string {0} = ", title)
      For Each x As Char In s
         Console.Write("{0:X4} ", AscW(x))
      Next 
      Console.WriteLine()
   End Sub 
End Class 
'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
'

Normalize()

Zdroj:
String.cs
Zdroj:
String.cs
Zdroj:
String.cs
Zdroj:
String.cs
Zdroj:
String.cs

Vrátí nový řetězec, jehož textová hodnota je stejná jako tento řetězec, ale jehož binární reprezentace je ve formátu normalizace Unicode C.

public:
 System::String ^ Normalize();
public string Normalize();
member this.Normalize : unit -> string
Public Function Normalize () As String

Návraty

String

Nový normalizovaný řetězec, jehož textová hodnota je stejná jako tento řetězec, ale jehož binární reprezentace je ve formě normalizace C.

Výjimky

ArgumentException

Aktuální instance obsahuje neplatné znaky Unicode.

Poznámky

Některé znaky Unicode mají několik ekvivalentních binárních reprezentací, které se skládají ze sad kombinování a/nebo složených znaků Unicode. Například jakýkoli z následujících bodů kódu může představovat písmeno "ắ":

  • U+1EAF

  • U+0103 U+0301

  • U+0061 U+0306 U+0301

Existence více reprezentací jednoho znaku komplikuje vyhledávání, řazení, porovnávání a další operace.

Standard Unicode definuje proces označovaný jako normalizace, který vrací jednu binární reprezentaci, pokud je zadána jakákoli z ekvivalentních binárních reprezentací znaku. Normalizaci lze provádět s několika algoritmy, označovanými jako normalizační formuláře, které dodržují různá pravidla. .NET podporuje čtyři formuláře normalizace (C, D, KC a KD), které jsou definované standardem Unicode. Pokud jsou dva řetězce reprezentovány ve stejné normalizační formě, lze je porovnat pomocí řadového porovnání.

Pokud chcete normalizovat a porovnat dva řetězce, postupujte takto:

  1. Získejte řetězce, které se mají porovnat ze vstupního zdroje, například ze souboru nebo ze vstupního zařízení uživatele.

  2. Normalize() Voláním metody normalizujete řetězce do normalizace formuláře C.

  3. Chcete-li porovnat dva řetězce, zavolejte metodu, která podporuje porovnání řadových řetězců, například metodu Compare(String, String, StringComparison) , a zadejte hodnotu StringComparison.Ordinal nebo StringComparison.OrdinalIgnoreCase jako StringComparison argument. Chcete-li seřadit pole normalizovaných řetězců, předejte comparer hodnotu StringComparer.Ordinal nebo StringComparer.OrdinalIgnoreCase příslušné přetížení Array.Sort.

  4. Vygenerujte řetězce v seřazeném výstupu podle pořadí uvedeného v předchozím kroku.

Popis podporovaných formulářů normalizace unicode naleznete v tématu System.Text.NormalizationForm.

Poznámky pro volající

Metoda IsNormalized se vrátí false , jakmile v řetězci narazí na první nenormalizovaný znak. Proto pokud řetězec obsahuje nenormalizované znaky následované neplatnými znaky Unicode, Normalize metoda vyvolá ArgumentException i když IsNormalized vrátí false.

Viz také

Platí pro

Normalize(NormalizationForm)

Zdroj:
String.cs
Zdroj:
String.cs
Zdroj:
String.cs
Zdroj:
String.cs
Zdroj:
String.cs

Vrátí nový řetězec, jehož textová hodnota je stejná jako tento řetězec, ale jehož binární reprezentace je v zadaném formátu normalizace Unicode.

public:
 System::String ^ Normalize(System::Text::NormalizationForm normalizationForm);
public string Normalize(System.Text.NormalizationForm normalizationForm);
member this.Normalize : System.Text.NormalizationForm -> string
Public Function Normalize (normalizationForm As NormalizationForm) As String

Parametry

normalizationForm
NormalizationForm

Formulář normalizace unicode.

Návraty

String

Nový řetězec, jehož textová hodnota je stejná jako tento řetězec, ale jehož binární reprezentace je ve formátu normalizace určeném parametrem normalizationForm .

Výjimky

ArgumentException

Aktuální instance obsahuje neplatné znaky Unicode.

Poznámky

Některé znaky Unicode mají několik ekvivalentních binárních reprezentací, které se skládají ze sad kombinování a/nebo složených znaků Unicode. Existence více reprezentací jednoho znaku komplikuje vyhledávání, řazení, porovnávání a další operace.

Standard Unicode definuje proces označovaný jako normalizace, který vrací jednu binární reprezentaci, pokud je zadána jakákoli z ekvivalentních binárních reprezentací znaku. Normalizaci lze provádět s několika algoritmy, označovanými jako normalizační formuláře, které dodržují různá pravidla. .NET podporuje čtyři formuláře normalizace (C, D, KC a KD), které jsou definované standardem Unicode. Pokud jsou dva řetězce reprezentovány ve stejné normalizační formě, lze je porovnat pomocí řadového porovnání.

Pokud chcete normalizovat a porovnat dva řetězce, postupujte takto:

  1. Získejte řetězce, které se mají porovnat ze vstupního zdroje, například ze souboru nebo ze vstupního zařízení uživatele.

  2. Normalize(NormalizationForm) Voláním metody normalizujete řetězce do zadaného formuláře normalizace.

  3. Chcete-li porovnat dva řetězce, zavolejte metodu, která podporuje porovnání řadových řetězců, například metodu Compare(String, String, StringComparison) , a zadejte hodnotu StringComparison.Ordinal nebo StringComparison.OrdinalIgnoreCase jako StringComparison argument. Chcete-li seřadit pole normalizovaných řetězců, předejte comparer hodnotu StringComparer.Ordinal nebo StringComparer.OrdinalIgnoreCase příslušné přetížení Array.Sort.

  4. Vygenerujte řetězce v seřazeném výstupu podle pořadí uvedeného v předchozím kroku.

Popis podporovaných formulářů normalizace unicode naleznete v tématu System.Text.NormalizationForm.

Poznámky pro volající

Metoda IsNormalized se vrátí false , jakmile v řetězci narazí na první nenormalizovaný znak. Proto pokud řetězec obsahuje nenormalizované znaky následované neplatnými znaky Unicode, Normalize metoda může vyvolat ArgumentException ačkoli IsNormalized vrátí false.

Viz také

Platí pro