Partage via


String.IsNormalized Méthode

Définition

Indique si cette chaîne figure dans un formulaire particulier de normalisation Unicode.

Surcharges

IsNormalized()

Indique si cette chaîne se trouve dans un formulaire de normalisation C Unicode.

IsNormalized(NormalizationForm)

Indique si cette chaîne figure dans le formulaire de normalisation Unicode spécifié.

Exemples

L’exemple suivant détermine si une chaîne est correctement normalisée dans différents formulaires de normalisation.

using namespace System;
using namespace System::Text;

void Show( String^ title, String^ s )
{
   Console::Write( "Characters in string {0} = ", title );
   for each (short x in s) {
      Console::Write("{0:X4} ", x);
   }
   Console::WriteLine();
}

int main()
{
   
   // Character c; combining characters acute and cedilla; character 3/4
   array<Char>^temp0 = {L'c',L'\u0301',L'\u0327',L'\u00BE'};
   String^ s1 = gcnew String( temp0 );
   String^ s2 = nullptr;
   String^ divider = gcnew 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();
}

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

*/
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
'

IsNormalized()

Source:
String.cs
Source:
String.cs
Source:
String.cs

Indique si cette chaîne se trouve dans un formulaire de normalisation C Unicode.

public:
 bool IsNormalized();
public bool IsNormalized ();
member this.IsNormalized : unit -> bool
Public Function IsNormalized () As Boolean

Retours

true si cette chaîne figure dans un formulaire de normalisation C ; sinon, false.

Exceptions

L’instance actuelle contient des caractères Unicode non valides.

Remarques

Certains caractères Unicode ont plusieurs représentations binaires équivalentes composées d’ensembles de caractères Unicode combinés et/ou composites. L’existence de plusieurs représentations pour un seul caractère complique la recherche, le tri, la correspondance et d’autres opérations.

La norme Unicode définit un processus appelé normalisation qui retourne une représentation binaire lorsqu’elle est donnée à l’une des représentations binaires équivalentes d’un caractère. La normalisation peut être effectuée avec plusieurs algorithmes, appelés formulaires de normalisation, qui obéissent à différentes règles. .NET prend actuellement en charge les formulaires de normalisation C, D, KC et KD.

Pour obtenir une description des formulaires de normalisation Unicode pris en charge, consultez System.Text.NormalizationForm.

Notes pour les appelants

La IsNormalized méthode retourne false dès qu’elle rencontre le premier caractère non normalisé d’une chaîne. Par conséquent, si une chaîne contient des caractères non normalisés suivis de caractères Unicode non valides, la Normalize méthode lève un ArgumentException bien retourne IsNormalizedfalse.

Voir aussi

S’applique à

IsNormalized(NormalizationForm)

Source:
String.cs
Source:
String.cs
Source:
String.cs

Indique si cette chaîne figure dans le formulaire de normalisation Unicode spécifié.

public:
 bool IsNormalized(System::Text::NormalizationForm normalizationForm);
public bool IsNormalized (System.Text.NormalizationForm normalizationForm);
member this.IsNormalized : System.Text.NormalizationForm -> bool
Public Function IsNormalized (normalizationForm As NormalizationForm) As Boolean

Paramètres

normalizationForm
NormalizationForm

Formulaire de normalisation Unicode.

Retours

true si cette chaîne se trouve dans le formulaire de normalisation spécifié par le paramètre normalizationForm ; sinon, false.

Exceptions

L’instance actuelle contient des caractères Unicode non valides.

Remarques

Certains caractères Unicode ont plusieurs représentations binaires équivalentes composées d’ensembles de caractères Unicode combinés et/ou composites. L’existence de plusieurs représentations pour un seul caractère complique la recherche, le tri, la correspondance et d’autres opérations.

La norme Unicode définit un processus appelé normalisation qui retourne une représentation binaire lorsqu’elle est donnée à l’une des représentations binaires équivalentes d’un caractère. La normalisation peut être effectuée avec plusieurs algorithmes, appelés formulaires de normalisation, qui obéissent à différentes règles. .NET prend actuellement en charge les formulaires de normalisation C, D, KC et KD.

Pour obtenir une description des formulaires de normalisation Unicode pris en charge, consultez System.Text.NormalizationForm.

Notes pour les appelants

La IsNormalized méthode retourne false dès qu’elle rencontre le premier caractère non normalisé d’une chaîne. Par conséquent, si une chaîne contient des caractères non normalisés suivis de caractères Unicode non valides, la Normalize méthode lève un ArgumentException bien retourne IsNormalizedfalse.

Voir aussi

S’applique à