Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

StringInfo-Klasse

 

Ermöglicht das Aufteilen einer Zeichenfolge in Textelemente sowie das Durchlaufen dieser Textelemente.

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

System.Object
  System.Globalization.StringInfo

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

NameBeschreibung
System_CAPS_pubmethodStringInfo()

Initialisiert eine neue Instanz der StringInfo-Klasse.

System_CAPS_pubmethodStringInfo(String)

Initialisiert eine neue Instanz der StringInfo-Klasse in eine angegebene Zeichenfolge.

NameBeschreibung
System_CAPS_pubpropertyLengthInTextElements

Ruft die Anzahl der Textelemente in der aktuellen StringInfo Objekt.

System_CAPS_pubpropertyString

Ruft den Wert für das aktuelle StringInfo-Objekt ab oder legt diesen fest.

NameBeschreibung
System_CAPS_pubmethodEquals(Object)

Gibt an, ob das aktuelle StringInfo-Objekt einem angegebenen Objekt entspricht.(Überschreibt Object.Equals(Object).)

System_CAPS_protmethodFinalize()

Gibt einem Objekt Gelegenheit, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird. (Geerbt von „Object“.)

System_CAPS_pubmethodGetHashCode()

Berechnet einen Hashcode für den Wert des aktuellen StringInfo Objekt.(Überschreibt Object.GetHashCode().)

System_CAPS_pubmethodSystem_CAPS_staticGetNextTextElement(String)

Ruft das erste Textelement in einer angegebenen Zeichenfolge ab.

System_CAPS_pubmethodSystem_CAPS_staticGetNextTextElement(String, Int32)

Ruft das Textelement am angegebenen Index der angegebenen Zeichenfolge ab.

System_CAPS_pubmethodSystem_CAPS_staticGetTextElementEnumerator(String)

Gibt einen Enumerator, der die Textelemente der gesamten Zeichenfolge durchläuft.

System_CAPS_pubmethodSystem_CAPS_staticGetTextElementEnumerator(String, Int32)

Gibt einen Enumerator durchläuft die Textelemente einer Zeichenfolge, beginnend am angegebenen Index.

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von „Object“.)

System_CAPS_protmethodMemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.(Geerbt von „Object“.)

System_CAPS_pubmethodSystem_CAPS_staticParseCombiningCharacters(String)

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

System_CAPS_pubmethodSubstringByTextElements(Int32)

Ruft eine Teilzeichenfolge der Textelemente aus dem aktuellen StringInfo -Objekt beginnend am angegebenen Textelement bis zum letzten Textelement.

System_CAPS_pubmethodSubstringByTextElements(Int32, Int32)

Ruft eine Teilzeichenfolge der Textelemente aus dem aktuellen StringInfo Objekt, beginnend am angegebenen Textelement und über die angegebene Anzahl von Textelementen.

System_CAPS_pubmethodToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.(Geerbt von „Object“.)

.NET Framework definiert ein Textelement als eine Texteinheit, die als einzelnes Zeichen, d. h. eine zwischen graphemgruppen angezeigt wird. Ein Textelement kann ein Basiszeichen, ein Ersatzzeichenpaar oder ein Kombinationszeichen Sequenz. Die Unicode Standard wird Sie als eine codierte zeichendarstellung für ein einzelnes abstraktes Zeichen, die aus einer Sequenz von zwei Codeeinheiten besteht, wobei die erste Einheit des Paars ist ein hohes Ersatzzeichen und der zweite ein niedriges Ersatzzeichen eines Ersatzzeichenpaars definiert. Der Unicode-Standard definiert eine Kombination von Zeichenfolge als Kombination aus einem Basiszeichen und einem oder mehreren Kombinationszeichen. Ein Ersatzzeichenpaar kann ein Basiszeichen oder ein Kombinationszeichen darstellen.

Die StringInfo Klasse ermöglicht Ihnen das Arbeiten mit einer Zeichenfolge als eine Reihe von Textelemente anstelle von individuellen Char Objekte.

Instanziiert ein StringInfo -Objekt, das eine angegebene Zeichenfolge, führen Sie einen der folgenden:

  • Rufen Sie die StringInfo(String) Konstruktor und übergeben sie die Zeichenfolge, die die StringInfo Objekt als Argument dargestellt wird.

  • Rufen Sie die Standardeinstellung StringInfo() -Konstruktor, und weisen Sie die Zeichenfolge, die die StringInfo Objekt darstellen, werden die String Eigenschaft.

Sie können mit der einzelnen Textelemente einer Zeichenfolge auf zwei Arten verwendet werden:

Das folgende Beispiel veranschaulicht beide Methoden zum Arbeiten mit den Textelementen in einer Zeichenfolge. Zwei Zeichenfolgen erstellt:

  • strCombining, dies ist eine Zeichenfolge mit arabischen Zeichen verwenden, die drei Textelemente mit mehreren Char Objekte. Zunächst wird die Basiszeichen arabische Buchstabe ALEF (U +-627) gefolgt von Arabische HAMZA unten (U +-655) und ARABISCHES KASRA (U + 0650 für). Das zweite Element der Text ist ARABISCHEN Buchstaben HEH (U + 0647) gefolgt von ARABISCHES FATHA (U +-64E). Das dritte Element der Text ist Arabische LETTTER BEH (U + 0628) gefolgt von ARABISCHES DAMMATAN (U + 064C).

  • strSurrogates, dies ist eine Zeichenfolge, die drei Ersatzzeichenpaare einschließt: griechischen ACROPHONIC (U + 10148) für fünf TALENTE aus zusätzlichen Multilingual Plane, U + 20026 von zusätzlichen ideografischen Ebene und U + F1001 aus dem persönlichen Bereich. Die UTF-16-Codierung der einzelnen Zeichen ist ein Ersatzzeichenpaar, der ein hohes Ersatzzeichen gefolgt von ein niedriges Ersatzzeichen besteht.

Jede Zeichenfolge wird einmal durch analysiert die ParseCombiningCharacters Methode und anschließend nach der GetTextElementEnumerator Methode. Beide Methoden analysieren die Textelemente in den beiden Zeichenfolgen ordnungsgemäß und zeigt die Ergebnisse des Analysevorgangs.

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

Hinweise für Aufrufer:

Intern die Methoden der StringInfo Klasse rufen die Methoden des der CharUnicodeInfo -Klasse Zeichenkategorien bestimmen. Beginnend mit der .NET Framework 4.6.2, Klassifizierung von Zeichen basiert auf The Unicode Standard, Version 8.0.0. Für die .NET Framework 4 über die .NET Framework 4.6.1, basiert auf The Unicode Standard, Version 6.3.0.

Dieses Beispiel zeigt, wie Sie die GetTextElementEnumerator und ParseCombiningCharacters Methoden die StringInfo Klasse, um eine Zeichenfolge zu ändern, der Ersatz- und enthält.

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

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 1.1
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1

Alle öffentlichen statischen Member ( Shared in Visual Basic) dieses Typs sind threadsicher. Die Threadsicherheit für Instanzmember ist nicht garantiert.

Zurück zum Anfang
Anzeigen: