Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo String::Normalize ()

 

Data di pubblicazione: ottobre 2016

Restituisce una nuova stringa il cui valore testuale è lo stesso di questa stringa ma la cui rappresentazione binaria è nel formato di normalizzazione Unicode C.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

public:
String^ Normalize()

Valore restituito

Type: System::String^

Nuova stringa normalizzata il cui valore testuale è lo stesso di questa stringa ma la cui rappresentazione binaria è nel formato di normalizzazione Unicode C.

Exception Condition
ArgumentException

L'istanza corrente contiene caratteri Unicode non validi.

Alcuni caratteri Unicode hanno più rappresentazioni binarie equivalenti formate da set di combinazione e/o i caratteri Unicode composti. Uno dei punti di codice seguente, ad esempio, può rappresentare la lettera "ắ":

  • U + 1EAF

  • U + 0103 U + 0301

  • U + 0061 U + 0306 U + 0301

L'esistenza di più rappresentazioni di un singolo carattere complica la ricerca, ordinamento, corrispondenza e altre operazioni.

Lo standard Unicode definisce un processo denominato normalizzazione che restituisce una rappresentazione binaria quando viene fornito qualsiasi rappresentazione binaria equivalente di un carattere. La normalizzazione può essere eseguita con diversi algoritmi, denominati normalizzazione, che sono conformi alle regole diverse. .NET Framework supporta quattro forme di normalizzazione (C, D, KC e KD) che sono definite dallo standard Unicode. Quando due stringhe sono rappresentate nello stesso formato di normalizzazione, theycan essere confrontati utilizzando il confronto ordinale.

Per normalizzare e confrontare due stringhe, eseguire le operazioni seguenti:

  1. Ottenere le stringhe da confrontare da un'origine di input, ad esempio un file o un dispositivo di input dell'utente.

  2. Chiamare il Normalize() metodo normalizzare le stringhe di formato di normalizzazione Unicode C.

  3. Per confrontare due stringhe, chiamare un metodo che supporta il confronto ordinale tra stringhe, ad esempio il Compare(String^, String^, StringComparison) (metodo), quindi specificare un valore di StringComparison::Ordinal o StringComparison::OrdinalIgnoreCasecome il StringComparison argomento. Per ordinare una matrice di stringhe normalizzate, passare un comparer valore StringComparer::Ordinal o StringComparer::OrdinalIgnoreCase a un overload appropriato del Array::Sort.

  4. Generare le stringhe nell'output ordinato in base all'ordine indicato nel passaggio precedente.

Per una descrizione dei formati di normalizzazione Unicode, vedere System.Text::NormalizationForm.

Note per i chiamanti:

Il IsNormalized restituisce false non appena viene rilevato il primo carattere non normalizzato in una stringa. Pertanto, se una stringa contiene caratteri non normalizzato seguiti da caratteri Unicode non validi, il Normalize metodo genererà un' ArgumentException Sebbene IsNormalized restituisce false.

Nell'esempio seguente una stringa in ognuno dei quattro normalizzazione Normalizza, conferma che la stringa di formato di normalizzazione specificato e quindi vengono elencati i punti di codice nella stringa normalizzata.

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

*/

.NET Framework
Disponibile da 2.0
Torna all'inizio
Mostra: