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

Classe StringInfo

 

Fornisce funzionalità per suddividere una stringa in elementi di testo e per scorrere tali elementi di testo.

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

System.Object
  System.Globalization.StringInfo

[SerializableAttribute]
[ComVisibleAttribute(true)]
public class StringInfo

NomeDescrizione
System_CAPS_pubmethodStringInfo()

Inizializza una nuova istanza della classe StringInfo.

System_CAPS_pubmethodStringInfo(String)

Inizializza una nuova istanza della classe StringInfo su una stringa specificata.

NomeDescrizione
System_CAPS_pubpropertyLengthInTextElements

Ottiene il numero di elementi di testo nell'oggetto StringInfo corrente.

System_CAPS_pubpropertyString

Ottiene o imposta il valore dell'oggetto StringInfo corrente.

NomeDescrizione
System_CAPS_pubmethodEquals(Object)

Indica se l'oggetto StringInfo corrente è uguale a un oggetto specificato.(Esegue l'override di Object.Equals(Object).)

System_CAPS_protmethodFinalize()

Consente a un oggetto di provare a liberare risorse ed eseguire altre operazioni di pulizia prima che l'oggetto stesso venga reclamato dalla procedura di Garbage Collection. (Ereditato da Object.)

System_CAPS_pubmethodGetHashCode()

Calcola un codice hash per il valore dell'oggetto corrente StringInfo oggetto.(Esegue l'override di Object.GetHashCode().)

System_CAPS_pubmethodSystem_CAPS_staticGetNextTextElement(String)

Ottiene il primo elemento di testo in una stringa specificata.

System_CAPS_pubmethodSystem_CAPS_staticGetNextTextElement(String, Int32)

Ottiene l'elemento di testo in corrispondenza dell'indice specificato della stringa specificata.

System_CAPS_pubmethodSystem_CAPS_staticGetTextElementEnumerator(String)

Restituisce un enumeratore che scorre gli elementi di testo dell'intera stringa.

System_CAPS_pubmethodSystem_CAPS_staticGetTextElementEnumerator(String, Int32)

Restituisce un enumeratore che scorre gli elementi di testo della stringa, a partire dall'indice specificato.

System_CAPS_pubmethodGetType()

Ottiene l'oggetto Type dell'istanza corrente.(Ereditato da Object.)

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.(Ereditato da Object.)

System_CAPS_pubmethodSystem_CAPS_staticParseCombiningCharacters(String)

Restituisce gli indici di ogni carattere di base, surrogato alto o il carattere di controllo all'interno della stringa specificata.

System_CAPS_pubmethodSubstringByTextElements(Int32)

Recupera una sottostringa di elementi di testo dall'oggetto StringInfo a partire da un elemento di testo specificato e continuando fino all'ultimo elemento dell'oggetto.

System_CAPS_pubmethodSubstringByTextElements(Int32, Int32)

Recupera una sottostringa di elementi di testo dall'oggetto StringInfo a partire da un elemento di testo specificato e fino al numero specificato di elementi di testo dell'oggetto.

System_CAPS_pubmethodToString()

Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object.)

.NET Framework definisce un elemento di testo come un'unità di testo che viene visualizzato come un singolo carattere, vale a dire un grafemi. Un elemento di testo può essere un carattere di base, una coppia di surrogati o un carattere di combinazione sequenza. Il Unicode Standard definisce una coppia di surrogati come una rappresentazione di caratteri codificati per un singolo carattere astratto costituito da una sequenza di due unità di codice, in cui la prima unità della coppia è un surrogato alto e il secondo è un surrogato basso. Lo Unicode Standard definisce una combinazione sequenza come una combinazione di un carattere di base e uno o più caratteri di combinazione di caratteri. Una coppia di surrogati può rappresentare un carattere di base o un carattere di combinazione.

La classe StringInfo consente di utilizzare una stringa come serie di elementi testuali anziché singoli oggetti Char.

Per creare un'istanza di un StringInfo oggetto che rappresenta una stringa specificata, è possibile effettuare una delle operazioni seguenti:

  • Chiamare il StringInfo(String) costruttore e passare la stringa che la StringInfo oggetto deve essere rappresentato come un argomento.

  • Chiamare il valore predefinito StringInfo() costruttore e assegnare la stringa che la StringInfo oggetto è per rappresentare il String proprietà.

