StringInfo Classe

Definizione

Spazio dei nomi:

System.Globalization

Assembly:

netstandard.dll, System.Runtime.dll

Origine:

StringInfo.cs

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

public ref class StringInfo

public class StringInfo

type StringInfo = class

Public Class StringInfo

Ereditarietà

Object

StringInfo

Esempio

In questo esempio vengono utilizzati i GetTextElementEnumerator metodi e ParseCombiningCharacters della StringInfo classe per modificare una stringa contenente surrogati e caratteri combinati.

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 'ā̈'
// Character at index 3 is 'b'
// Character at index 4 is 'ç'
//
// Result of ParseCombiningCharacters:
// Character 0 starts at index 0
// Character 1 starts at index 3
// Character 2 starts at index 4

Imports System.Text
Imports System.Globalization

Public Module Example
   Public Sub Main()
      ' The string below contains combining characters.
      Dim s As String = "a" + ChrW(&h0304) + ChrW(&h0308) + "bc" + ChrW(&h0327)

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

      ' Show the index in the string where each 'character' starts.
      EnumTextElementIndexes(s)
   End Sub

   ' Show how to enumerate each real character (honoring surrogates) in a string.
   Sub EnumTextElements(s As String)
      ' This StringBuilder holds the output results.
      Dim sb As New StringBuilder()

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

      ' Show the results.
      Console.WriteLine("Result of GetTextElementEnumerator:")
      Console.WriteLine(sb)
   End Sub

   ' Show how to discover the index of each real character (honoring surrogates) in a string.
   Sub EnumTextElementIndexes(s As String)
      ' This StringBuilder holds the output results.
      Dim sb As New StringBuilder()

      ' Use the ParseCombiningCharacters method to 
      ' get the index of each real character in the string.
      Dim textElemIndex() As Integer = StringInfo.ParseCombiningCharacters(s)

      ' Iterate through each real character showing the character and the index where it was found.
      For i As Int32 = 0 To textElemIndex.Length - 1
         sb.AppendFormat("Character {0} starts at index {1}{2}",
                         i, textElemIndex(i), Environment.NewLine)
      Next

      ' Show the results.
      Console.WriteLine("Result of ParseCombiningCharacters:")
      Console.WriteLine(sb)
   End Sub
End Module
' The example displays the following output:
'
'       Result of GetTextElementEnumerator:
'       Character at index 0 is 'ā̈'
'       Character at index 3 is 'b'
'       Character at index 4 is 'ç'
'       
'       Result of ParseCombiningCharacters:
'       Character 0 starts at index 0
'       Character 1 starts at index 3
'       Character 2 starts at index 4

Commenti

.NET definisce un elemento di testo come un'unità di testo visualizzata come un singolo carattere, ovvero un grafo. Un elemento di testo può essere un carattere di base, una coppia di surrogati o una sequenza di caratteri combinata. Lo standard Unicode definisce una coppia di surrogati come 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 elevato e la seconda è un surrogato basso. Lo standard Unicode definisce una sequenza di caratteri combinata come combinazione di un carattere di base e uno o più caratteri combinati. Una coppia di surrogati può rappresentare un carattere di base o un carattere combinato.

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

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

• Chiamare il StringInfo(String) costruttore e passarlo alla stringa che l'oggetto StringInfo deve rappresentare come argomento.

• Chiamare il costruttore predefinito StringInfo() e assegnare la stringa che l'oggetto StringInfo deve rappresentare alla String proprietà .

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

• Enumerando ogni elemento di testo. A tale scopo, chiamare il GetTextElementEnumerator metodo e quindi chiamare ripetutamente il MoveNext metodo sull'oggetto restituito TextElementEnumerator fino a quando il metodo non restituisce false.

• Chiamando il ParseCombiningCharacters metodo per recuperare una matrice contenente l'indice iniziale di ogni elemento di testo. È quindi possibile recuperare singoli elementi di testo passando questi indici al SubstringByTextElements metodo .

Nell'esempio seguente vengono illustrati entrambi i modi di utilizzare gli elementi di testo in una stringa. Crea due stringhe:

• strCombining, ovvero una stringa di caratteri arabi che include tre elementi di testo con più Char oggetti. Il primo elemento di testo è il carattere di base LETTERA ARABA ALEF (U+0627) seguito da ARABIC HAMZA BELOW (U+0655) e ARABIC KASRA (U+0650). Il secondo elemento di testo è LETTERA ARABA HEH (U+0647) seguito da ARABIC FATHA (U+064E). Il terzo elemento di testo è ARABIC LETTER BEH (U+0628) seguito da ARABO DAMMATAN (U+064C).

• strSurrogates, che è una stringa che include tre coppie surrogate: GRECO ACROPHONIC FIVE TALENT (U+10148) dal piano multilingue supplementare, U+20026 dal piano Ideografico supplementare e U+F1001 dall'area utente privata. La codifica UTF-16 di ogni carattere è una coppia di surrogati costituita da un surrogato elevato seguito da un surrogato basso.

Ogni stringa viene analizzata una volta dal ParseCombiningCharacters metodo e quindi dal GetTextElementEnumerator metodo . 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 += $"{(ushort)ch:X4} ";

      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

