Windows Dev Center

Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original
Informationen
Das angeforderte Thema wird unten angezeigt. Es ist jedoch nicht in dieser Bibliothek vorhanden.

StringInfo-Klasse

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

System.Object
  System.Globalization.StringInfo

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

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

Der StringInfo-Typ macht die folgenden Member verfügbar.

  NameBeschreibung
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsStringInfo()Initialisiert eine neue Instanz der StringInfo-Klasse.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsStringInfo(String)Initialisiert eine neue Instanz der StringInfo-Klasse für eine angegebene Zeichenfolge.
Zum Seitenanfang

  NameBeschreibung
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLengthInTextElementsRuft die Anzahl der Textelemente im aktuellen StringInfo-Objekt ab.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsStringRuft den Wert des aktuellen StringInfo-Objekts ab oder legt diesen fest.
Zum Seitenanfang

  NameBeschreibung
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEqualsGibt an, ob das aktuelle StringInfo-Objekt einem angegebenen Objekt entspricht. (Überschreibt Object.Equals(Object).)
Geschützte MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsFinalize Gibt einem Objekt Gelegenheit, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird. (Von Object geerbt.)
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetHashCodeBerechnet einen Hashcode für den Wert des aktuellen StringInfo-Objekts. (Überschreibt Object.GetHashCode().)
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetNextTextElement(String)Ruft das erste Textelement in einer angegebenen Zeichenfolge ab.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetNextTextElement(String, Int32)Ruft das Textelement am angegebenen Index der angegebenen Zeichenfolge ab.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetTextElementEnumerator(String)Gibt einen Enumerator zurück, der die Textelemente der gesamten Zeichenfolge durchläuft.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetTextElementEnumerator(String, Int32)Gibt einen Enumerator zurück, der die Textelemente der Zeichenfolge beginnend am angegebenen Index durchläuft.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetTypeRuft den Type der aktuellen Instanz ab. (Von Object geerbt.)
Geschützte MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsMemberwiseCloneErstellt eine flache Kopie des aktuellen Object. (Von Object geerbt.)
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsParseCombiningCharactersGibt die Indizes aller Basiszeichen, hohen Ersatzzeichen oder Steuerzeichen in der angegebenen Zeichenfolge zurück.
Öffentliche MethodeSubstringByTextElements(Int32)Ruft eine Teilzeichenfolge der Textelemente aus dem aktuellen StringInfo-Objekt ab (beginnend am angegebenen Textelement bis zum letzten Textelement).
Öffentliche MethodeSubstringByTextElements(Int32, Int32)Ruft eine Teilzeichenfolge der Textelemente aus dem aktuellen StringInfo-Objekt ab (beginnend am angegebenen Textelement bis zur angegebenen Anzahl der Textelemente).
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToStringGibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Von Object geerbt.)
Zum Seitenanfang

.NET Framework definiert ein Textelement als Texteinheit, die als einzelnes Zeichen, d. h. als Graphem, dargestellt wird. Ein Textelement kann ein Basiszeichen, ein Ersatzzeichenpaar oder eine Kombinationssequenz sein. 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 Paars das hohe Ersatzzeichen und die zweite Einheit das niedrige Ersatzzeichen dar. Der Unicode-Standard definiert eine Kombinationszeichensequenz als Kombination aus einem Basiszeichen und einem oder mehreren Kombinationszeichen. Ein Ersatzzeichenpaar kann ein Basiszeichen oder ein Kombinationszeichen darstellen.

Die StringInfo-Klasse können Sie, dass eine Zeichenfolge als eine Reihe Textelemente anstatt Einzelpersonen Char-Objekte zu arbeiten. Sie können mit den einzelnen Textelementen in einer Zeichenfolge auf zwei Arten verwenden:

Das folgende Beispiel veranschaulicht beide Methoden des Arbeitens mit den Textelementen in einer Zeichenfolge. Es erstellt zwei Zeichenfolgen:

  • strCombining, das eine Zeichenfolge mit arabischen Zeichen entspricht, die u drei Elementen mit mehreren Char-Objekten Text. Das erste Textelement ist der ARABISCHE Basiszeichen BUCHSTABE ALEF (U+-627) gefolgt von ARABISCHEM HAMZA NACH-UNTEN (U+-655) und von ARABISCHEM KASRA (U+0650). Das zweite Textelement ist der ARABISCHE BUCHSTABE HEH (U+0647) gefolgt von ARABISCHEM FATHA (U+-64E). Das dritte Textelement ist ARABISCHES LETTTER BEH (U+0628) gefolgt von ARABISCHEM DAMMATAN (U+064C).

  • strSurrogates, das eine Zeichenfolge ist, die drei Ersatzzeichenpaare enthält: GRIECHISCHE TALENTE ACROPHONIC FIVE (U+10148) von der ErgänzungsEbene mehrsprachigen, U+20026 von der ErgänzungsEbene ideografisch und privaten U+F1001 im Benutzerbereich. Die UTF-16-Codierung jedes Zeichens ist ein Ersatzzeichenpaar, das aus einem hohen Ersatzzeichen besteht, das von einer niedrigen Ersatzzeichen folgt.

Jede Zeichenfolge wird einmal durch die ParseCombiningCharacters-Methode und dann die GetTextElementEnumerator-Methode analysiert. Beide Methoden ordnungsgemäß analysieren die Textelemente in beiden Zeichenfolgen und die Ergebnisse des Analysevorgangs an.


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


In diesem Beispiel wird veranschaulicht, wie mithilfe der GetTextElementEnumerator-Methode und der ParseCombiningCharacters-Methode der StringInfo-Klasse eine Zeichenfolge mit Ersatz- und Kombinationsszeichen bearbeitet werden kann.


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


.NET Framework

Unterstützt in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Portable Klassenbibliothek

Unterstützt in: Portable Klassenbibliothek

.NET für Windows Store-Apps

Unterstützt in: Windows 8

.NET für Windows Phone-Apps

Unterstützt in: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

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

Alle öffentlichen static (Shared in Visual Basic)-Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Community-Beiträge

Anzeigen:
© 2015 Microsoft