È possibile utilizzare i singoli elementi di testo di una stringa in due modi:

Nell'esempio seguente vengono illustrate entrambe le modalità di utilizzo degli elementi di testo in una stringa. Vengono create due stringhe:

  • strCombining, una stringa di caratteri arabi contenente tre elementi di testo con più oggetti Char. Il primo elemento di testo è il carattere di base ARABIC LETTER ALEF (U+-627) seguito da ARABIC HAMZA BELOW (U+-655) e ARABIC KASRA (U+0650). Il secondo elemento di testo è ARABIC LETTER HEH (U+0647) seguito da ARABIC FATHA (U+-64E). Il terzo elemento di testo è ARABIC LETTTER BEH (U+0628) seguito da ARABIC DAMMATAN (U+064C).

  • strSurrogates, che è una stringa che include tre coppie di surrogati: AGREEK ACROPHONIC FIVE TALENTS (U+10148) del Piano multilingue supplementare, U+20026 del Piano ideografico supplementare e U+F1001 dall'area privata dell'utente. La codifica UTF-16 di ciascun carattere è una coppia di surrogati costituita da un surrogato alto seguito da un surrogato basso.

Ogni stringa viene analizzata una volta dal metodo ParseCombiningCharacters e successivamente dal metodo GetTextElementEnumerator. Entrambi i metodi analizzano correttamente gli elementi di testo nelle due stringhe e visualizzano i risultati dell'operazione di analisi.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // The Unicode code points specify Arabic base characters and 
      // combining character sequences.
      string strCombining = "\u0627\u0655\u0650\u064A\u0647\u064E" +
                            "\u0627\u0628\u064C";

      // The Unicode code points specify private surrogate pairs.
      string strSurrogates = Char.ConvertFromUtf32(0x10148) +
                             Char.ConvertFromUtf32(0x20026) + "a" +
                             Char.ConvertFromUtf32(0xF1001);

      EnumerateTextElements(strCombining);
      EnumerateTextElements(strSurrogates);
   }

   public static void EnumerateTextElements(string str)
   {
      // Get the Enumerator.
      TextElementEnumerator teEnum = null;      

      // Parse the string using the ParseCombiningCharacters method.
      Console.WriteLine("\nParsing with ParseCombiningCharacters:");
      int[] teIndices = StringInfo.ParseCombiningCharacters(str);

      for (int i = 0; i < teIndices.Length; i++) {
         if (i < teIndices.Length - 1)
            Console.WriteLine("Text Element {0} ({1}..{2})= {3}", i, 
               teIndices[i], teIndices[i + 1] - 1, 
               ShowHexValues(str.Substring(teIndices[i], teIndices[i + 1] - 
                             teIndices[i])));
         else
            Console.WriteLine("Text Element {0} ({1}..{2})= {3}", i, 
               teIndices[i], str.Length - 1, 
               ShowHexValues(str.Substring(teIndices[i])));
      }
      Console.WriteLine();

      // Parse the string with the GetTextElementEnumerator method.
      Console.WriteLine("Parsing with TextElementEnumerator:");
      teEnum = StringInfo.GetTextElementEnumerator(str);

      int teCount = - 1;

      while (teEnum.MoveNext()) {
         // Displays the current element.
         // Both GetTextElement() and Current retrieve the current
         // text element. The latter returns it as an Object.
         teCount++;
         Console.WriteLine("Text Element {0} ({1}..{2})= {3}", teCount, 
            teEnum.ElementIndex, teEnum.ElementIndex + 
            teEnum.GetTextElement().Length - 1, ShowHexValues((string)(teEnum.Current)));
      }
   }

   private static string ShowHexValues(string s)
   {
      string hexString = "";
      foreach (var ch in s)
         hexString += String.Format("{0:X4} ", Convert.ToUInt16(ch));

      return hexString;
   }
}
// The example displays the following output:
//       Parsing with ParseCombiningCharacters:
//       Text Element 0 (0..2)= 0627 0655 0650
//       Text Element 1 (3..3)= 064A
//       Text Element 2 (4..5)= 0647 064E
//       Text Element 3 (6..6)= 0627
//       Text Element 4 (7..8)= 0628 064C
//       
//       Parsing with TextElementEnumerator:
//       Text Element 0 (0..2)= 0627 0655 0650
//       Text Element 1 (3..3)= 064A
//       Text Element 2 (4..5)= 0647 064E
//       Text Element 3 (6..6)= 0627
//       Text Element 4 (7..8)= 0628 064C
//       
//       Parsing with ParseCombiningCharacters:
//       Text Element 0 (0..1)= D800 DD48
//       Text Element 1 (2..3)= D840 DC26
//       Text Element 2 (4..4)= 0061
//       Text Element 3 (5..6)= DB84 DC01
//       
//       Parsing with TextElementEnumerator:
//       Text Element 0 (0..1)= D800 DD48
//       Text Element 1 (2..3)= D840 DC26
//       Text Element 2 (4..4)= 0061
//       Text Element 3 (5..6)= DB84 DC01

