String.Normalize Metódus

Definíció

Névtér:: System

Szerelvény:: mscorlib.dll

Szerelvény:: netstandard.dll

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Egy új sztringet ad vissza, amelynek bináris ábrázolása egy adott Unicode-normalizálási formában van.

Túlterhelések

Name	Description
Normalize()	Egy új sztringet ad vissza, amelynek szöveges értéke megegyezik ezzel a sztringgel, de amelynek bináris ábrázolása Unicode normalizálási formában C.
Normalize(NormalizationForm)	Egy új sztringet ad vissza, amelynek szöveges értéke megegyezik ezzel a sztringgel, de amelynek bináris ábrázolása a megadott Unicode normalizálási formában van.

Példák

Az alábbi példa normalizál egy sztringet mind a négy normalizálási űrlapra, megerősíti, hogy a sztring a megadott normalizálási űrlapra lett normalizálva, majd felsorolja a normalizált sztring kódpontjait.

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

Egy új sztringet ad vissza, amelynek szöveges értéke megegyezik ezzel a sztringgel, de amelynek bináris ábrázolása Unicode normalizálási formában C.

public:
 System::String ^ Normalize();

public string Normalize();

member this.Normalize : unit -> string

Public Function Normalize () As String

Válaszok

String

Egy új, normalizált sztring, amelynek szöveges értéke megegyezik ezzel a sztringgel, de bináris ábrázolása normalizálási formában C.

Kivételek

ArgumentException

Az aktuális példány érvénytelen Unicode-karaktereket tartalmaz.

Megjegyzések

Egyes Unicode-karakterek több egyenértékű bináris reprezentációval rendelkeznek, amelyek egyesítő és/vagy összetett Unicode-karakterekből állnak. Az alábbi kódpontok bármelyike például a "ắ" betűt jelölheti:

U+1EAF
U+0103 U+0301
U+0061 U+0306 U+0301

Ha egyetlen karakterhez több reprezentáció is létezik, az bonyolítja a keresést, a rendezést, az egyeztetést és az egyéb műveleteket.

A Unicode-szabvány egy normalizálás nevű folyamatot határoz meg, amely egy bináris reprezentációt ad vissza, ha egy karakter azonos bináris reprezentációit adja vissza. A normalizálás több algoritmussal, úgynevezett normalizálási űrlapokkal is elvégezhető, amelyek különböző szabályokat követnek. .NET támogatja a Unicode szabvány által definiált négy normalizálási űrlapot (C, D, KC és KD). Ha két sztring ugyanabban a normalizálási formában jelenik meg, azokat sorszámos összehasonlítással lehet összehasonlítani.

Két sztring normalizálásához és összehasonlításához tegye a következőket:

Szerezze be az összehasonlítandó sztringeket egy bemeneti forrásból, például egy fájlból vagy egy felhasználói beviteli eszközből.
A sztringek normalizálásához hívja meg a Normalize() metódust a C normalizálási formára.
Két sztring összehasonlításához hívjon meg egy metódust, amely támogatja az ordinális sztringek összehasonlítását, például a Compare(String, String, StringComparison) metódust, és adjon meg egy értéket StringComparison.Ordinal vagy StringComparison.OrdinalIgnoreCase argumentumot StringComparison . Normalizált sztringek tömbjének rendezéséhez adja át comparer a megfelelő túlterhelés értékét StringComparer.Ordinal vagy StringComparer.OrdinalIgnoreCase túlterhelését Array.Sort.
Adja ki a sztringeket a rendezett kimenetben az előző lépésben megadott sorrend alapján.

A támogatott Unicode-normalizálási űrlapok leírását lásd: System.Text.NormalizationForm.

Megjegyzések a hívókhoz

A IsNormalized metódus azonnal visszatér false , amint egy sztring első nem normalizált karakterével találkozik. Ezért ha egy sztring nem normalizált karaktereket, majd érvénytelen Unicode-karaktereket tartalmaz, a Normalize metódus egy bárt IsNormalized ad ArgumentException visszafalse.

Lásd még

IsNormalized()

A következőre érvényes:

Normalize(NormalizationForm)

Egy új sztringet ad vissza, amelynek szöveges értéke megegyezik ezzel a sztringgel, de amelynek bináris ábrázolása a megadott Unicode normalizálási formában van.

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

Paraméterek

normalizationForm: NormalizationForm

Unicode-normalizálási űrlap.

Válaszok

String

Új sztring, amelynek szöveges értéke megegyezik ezzel a sztringgel, de bináris ábrázolása a normalizationForm paraméter által megadott normalizálási formában van.

Kivételek

ArgumentException

Az aktuális példány érvénytelen Unicode-karaktereket tartalmaz.

Megjegyzések

Egyes Unicode-karakterek több egyenértékű bináris reprezentációval rendelkeznek, amelyek egyesítő és/vagy összetett Unicode-karakterekből állnak. Ha egyetlen karakterhez több reprezentáció is létezik, az bonyolítja a keresést, a rendezést, az egyeztetést és az egyéb műveleteket.

Két sztring normalizálásához és összehasonlításához tegye a következőket:

Szerezze be az összehasonlítandó sztringeket egy bemeneti forrásból, például egy fájlból vagy egy felhasználói beviteli eszközből.
Hívja meg a Normalize(NormalizationForm) metódust, hogy normalizálja a sztringeket egy megadott normalizálási űrlapra.
Két sztring összehasonlításához hívjon meg egy metódust, amely támogatja az ordinális sztringek összehasonlítását, például a Compare(String, String, StringComparison) metódust, és adjon meg egy értéket StringComparison.Ordinal vagy StringComparison.OrdinalIgnoreCase argumentumot StringComparison . Normalizált sztringek tömbjének rendezéséhez adja át comparer a megfelelő túlterhelés értékét StringComparer.Ordinal vagy StringComparer.OrdinalIgnoreCase túlterhelését Array.Sort.
Adja ki a sztringeket a rendezett kimenetben az előző lépésben megadott sorrend alapján.

A támogatott Unicode-normalizálási űrlapok leírását lásd: System.Text.NormalizationForm.

Megjegyzések a hívókhoz

A IsNormalized metódus azonnal visszatér false , amint egy sztring első nem normalizált karakterével találkozik. Ezért ha egy sztring nem normalizált karaktereket, majd érvénytelen Unicode-karaktereket tartalmaz, a metódus ugyan visszaadja ArgumentException IsNormalized a Normalize függvénytfalse.

Lásd még

IsNormalized()

A következőre érvényes:

Visszajelzés

Hasznosnak találta ezt az oldalt?