StringInfo Osztály

Definíció

Névtér:

System.Globalization

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

StringInfo.cs

Lehetővé teszi egy sztring szöveges elemekre való felosztását és a szövegelemeken keresztüli iterálást.

public ref class StringInfo

public class StringInfo

type StringInfo = class

Public Class StringInfo

Öröklődés

Object

StringInfo

Példák

Ez a példa az osztály metódusait és metódusait GetTextElementEnumerator használja a ParseCombiningCharacters helyettesítő karaktereket StringInfo tartalmazó sztringek módosítására.

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

Megjegyzések

.NET egy szöveges elemet egy szöveges egységként definiál, amely egyetlen karakterként, azaz gráfként jelenik meg. A szöveges elem lehet alap karakter, helyettesítő pár vagy kombináló karaktersorozat. A Unicode Standard a helyettesítő párokat kódolt karakterábrázolásként határozza meg egyetlen absztrakt karakterhez, amely két kódegységből álló sorozatból áll, ahol a pár első egysége magas helyettesítő, a második pedig alacsony helyettesítő. A Unicode Standard az egyesítő karaktersorozatokat alapkarakterek és egy vagy több egyesítési karakter kombinációjaként határozza meg. A helyettesítő párok egy alap- vagy egy egyesítési karaktert jelölhetnek.

Az StringInfo osztály lehetővé teszi a sztringek használatát szöveges elemek sorozataként, nem pedig egyéni Char objektumokként.

Egy adott sztringet StringInfo képviselő objektum példányosításához tegye az alábbiak egyikét:

• Hívja meg a StringInfo(String) konstruktort, és adja át azt a sztringet, amelyet az StringInfo objektum argumentumként jelöl.

• Hívja meg az alapértelmezett StringInfo() konstruktort, és rendelje hozzá azt a sztringet, amelyet az StringInfo objektum képvisel a String tulajdonsághoz.

A sztring egyes szövegelemeivel kétféleképpen dolgozhat:

• Az egyes szövegelemek számbavételével. Ehhez hívja meg a metódust GetTextElementEnumerator , majd többször hívja meg a MoveNext metódust a visszaadott TextElementEnumerator objektumon, amíg a metódus vissza nem tér false.

• A metódus meghívásával ParseCombiningCharacters lekérheti az egyes szövegelemek kezdőindexét tartalmazó tömböt. Ezután lekérheti az egyes szöveges elemeket úgy, hogy átadja ezeket az indexeket a SubstringByTextElements metódusnak.

Az alábbi példa a sztring szövegelemeivel való munka mindkét módját szemlélteti. Két sztringet hoz létre:

• strCombining, amely egy arab karakterekből álló sztring, amely három szöveges elemet tartalmaz több Char objektummal. Az első szöveges elem az ARAB BETŰ ALEF (U+0627), majd az ARAB HAMZA BELOW (U+0655) és az ARAB KASRA (U+0650) karakter. A második szöveges elem az ARAB HEH BETŰ (U+0647), majd az ARAB FATHA (U+064E). A harmadik szövegelem az ARAB BETŰ BEH (U+0628), majd az ARAB DAMMATAN (U+064C).

• strSurrogates, amely egy sztring, amely három helyettesítő párt tartalmaz: GÖRÖG ACROPHONIC FIVE TALENTS (U+10148) a kiegészítő többnyelvű síkból, U+20026 a kiegészítő ideografikus síkból, és U+F1001 a magánfelhasználói területről. Az UTF-16 kódolása minden karakter egy helyettesítő pár, amely egy magas helyettesítő, majd egy alacsony helyettes.

Minden sztringet egyszer elemez a ParseCombiningCharacters metódus, majd a GetTextElementEnumerator metódus. Mindkét metódus megfelelően elemzi a két sztring szöveges elemeit, és megjeleníti az elemzési művelet eredményeit.

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

Megjegyzések a hívókhoz

Az osztály metódusai StringInfo belsőleg meghívják az osztály metódusait a CharUnicodeInfo karakterkategóriák meghatározásához. A .NET Framework 4.6.2-es verziójától kezdve a karakterbesorolás A Unicode Standard 8.0.0 alapján történik. A .NET Framework 4-es és a .NET Framework 4.6.1-es verziójának A Unicode Standard 6.3.0. A .NET Core-ban a A Unicode Standard 8.0.0.

Konstruktorok

Name	Description
StringInfo()	Inicializálja a StringInfo osztály új példányát.
StringInfo(String)	Inicializálja az StringInfo osztály új példányát egy megadott sztringre.

Tulajdonságok

Name	Description
LengthInTextElements	Lekéri az aktuális StringInfo objektum szöveges elemeinek számát.
String	Lekéri vagy beállítja az aktuális StringInfo objektum értékét.

Metódusok

Name	Description
Equals(Object)	Azt jelzi, hogy az aktuális StringInfo objektum egyenlő-e egy adott objektummal.
GetHashCode()	Az aktuális StringInfo objektum értékének kivonatkódját számítja ki.
GetNextTextElement(String, Int32)	Lekéri a szöveges elemet a megadott sztring megadott indexében.
GetNextTextElement(String)	Lekéri egy megadott sztring első szöveges elemét.
GetNextTextElementLength(ReadOnlySpan<Char>)	A bemeneti időtartamban előforduló első szöveges elem (kiterjesztett gráffürt) hosszát adja vissza.
GetNextTextElementLength(String, Int32)	A bemeneti sztringben a megadott indextől kezdődő első szöveges elem (kiterjesztett gráffürt) hosszát adja vissza.
GetNextTextElementLength(String)	A bemeneti sztringben előforduló első szöveges elem (kiterjesztett gráffürt) hosszát adja vissza.
GetTextElementEnumerator(String, Int32)	Egy enumerátort ad vissza, amely a sztring szöveges elemein halad végig a megadott indextől kezdve.
GetTextElementEnumerator(String)	Egy enumerátort ad vissza, amely a teljes sztring szöveges elemein halad végig.
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
ParseCombiningCharacters(String)	A megadott sztringen belül az egyes alapkaraktériumok, magas helyettesítő vagy vezérlőkaraktériumok indexeit adja vissza.
SubstringByTextElements(Int32, Int32)	Lekéri a szöveges elemek részszűrését az aktuális StringInfo objektumból egy megadott szövegelemtől kezdve, és a megadott számú szöveges elemen halad végig.
SubstringByTextElements(Int32)	Lekéri az aktuális StringInfo objektum szöveges elemeinek egy részszűkítését egy megadott szövegelemtől kezdve az utolsó szöveges elemig.
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)

Lásd még

• Súlytáblák Windows operációs rendszerekhez
• Alapértelmezett Unicode rendezési elemtáblázat Linux és macOS rendszeren