Note per i chiamanti:

Internamente, i metodi del StringInfo classe chiamare i metodi del CharUnicodeInfo classe per determinare le categorie di caratteri. A partire dal .NET Framework 4.6.2, classificazione di caratteri è basata su The Unicode Standard, Version 8.0.0. Per il .NET Framework 4 tramite il .NET Framework 4.6.1, si basa su The Unicode Standard, Version 6.3.0.

In questo esempio viene illustrato come utilizzare il GetTextElementEnumerator e ParseCombiningCharacters metodi di StringInfo classe per gestire una stringa che contiene caratteri surrogati e combinazione.

using System;
using System.Text;
using System.Globalization;

public sealed class App {
   static void Main() {
      // The string below contains combining characters.
      String s = "a\u0304\u0308bc\u0327";

      // Show each 'character' in the string.
      EnumTextElements(s);

      // Show the index in the string where each 'character' starts.
      EnumTextElementIndexes(s);
   }

   // Show how to enumerate each real character (honoring surrogates) in a string.
   static void EnumTextElements(String s) {
      // This StringBuilder holds the output results.
      StringBuilder sb = new StringBuilder();

      // Use the enumerator returned from GetTextElementEnumerator 
      // method to examine each real character.
      TextElementEnumerator charEnum = StringInfo.GetTextElementEnumerator(s);
      while (charEnum.MoveNext()) {
         sb.AppendFormat(
           "Character at index {0} is '{1}'{2}",
           charEnum.ElementIndex, charEnum.GetTextElement(),
           Environment.NewLine);
      }

      // Show the results.
      Console.WriteLine("Result of GetTextElementEnumerator:");
      Console.WriteLine(sb);
   }

   // Show how to discover the index of each real character (honoring surrogates) in a string.
   static void EnumTextElementIndexes(String s) {
      // This StringBuilder holds the output results.
      StringBuilder sb = new StringBuilder();

      // Use the ParseCombiningCharacters method to 
      // get the index of each real character in the string.
      Int32[] textElemIndex = StringInfo.ParseCombiningCharacters(s);

      // Iterate through each real character showing the character and the index where it was found.
      for (Int32 i = 0; i < textElemIndex.Length; i++) {
         sb.AppendFormat(
            "Character {0} starts at index {1}{2}",
            i, textElemIndex[i], Environment.NewLine);
      }

      // Show the results.
      Console.WriteLine("Result of ParseCombiningCharacters:");
      Console.WriteLine(sb);
   }
}

// This code produces the following output.
//
// Result of GetTextElementEnumerator:
// Character at index 0 is 'a-"'
// Character at index 3 is 'b'
// Character at index 4 is 'c,'
// 
// Result of ParseCombiningCharacters:
// Character 0 starts at index 0
// Character 1 starts at index 3
// Character 2 starts at index 4

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 1.1
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1

I membri statici pubblici ( Condiviso in Visual Basic) di questo tipo è thread safe. Non tutti i membri di istanza sono garantiti come thread safe.

Torna all'inizio
Mostra: