StringInfo.ParseCombiningCharacters-Methode

Gibt die Indizes aller Basiszeichen, hohen Ersatzzeichen oder Steuerzeichen in der angegebenen Zeichenfolge zurück.

Namespace: System.Globalization
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
Public Shared Function ParseCombiningCharacters ( _
    str As String _
) As Integer()
'Usage
Dim str As String
Dim returnValue As Integer()

returnValue = StringInfo.ParseCombiningCharacters(str)

public static int[] ParseCombiningCharacters (
    string str
)

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

public static int[] ParseCombiningCharacters (
    String str
)

public static function ParseCombiningCharacters (
    str : String
) : int[]

Parameter

• str
  Die zu durchsuchende Zeichenfolge.

Rückgabewert

Ein Array von Ganzzahlen, das die nullbasierten Indizes aller Basiszeichens, hohen Ersatzzeichen oder Steuerzeichen in der angegebenen Zeichenfolge enthält.

Ausnahmen

Hinweise

Der Unicode-Standard definiert ein Ersatzzeichenpaar als codierte Zeichendarstellung für ein einzelnes abstraktes Zeichen, das aus einer Folge von zwei Codeeinheiten besteht. Dabei stellt die erste Einheit des Paares das hohe Ersatzzeichen dar und die zweite Einheit das niedrige Ersatzzeichen. Ein hohes Ersatzzeichen ist ein Unicode-Codepunkt im Bereich von U+D800 bis U+DBFF, und ein niedriges Ersatzzeichen ist ein Unicode-Codepunkt im Bereich von U+DC00 bis U+DFFF.

Ein Steuerzeichen ist ein Zeichen, das den Unicode-Wert U+007F hat oder im Bereich von U+0000 bis U+001F bzw. im Bereich U+0080 bis U+009F liegt.

.NET Framework definiert ein Textelement als eine Texteinheit, die als einzelnes Zeichen, d. h. als Graphem, dargestellt wird. Ein Textelement kann ein Basiszeichen, ein Ersatzzeichenpaar oder eine Kombinationszeichenfolge sein. Der Unicode-Standard definiert eine Kombinationszeichenfolge als Kombination aus einem Basiszeichen und einem oder mehreren Kombinationszeichen. Ein Ersatzzeichenpaar kann ein Basiszeichen oder ein Kombinationszeichen darstellen. Weitere Informationen über Ersatzzeichenpaare und Kombinationszeichenfolgen finden Sie im Unicode-Standard unter http://www.unicode.org.

Wenn eine Kombinationszeichenfolge ungültig ist, wird auch jedes Kombinationszeichen in dieser Folge zurückgegeben.

Jeder Index im resultierenden Array ist der Anfang eines Textelements, d. h. der Index des Basiszeichens oder des hohen Ersatzzeichens.

Die Länge jedes Elements kann einfach als die Differenz zwischen zwei aufeinander folgenden Indizes berechnet werden. Die Länge des Arrays ist immer kleiner oder gleich der Länge der Zeichenfolge. Für die Zeichenfolge "\u4f00\u302a\ud800\udc00\u4f01" gibt diese Methode z. B. die Indizes 0, 2, und 4 zurück.

Entsprechende Member

Ab .NET Framework Version 2.0 bieten die SubstringByTextElements-Methode und die LengthInTextElements-Eigenschaft eine benutzerfreundliche Implementierung der Funktion, die von der ParseCombiningCharacters-Methode bereitgestellt wird.

Beispiel

Im folgenden Codebeispiel wird das Aufrufen der ParseCombiningCharacters-Methode veranschaulicht. Dieses Codebeispiel ist Teil eines umfangreicheren Beispiels für die StringInfo-Klasse.

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

using namespace System;
using namespace System::Text;
using namespace System::Globalization;


// Show how to enumerate each real character (honoring surrogates)
// in a string.

void EnumTextElements(String^ combiningChars)
{
    // This StringBuilder holds the output results.
    StringBuilder^ sb = gcnew StringBuilder();

    // Use the enumerator returned from GetTextElementEnumerator
    // method to examine each real character.
    TextElementEnumerator^ charEnum =
        StringInfo::GetTextElementEnumerator(combiningChars);
    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.

void EnumTextElementIndexes(String^ combiningChars)
{
    // This StringBuilder holds the output results.
    StringBuilder^ sb = gcnew StringBuilder();

    // Use the ParseCombiningCharacters method to
    // get the index of each real character in the string.
    array <int>^ textElemIndex =
        StringInfo::ParseCombiningCharacters(combiningChars);

    // Iterate through each real character showing the character
    // and the index where it was found.
    for (int 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);
}

int main()
{

    // The string below contains combining characters.
    String^ combiningChars = L"a\u0304\u0308bc\u0327";

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

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

};

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

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

Siehe auch

Referenz

StringInfo-Klasse
StringInfo-Member
System.Globalization-Namespace
SubstringByTextElements
LengthInTextElements