StringInfo.ParseCombiningCharacters(String) Metódus

Definíció

Névtér:

System.Globalization

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

StringInfo.cs

A megadott sztringen belül az egyes alapkaraktériumok, magas helyettesítő vagy vezérlőkaraktériumok indexeit adja vissza.

public:
 static cli::array <int> ^ ParseCombiningCharacters(System::String ^ str);

public static int[] ParseCombiningCharacters(string str);

static member ParseCombiningCharacters : string -> int[]

Public Shared Function ParseCombiningCharacters (str As String) As Integer()

Paraméterek

str

String

A keresendő sztring.

Válaszok

Int32[]

Egész számokat tartalmazó tömb, amely a megadott sztringen belül tartalmazza az egyes alapkarakták, magas helyettesítő vagy vezérlő karakterek nulla alapú indexeit.

Kivételek

ArgumentNullException

str az null.

Példák

Az alábbi példa a metódus meghívását ParseCombiningCharacters mutatja be. Ez a példakód egy nagyobb, az StringInfo osztályhoz tartozó példa része.

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

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 magas helyettesítő egy Unicode kódpont az U+D800 és U+DBFF közötti tartományban, az alacsony helyettesítő pedig egy Unicode kódpont az U+DC00 és az U+DFFF tartományban.

A vezérlőkarakter olyan karakter, amelynek Unicode-értéke U+007F, vagy U+0000–U+001F vagy U+0080–U+009F tartományban.

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

Ha egy egyesítő karaktersorozat érvénytelen, a rendszer az adott sorozat összes egyesítő karakterét is visszaadja.

Az eredményként kapott tömb minden indexe egy szövegelem kezdete, vagyis az alap karakter vagy a magas helyettesítő indexe.

Az egyes elemek hossza könnyen kiszámítható az egymást követő indexek közötti különbségként. A tömb hossza mindig kisebb vagy egyenlő lesz, mint a sztring hossza. Ha például a "\u4f00\u302a\ud800\udc00\u4f01" sztringet adja vissza, ez a metódus a 0, a 2 és a 4 indexet adja vissza.

Egyenértékű tagok

A .NET-keretrendszer 2.0-s verziójától kezdve a SubstringByTextElements metódus és a LengthInTextElements tulajdonság a ParseCombiningCharacters metódus által kínált funkciók egyszerű implementálását biztosítja.

Lásd még

• SubstringByTextElements
• LengthInTextElements