String.Normalize Methode

Definitie

Naamruimte:: System

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Retourneert een nieuwe tekenreeks waarvan de binaire weergave een bepaalde Unicode-normalisatievorm heeft.

Overloads

Name	Description
Normalize()	Retourneert een nieuwe tekenreeks waarvan de tekstwaarde hetzelfde is als deze tekenreeks, maar waarvan de binaire weergave zich in Unicode-normalisatievorm C bevindt.
Normalize(NormalizationForm)	Retourneert een nieuwe tekenreeks waarvan de tekstwaarde hetzelfde is als deze tekenreeks, maar waarvan de binaire weergave zich in de opgegeven Unicode-normalisatievorm bevindt.

Voorbeelden

In het volgende voorbeeld wordt een tekenreeks genormaliseerd naar elk van de vier normalisatieformulieren, wordt bevestigd dat de tekenreeks is genormaliseerd in het opgegeven normalisatieformulier en worden de codepunten in de genormaliseerde tekenreeks weergegeven.

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

Retourneert een nieuwe tekenreeks waarvan de tekstwaarde hetzelfde is als deze tekenreeks, maar waarvan de binaire weergave zich in Unicode-normalisatievorm C bevindt.

public:
 System::String ^ Normalize();

public string Normalize();

member this.Normalize : unit -> string

Public Function Normalize () As String

Retouren

String

Een nieuwe, genormaliseerde tekenreeks waarvan de tekstwaarde hetzelfde is als deze tekenreeks, maar waarvan de binaire weergave zich in normalisatievorm C bevindt.

Uitzonderingen

ArgumentException

Het huidige exemplaar bevat ongeldige Unicode-tekens.

Opmerkingen

Sommige Unicode-tekens hebben meerdere equivalente binaire weergaven die bestaan uit sets combinaties en/of samengestelde Unicode-tekens. Een van de volgende codepunten kan bijvoorbeeld de letter 'ắ' vertegenwoordigen:

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

Het bestaan van meerdere representaties voor één teken maakt het zoeken, sorteren, vergelijken en andere bewerkingen ingewikkeld.

De Unicode-standaard definieert een proces met de naam normalisatie dat één binaire weergave retourneert wanneer een van de equivalente binaire representaties van een teken wordt gegeven. Normalisatie kan worden uitgevoerd met verschillende algoritmen, normalisatievormen genoemd, die verschillende regels volgen. .NET ondersteunt de vier normalisatievormen (C, D, KC en KD) die zijn gedefinieerd door de Unicode-standaard. Wanneer twee tekenreeksen in dezelfde normalisatievorm worden weergegeven, kunnen ze worden vergeleken met behulp van een rangtelvergelijking.

Ga als volgt te werk om twee tekenreeksen te normaliseren en te vergelijken:

Haal de tekenreeksen op die moeten worden vergeleken vanuit een invoerbron, zoals een bestand of een apparaat voor gebruikersinvoer.
Roep de Normalize() methode aan om de tekenreeksen te normaliseren naar normalisatieformulier C.
Als u twee tekenreeksen wilt vergelijken, roept u een methode aan die ondersteuning biedt voor rangtelreeksvergelijking, zoals de Compare(String, String, StringComparison) methode, en geeft u een waarde van StringComparison.Ordinal of StringComparison.OrdinalIgnoreCase als argument StringComparison op. Als u een matrix van genormaliseerde tekenreeksen wilt sorteren, geeft u een comparer waarde van StringComparer.Ordinal of StringComparer.OrdinalIgnoreCase aan een juiste overbelasting van Array.Sort.
De tekenreeksen verzenden in de gesorteerde uitvoer op basis van de volgorde die in de vorige stap is aangegeven.

Zie voor een beschrijving van ondersteunde Unicode-normalisatieformulieren System.Text.NormalizationForm.

Notities voor bellers

De IsNormalized methode retourneert false zodra het eerste niet-genormaliseerde teken in een tekenreeks tegenkomt. Als een tekenreeks dus niet-genormaliseerde tekens bevat, gevolgd door ongeldige Unicode-tekens, genereert de Normalize methode een ArgumentException hoewel IsNormalized retourneert false.

Zie ook

IsNormalized()

Van toepassing op

Normalize(NormalizationForm)

Retourneert een nieuwe tekenreeks waarvan de tekstwaarde hetzelfde is als deze tekenreeks, maar waarvan de binaire weergave zich in de opgegeven Unicode-normalisatievorm bevindt.

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

Parameters

normalizationForm: NormalizationForm

Een Unicode-normalisatieformulier.

Retouren

String

Een nieuwe tekenreeks waarvan de tekstuele waarde hetzelfde is als deze tekenreeks, maar waarvan de binaire weergave zich in de normalisatievorm bevindt die is opgegeven door de normalizationForm parameter.

Uitzonderingen

ArgumentException

Het huidige exemplaar bevat ongeldige Unicode-tekens.

Opmerkingen

Sommige Unicode-tekens hebben meerdere equivalente binaire weergaven die bestaan uit sets combinaties en/of samengestelde Unicode-tekens. Het bestaan van meerdere representaties voor één teken maakt het zoeken, sorteren, vergelijken en andere bewerkingen ingewikkeld.

Ga als volgt te werk om twee tekenreeksen te normaliseren en te vergelijken:

Haal de tekenreeksen op die moeten worden vergeleken vanuit een invoerbron, zoals een bestand of een apparaat voor gebruikersinvoer.
Roep de Normalize(NormalizationForm) methode aan om de tekenreeksen te normaliseren naar een opgegeven normalisatieformulier.
Als u twee tekenreeksen wilt vergelijken, roept u een methode aan die ondersteuning biedt voor rangtelreeksvergelijking, zoals de Compare(String, String, StringComparison) methode, en geeft u een waarde van StringComparison.Ordinal of StringComparison.OrdinalIgnoreCase als argument StringComparison op. Als u een matrix van genormaliseerde tekenreeksen wilt sorteren, geeft u een comparer waarde van StringComparer.Ordinal of StringComparer.OrdinalIgnoreCase aan een juiste overbelasting van Array.Sort.
De tekenreeksen verzenden in de gesorteerde uitvoer op basis van de volgorde die in de vorige stap is aangegeven.

Zie voor een beschrijving van ondersteunde Unicode-normalisatieformulieren System.Text.NormalizationForm.

Notities voor bellers

De IsNormalized methode retourneert false zodra het eerste niet-genormaliseerde teken in een tekenreeks tegenkomt. Als een tekenreeks dus niet-genormaliseerde tekens bevat, gevolgd door ongeldige Unicode-tekens, kan de Normalize methode een ArgumentException hoewel IsNormalized geretourneerde falsemethode genereren.

Zie ook

IsNormalized()

Van toepassing op

Feedback

Is deze pagina nuttig?