Imports System.Globalization

Public Module Example
   Public Sub Main()
      ' The Unicode code points specify Arabic base characters and 
      ' combining character sequences.
      Dim strCombining As String = ChrW(&H627) & ChrW(&h0655) + ChrW(&H650) & 
              ChrW(&H64A) & ChrW(&H647) & ChrW(&H64E) & ChrW(&H627) & 
              ChrW(&H628) & ChrW(&H64C)

      ' The Unicode code points specify private surrogate pairs.
      Dim strSurrogates As String = Char.ConvertFromUtf32(&h10148) +
                                    Char.ConvertFromUtf32(&h20026) + "a" +
                                    Char.ConvertFromUtf32(&hF1001)
      
      EnumerateTextElements(strCombining)
      EnumerateTextElements(strSurrogates)
   End Sub

   Public Sub EnumerateTextElements(str As String)
      ' Get the Enumerator.
      Dim teEnum As TextElementEnumerator = Nothing      

      ' Parse the string using the ParseCombiningCharacters method.
      Console.WriteLine()
      Console.WriteLine("Parsing with ParseCombiningCharacters:")
      Dim teIndices As Integer() = StringInfo.ParseCombiningCharacters(str)
      
      For i As Integer = 0 To teIndices.Length - 1
         If i < teIndices.Length - 1 Then
            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))))
         End If
      Next
      Console.WriteLine()

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

      Dim TECount As Integer = - 1

      While teEnum.MoveNext()
         ' Prints the current element.
         ' Both GetTextElement() and Current retrieve the current
         ' text element. The latter returns it as an Object.
         TECount += 1
         Console.WriteLine("Text Element {0} ({1}..{2})= {3}", teCount, 
            teEnum.ElementIndex, teEnum.ElementIndex + 
            teEnum.GetTextElement().Length - 1, ShowHexValues(CStr(teEnum.Current)))
      End While
   End Sub
   
   Private Function ShowHexValues(s As String) As String
      Dim hexString As String = ""
      For Each ch In s
         hexString += String.Format("{0:X4} ", Convert.ToUInt16(ch))
      Next
      Return hexString
   End Function
End Module
' 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 della StringInfo classe chiamano i metodi della CharUnicodeInfo classe per determinare le categorie di caratteri. A partire da .NET Framework 4.6.2, la classificazione dei caratteri è basata sullo standard Unicode versione 8.0.0. Per .NET Framework 4 e .NET Framework 4.6.1, si basa su Standard Unicode versione 6.3.0. In .NET Core è basato sullo standard Unicode versione 8.0.0.

Costruttori

Nome	Descrizione
StringInfo()	Inizializza una nuova istanza della classe StringInfo.
StringInfo(String)	Inizializza una nuova istanza della StringInfo classe in una stringa specificata.

Proprietà

Nome	Descrizione
LengthInTextElements	Ottiene il numero di elementi di testo nell'oggetto corrente StringInfo .
String	Ottiene o imposta il valore dell'oggetto corrente StringInfo .

Metodi

Nome	Descrizione
Equals(Object)	Indica se l'oggetto corrente StringInfo è uguale a un oggetto specificato.
GetHashCode()	Calcola un codice hash per il valore dell'oggetto corrente StringInfo .
GetNextTextElement(String, Int32)	Ottiene l'elemento di testo in corrispondenza dell'indice specificato della stringa specificata.
GetNextTextElement(String)	Ottiene il primo elemento di testo in una stringa specificata.
GetNextTextElementLength(ReadOnlySpan<Char>)	Restituisce la lunghezza del primo elemento di testo (cluster grapheme esteso) che si verifica nell'intervallo di input.
GetNextTextElementLength(String, Int32)	Restituisce la lunghezza del primo elemento di testo (cluster grapheme esteso) che si verifica nella stringa di input a partire dall'indice specificato.
GetNextTextElementLength(String)	Restituisce la lunghezza del primo elemento di testo (cluster grapheme esteso) che si verifica nella stringa di input.
GetTextElementEnumerator(String, Int32)	Restituisce un enumeratore che scorre gli elementi di testo della stringa, a partire dall'indice specificato.
GetTextElementEnumerator(String)	Restituisce un enumeratore che scorre gli elementi di testo dell'intera stringa.
GetType()	Ottiene il Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale del Objectcorrente. (Ereditato da Object)
ParseCombiningCharacters(String)	Restituisce gli indici di ogni carattere di base, surrogato elevato o carattere di controllo all'interno della stringa specificata.
SubstringByTextElements(Int32, Int32)	Recupera una sottostringa di elementi di testo dall'oggetto corrente StringInfo a partire da un elemento di testo specificato e continua attraverso il numero specificato di elementi di testo.
SubstringByTextElements(Int32)	Recupera una sottostringa di elementi di testo dall'oggetto corrente StringInfo a partire da un elemento di testo specificato e continua attraverso l'ultimo elemento di testo.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)

Vedi anche

• Ordinamento di tabelle ponderate per i sistemi operativi Windows
• Tabella degli elementi Delle regole di confronto Unicode predefinita, per Linux e macOS