Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original
Información
El tema que ha solicitado se muestra abajo. Sin embargo, este tema no se encuentra en la biblioteca.

String.Normalize (Método) (NormalizationForm)

Devuelve una nueva cadena cuyo valor textual es igual que esta cadena, pero cuya representación binaria tiene la forma de normalización Unicode especificada.

Espacio de nombres:  System
Ensamblado:  mscorlib (en mscorlib.dll)

public string Normalize(
	NormalizationForm normalizationForm
)

Parámetros

normalizationForm
Tipo: System.Text.NormalizationForm
Forma de normalización Unicode.

Valor devuelto

Tipo: System.String
Una nueva cadena cuyo valor textual es igual que esta cadena, pero cuya representación binaria tiene la forma de normalización especificada por el parámetro normalizationForm.

ExcepciónCondición
ArgumentException

La instancia actual contiene caracteres Unicode no válidos.

Algunos caracteres Unicode tienen múltiples representaciones binarias equivalentes, que consisten en conjuntos de caracteres Unicode combinables o compuestos. La existencia de varias representaciones de un único carácter complica la búsqueda, la ordenación, la comparación y otras operaciones.

El estándar Unicode define un proceso denominado normalización, que devuelve una representación binaria al proporcionar cualquiera de las representaciones binarias equivalentes de un carácter. La normalización puede realizarse con varios algoritmos, denominados formas de normalización, que cumplen reglas diferentes. .NET Framework admite los cuatro formas de normalización (C, d, kc, y depurador de kernel) definidos por el estándar Unicode. Cuando dos cadenas se representan en el mismo formulario de normalización, pueden compararse mediante la comparación ordinal.

Para normalizar y comparar dos cadenas, haga lo siguiente:

  1. Obtener las cadenas que se van a comparar de un origen de entrada, como un archivo o un dispositivo de datos proporcionados por el usuario.

  2. Llame al método de Normalize(NormalizationForm) para normalizar las cadenas en un formato especificado de normalización.

  3. Para comparar dos cadenas, llame a un método que admita la comparación de cadenas ordinal, como el método de Compare(String, String, StringComparison) , y proporcione un valor de StringComparison.Ordinal o de StringComparison.OrdinalIgnoreCase como argumento de StringComparison . Para ordenar una matriz de cadenas normalizadas, pase un valor de comparer de StringComparer.Ordinal o de StringComparer.OrdinalIgnoreCase a una sobrecarga adecuada de Array.Sort.

  4. Emita las cadenas en la salida ordenada basándose en el orden indicado por el paso anterior.

Para obtener una descripción de las formas de normalización Unicode compatibles, vea System.Text.NormalizationForm.

Notas para los llamadores

El método IsNormalized devuelve false en cuanto encuentre el primero carácter no normalizado en una cadena. Por consiguiente, si una cadena contiene caracteres no normalizados seguidos por caracteres Unicode no válidos, el método Normalize puede producir ArgumentException aunque IsNormalized devuelve false.

En el siguiente ejemplo se aplica a una cadena cada una de las cuatro formas de normalización, se confirma que se ha aplicado la forma de normalización especificada a la cadena y, a continuación, se muestran los puntos de código en la cadena normalizada.


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

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Compatible con: 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 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Adiciones de comunidad

Mostrar:
© 2015 Microsoft