Lire en anglais

Partager via


String.Normalize Méthode

Définition

Retourne une nouvelle chaîne dont la représentation binaire se trouve dans un formulaire particulier de normalisation Unicode.

Surcharges

Normalize()

Retourne une nouvelle chaîne dont la valeur textuelle est identique à celle de cette chaîne, mais dont la représentation binaire se trouve dans un formulaire de normalisation C Unicode.

Normalize(NormalizationForm)

Retourne une nouvelle chaîne dont la valeur textuelle est identique à celle de cette chaîne, mais dont la représentation binaire se trouve dans le formulaire de normalisation Unicode spécifié.

Exemples

L’exemple suivant normalise une chaîne à chacun des quatre formulaires de normalisation, confirme que la chaîne a été normalisée au formulaire de normalisation spécifié, puis répertorie les points de code dans la chaîne normalisée.

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

*/

Normalize()

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

Retourne une nouvelle chaîne dont la valeur textuelle est identique à celle de cette chaîne, mais dont la représentation binaire se trouve dans un formulaire de normalisation C Unicode.

public string Normalize ();

Retours

Nouvelle chaîne normalisée dont la valeur textuelle est identique à celle de cette chaîne, mais dont la représentation binaire se trouve dans un formulaire de normalisation C Unicode.

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. Par exemple, l’un des points de code suivants peut représenter la lettre « ắ » :

  • U+1EAF

  • U+0103 U+0301

  • U+0061 U+0306 U+0301

L’existence de plusieurs représentations pour un seul caractère complique la recherche, le tri, la mise en correspondance et d’autres opérations.

La norme Unicode définit un processus appelé normalisation qui retourne une représentation binaire lorsque l’une des représentations binaires équivalentes d’un caractère est donnée. La normalisation peut être effectuée avec plusieurs algorithmes, appelés formulaires de normalisation, qui obéissent à différentes règles. .NET prend en charge les quatre formes de normalisation (C, D, KC et KD) définies par la norme Unicode. Lorsque deux chaînes sont représentées dans la même forme de normalisation, elles peuvent être comparées à l’aide de la comparaison ordinale.

Pour normaliser et comparer deux chaînes, procédez comme suit :

  1. Obtenez les chaînes à comparer à partir d’une source d’entrée, telle qu’un fichier ou un périphérique d’entrée utilisateur.

  2. Appelez la Normalize() méthode pour normaliser les chaînes au format de normalisation C.

  3. Pour comparer deux chaînes, appelez une méthode qui prend en charge la comparaison de chaînes ordinales, telle que la Compare(String, String, StringComparison) méthode, et fournissez une valeur de StringComparison.Ordinal ou StringComparison.OrdinalIgnoreCase comme StringComparison argument. Pour trier un tableau de chaînes normalisées, passez une comparer valeur de StringComparer.Ordinal ou StringComparer.OrdinalIgnoreCase à une surcharge appropriée de Array.Sort.

  4. Émettez les chaînes dans la sortie triée en fonction de l’ordre indiqué par l’étape précédente.

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 que IsNormalized retourne false.

Voir aussi

S’applique à

.NET 9 et autres versions
Produit Versions
.NET Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 2.0, 2.1

Normalize(NormalizationForm)

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

Retourne une nouvelle chaîne dont la valeur textuelle est identique à celle de cette chaîne, mais dont la représentation binaire se trouve dans le formulaire de normalisation Unicode spécifié.

public string Normalize (System.Text.NormalizationForm normalizationForm);

Paramètres

normalizationForm
NormalizationForm

Formulaire de normalisation Unicode.

Retours

Nouvelle chaîne dont la valeur textuelle est identique à celle de cette chaîne, mais dont la représentation binaire se trouve dans le formulaire de normalisation spécifié par le paramètre normalizationForm.

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 mise en correspondance et d’autres opérations.

La norme Unicode définit un processus appelé normalisation qui retourne une représentation binaire lorsque l’une des représentations binaires équivalentes d’un caractère est donnée. La normalisation peut être effectuée avec plusieurs algorithmes, appelés formulaires de normalisation, qui obéissent à différentes règles. .NET prend en charge les quatre formes de normalisation (C, D, KC et KD) définies par la norme Unicode. Lorsque deux chaînes sont représentées dans la même forme de normalisation, elles peuvent être comparées à l’aide de la comparaison ordinale.

Pour normaliser et comparer deux chaînes, procédez comme suit :

  1. Obtenez les chaînes à comparer à partir d’une source d’entrée, telle qu’un fichier ou un périphérique d’entrée utilisateur.

  2. Appelez la Normalize(NormalizationForm) méthode pour normaliser les chaînes à un formulaire de normalisation spécifié.

  3. Pour comparer deux chaînes, appelez une méthode qui prend en charge la comparaison de chaînes ordinales, telle que la Compare(String, String, StringComparison) méthode, et fournissez une valeur de StringComparison.Ordinal ou StringComparison.OrdinalIgnoreCase comme StringComparison argument. Pour trier un tableau de chaînes normalisées, passez une comparer valeur de StringComparer.Ordinal ou StringComparer.OrdinalIgnoreCase à une surcharge appropriée de Array.Sort.

  4. Émettez les chaînes dans la sortie triée en fonction de l’ordre indiqué par l’étape précédente.

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 peut lever un ArgumentException bien que IsNormalized retourne false.

Voir aussi

S’applique à

.NET 9 et autres versions
Produit Versions
.NET Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 2.0, 2.1