Informations
Le sujet que vous avez demandé est indiqué ci-dessous. Toutefois, ce sujet ne figure pas dans la bibliothèque.

String.Normalize, méthode (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é.

Espace de noms :  System
Assembly :  mscorlib (dans mscorlib.dll)

public string Normalize(
	NormalizationForm normalizationForm
)

Paramètres

normalizationForm
Type : System.Text.NormalizationForm
Formulaire de normalisation Unicode.

Valeur de retour

Type : System.String
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.

ExceptionCondition
ArgumentException

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

Certains caractères Unicode ont plusieurs représentations binaires équivalentes : des combinaisons de caractères Unicode ou des caractères Unicode composites. L'existence de plusieurs représentations pour un même caractère complique la recherche, le tri, la correspondance et autres opérations.

La norme Unicode définit un processus appelé normalisation qui retourne une représentation binaire lorsqu'une représentation binaire équivalente d'un caractère est donnée. La normalisation peut être effectuée avec plusieurs algorithmes, appelés formulaires de normalisation et régis par des règles différentes. Le .NET Framework prend en charge les trois formes de normalisation (C, D, KC, et KD) définies par les normes Unicode. Lorsque deux chaînes sont représentées avec le même formulaire de normalisation, elles peuvent être comparées à l'aide d'une comparaison ordinale.

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

  1. Récupérez les chaînes à comparer dans une source d'entrée telle qu'un fichier ou une entrée d'appareil.

  2. Appelez la méthode Normalize(NormalizationForm) pour normaliser les chaînes dans une forme standardisée.

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

  4. Émettez les chaînes dans la sortie triée selon l'ordre indiqué par l'étape précédente.

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

Remarques à l'attention des appelants

La méthode IsNormalized retourne la valeur false dès qu'elle rencontre le premier caractère non-normalisé dans 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 méthode Normalize peut provoquer un ArgumentException même si IsNormalized retourne la valeur false.

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


// This example demonstrates the String.Normalize method
//                       and the String.IsNormalized method

using System;
using System.Text;

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

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

    catch (Exception e) 
        {
        Console.WriteLine(e.Message);
        }
    }

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

*/


.NET Framework

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Ajouts de la communauté

Afficher:
© 2014 Microsoft