String-Klasse

Stellt Text als eine Reihe von Unicode-Zeichen dar.

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

[SerializableAttribute]
[ComVisibleAttribute(true)]
public sealed class String : IComparable, 
	ICloneable, IConvertible, IComparable<string>, IEnumerable<char>, 
	IEnumerable, IEquatable<string>

Der String-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-AppsString(Char*)Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch einen angegebenen Zeiger auf ein Array von Unicode-Zeichen bestimmt wird.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsString(Char[])Initialisiert eine neue Instanz der String-Klasse mit dem durch ein Array von Unicode-Zeichen angegebenen Wert.
Öffentliche MethodeUnterstützt von XNA FrameworkString(SByte*)Initialisiert eine neue Instanz der String-Klasse mit dem durch einen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen angegebenen Wert.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsString(Char, Int32)Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch ein angegebenes so oft wie angegeben wiederholtes Unicode-Zeichen bestimmt wird.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsString(Char*, Int32, Int32)Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch einen angegebenen Zeiger auf ein Array von Unicode-Zeichen, durch die Position des ersten Zeichens innerhalb dieses Arrays und durch eine Länge bestimmt wird.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsString(Char[], Int32, Int32)Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch ein Array von Unicode-Zeichen, die Position des ersten Zeichens innerhalb dieses Arrays und eine Länge bestimmt wird.
Öffentliche MethodeString(SByte*, Int32, Int32)Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch einen angegebenen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen, die Startposition innerhalb dieses Arrays und die Länge angegeben wird.
Öffentliche MethodeString(SByte*, Int32, Int32, Encoding)Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch einen angegebenen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen, die Startposition innerhalb dieses Arrays, eine Länge und ein Encoding-Objekt angegeben wird.
Zum Seitenanfang

  NameBeschreibung
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCharsRuft das Char-Objekt an einer angegebenen Zeichenposition innerhalb des aktuellen String-Objekts ab.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLengthRuft die Anzahl der Zeichen im aktuellen String-Objekt ab.
Zum Seitenanfang

  NameBeschreibung
Öffentliche MethodeUnterstützt von XNA FrameworkCloneGibt einen Verweis auf diese Instanz von String zurück.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCompare(String, String)Vergleicht zwei angegebene String-Objekte und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkCompare(String, String, Boolean)Vergleicht zwei angegebene String-Objekte, wobei ihre Groß- und Kleinschreibung entweder ignoriert oder berücksichtigt wird, und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCompare(String, String, StringComparison)Vergleicht zwei angegebene String-Objekte gemäß den angegebenen Vergleichsregeln und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkCompare(String, String, Boolean, CultureInfo)Vergleicht zwei angegebene String-Objekte, wobei ihre Groß- und Kleinschreibung entweder ignoriert oder berücksichtigt und der Vergleich durch kulturspezifische Informationen beeinflusst wird, und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekCompare(String, String, CultureInfo, CompareOptions)Vergleicht zwei angegebene String-Objekte mit den festgelegten Vergleichsoptionen und kulturspezifischen Informationen, die den Vergleich beeinflussen, und gibt eine ganze Zahl zurück, die die Beziehung der beiden Zeichenfolgen zueinander in der Sortierreihenfolge angibt.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCompare(String, Int32, String, Int32, Int32)Vergleicht Teilzeichenfolgen von zwei angegebenen String-Objekten und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkCompare(String, Int32, String, Int32, Int32, Boolean)Vergleicht Teilzeichenfolgen von zwei angegebenen String-Objekten, wobei ihre Groß- und Kleinschreibung entweder ignoriert oder berücksichtigt wird, und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCompare(String, Int32, String, Int32, Int32, StringComparison)Vergleicht Teilzeichenfolgen von zwei angegebenen String-Objekten gemäß den angegebenen Vergleichsregeln und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkCompare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)Vergleicht Teilzeichenfolgen von zwei angegebenen String-Objekten, wobei ihre Groß- und Kleinschreibung entweder ignoriert oder berücksichtigt und der Vergleich durch kulturspezifische Informationen beeinflusst wird, und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt.
Öffentliche MethodeStatischer MemberCompare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)Vergleicht Teilzeichenfolgen von zwei angegebenen String-Objekten mit den festgelegten Vergleichsoptionen und kulturspezifischen Informationen, die den Vergleich beeinflussen, und gibt eine ganze Zahl zurück, die die Beziehung der beiden Teilzeichenfolgen zueinander in der Sortierreihenfolge angibt.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCompareOrdinal(String, String)Vergleicht zwei angegebene String-Objekte, indem die numerischen Werte der entsprechenden Char-Objekte in den Zeichenfolgen ausgewertet werden.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCompareOrdinal(String, Int32, String, Int32, Int32)Vergleicht Teilzeichenfolgen zweier angegebener String-Objekte, indem die numerischen Werte der entsprechenden Char-Objekte in den Teilzeichenfolgen ausgewertet werden.
Öffentliche MethodeUnterstützt von XNA FrameworkCompareTo(Object)Vergleicht diese Instanz mit einem angegebenen Object und gibt an, ob diese Instanz in der Sortierreihenfolge an einer früheren, späteren oder derselben Position wie das angegebene Object aufgeführt wird.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCompareTo(String)Vergleicht diese Instanz mit einem angegebenen String-Objekt und gibt an, ob diese Instanz in der Sortierreihenfolge an einer früheren, späteren oder derselben Position wie der angegebene String aufgeführt wird.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsConcat(Object)Erstellt die Zeichenfolgendarstellung eines angegebenen Objekts.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsConcat(Object[])Verkettet die Zeichenfolgendarstellungen der Elemente in einem angegebenen Object-Array.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsConcat(IEnumerable<String>)Verkettet die Member einer erstellten IEnumerable<T>-Auflistung vom Typ String.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsConcat(String[])Verkettet die Elemente eines angegebenen String-Arrays.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsConcat(Object, Object)Verkettet die Zeichenfolgendarstellungen zweier angegebener Objekte.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsConcat(String, String)Verkettet zwei angegebene Instanzen von String.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsConcat(Object, Object, Object)Verkettet die Zeichenfolgendarstellungen von drei angegebenen Objekten.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsConcat(String, String, String)Verkettet drei angegebene Instanzen von String.
Öffentliche MethodeStatischer MemberConcat(Object, Object, Object, Object)Verkettet die Zeichenfolgenentsprechungen von vier angegebenen Objekten sowie aller in einer optionalen Parameterliste variabler Länger angegebenen Objekte.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsConcat(String, String, String, String)Verkettet vier angegebene Instanzen von String.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsConcat<T>(IEnumerable<T>)Verkettet die Member einer IEnumerable<T>-Implementierung.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsContainsGibt einen Wert zurück, der angibt, ob eine angegebene untergeordnete Zeichenfolge in dieser Zeichenfolge vorkommt.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkCopyErstellt eine neue Instanz von String mit demselben Wert wie eine angegebene Instanz von String.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCopyToKopiert eine angegebene Anzahl von Zeichen von einer angegebenen Position in dieser Instanz an eine angegebene Position in einem Array von Unicode-Zeichen.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEndsWith(String)Bestimmt, ob das Ende dieser Zeichenfolgeninstanz mit der angegebenen Zeichenfolge übereinstimmt.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEndsWith(String, StringComparison)Bestimmt, ob das Ende dieser Zeichenfolgeninstanz bei einem Vergleich unter Verwendung der angegebenen Vergleichsoption mit der angegebenen Zeichenfolge übereinstimmt.
Öffentliche MethodeEndsWith(String, Boolean, CultureInfo)Bestimmt, ob das Ende dieser Zeichenfolgeninstanz bei einem Vergleich unter Verwendung der angegebenen Kultur mit der angegebenen Zeichenfolge übereinstimmt.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquals(Object)Bestimmt, ob diese Instanz und ein angegebenes Objekt, das ebenfalls ein String-Objekt sein muss, denselben Wert haben. (Überschreibt Object.Equals(Object).)
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquals(String)Bestimmt, ob diese Instanz und ein anderes angegebenes String-Objekt denselben Wert haben.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquals(String, String)Bestimmt, ob zwei angegebene String-Objekte denselben Wert haben.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquals(String, StringComparison)Bestimmt, ob diese Zeichenfolge und ein angegebenes String-Objekt denselben Wert haben. Ein Parameter gibt die Kultur, Berücksichtigung von Groß- und Kleinschreibung und Sortierregeln, die für den Vergleich verwendet werden.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquals(String, String, StringComparison)Bestimmt, ob zwei angegebene String-Objekte denselben Wert haben. Ein Parameter gibt die Kultur, Berücksichtigung von Groß- und Kleinschreibung und Sortierregeln, die für den Vergleich verwendet werden.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkFormat(String, Object)Ersetzt ein oder mehrere Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung eines angegebenen Objekts.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsFormat(String, Object[])Ersetzt das Formatelement in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung eines entsprechenden Objekts in einem angegebenen Array.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsFormat(IFormatProvider, String, Object[])Ersetzt die Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellungen entsprechender Objekte in einem angegebenen Array. Ein Parameter liefert kulturabhängige Formatierungsinformationen.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkFormat(String, Object, Object)Ersetzt die Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung von zwei angegebenen Objekten.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkFormat(String, Object, Object, Object)Ersetzt die Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung von drei angegebenen Objekten.
Öffentliche MethodeUnterstützt von XNA FrameworkGetEnumeratorRuft ein Objekt ab, das die einzelnen Zeichen dieser Zeichenfolge durchlaufen kann.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetHashCodeGibt den Hashcode für diese Zeichenfolge zurück. (Überschreibt Object.GetHashCode().)
Ö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.)
Öffentliche MethodeUnterstützt von XNA FrameworkGetTypeCodeGibt den TypeCode für die Klasse String zurück.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIndexOf(Char)Gibt den NULL-basierten Index des ersten Vorkommens des angegebenen Unicode-Zeichens in dieser Zeichenfolge an.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIndexOf(String)Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge in dieser Instanz an.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIndexOf(Char, Int32)Gibt den NULL-basierten Index des ersten Vorkommens des angegebenen Unicode-Zeichens in dieser Zeichenfolge an. Die Suche beginnt an einer angegebenen Zeichenposition.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIndexOf(String, Int32)Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIndexOf(String, StringComparison)Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge im aktuellen String-Objekt an. Ein Parameter gibt den Typ der Suche für die angegebene Zeichenfolge an.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIndexOf(Char, Int32, Int32)Gibt den NULL-basierten Index des ersten Vorkommens des angegebenen Zeichens in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition, und es wird eine angegebene Anzahl von Zeichenpositionen überprüft.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIndexOf(String, Int32, Int32)Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition, und es wird eine angegebene Anzahl von Zeichenpositionen überprüft.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIndexOf(String, Int32, StringComparison)Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge im aktuellen String-Objekt an. Parameter geben die Anfangssuchposition in der aktuellen Zeichenfolge und den Typ der Suche an, die für die angegebene Zeichenfolge verwendet werden soll.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIndexOf(String, Int32, Int32, StringComparison)Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge im aktuellen String-Objekt an. Parameter geben die Anfangssuchposition in der aktuellen Zeichenfolge, die Anzahl der Zeichen in der aktuellen Zeichenfolge und den Typ der Suche für die angegebene Zeichenfolge an.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIndexOfAny(Char[])Gibt den NULL-basierten Index des ersten Vorkommens eines beliebigen Zeichens aus einem angegebenen Array von Unicode-Zeichen in dieser Instanz an.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIndexOfAny(Char[], Int32)Gibt den NULL-basierten Index des ersten Vorkommens eines beliebigen Zeichens aus einem angegebenen Array von Unicode-Zeichen in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIndexOfAny(Char[], Int32, Int32)Gibt den NULL-basierten Index des ersten Vorkommens eines beliebigen Zeichens aus einem angegebenen Array von Unicode-Zeichen in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition, und es wird eine angegebene Anzahl von Zeichenpositionen überprüft.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsInsertGibt eine neue Zeichenfolge zurück, in der eine angegebene Zeichenfolge an einer angegebenen Indexposition in dieser Instanz eingefügt wird.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkInternRuft den Verweis des Systems auf den angegebenen String ab.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkIsInternedRuft einen Verweis auf einen angegebenen String ab.
Öffentliche MethodeIsNormalized()Gibt an, ob diese Zeichenfolge in der Unicode-Normalisierungsform C vorliegt.
Öffentliche MethodeIsNormalized(NormalizationForm)Gibt an, ob diese Zeichenfolge in der angegebenen Unicode-Normalisierungsform vorliegt.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIsNullOrEmptyGibt an, ob die angegebene Zeichenfolge null oder eine Empty-Zeichenfolge ist.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIsNullOrWhiteSpaceGibt an, ob eine angegebene Zeichenfolge null ist, leer ist oder nur aus Leerzeichen besteht.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsJoin(String, IEnumerable<String>)Verkettet die Member einer erstellten IEnumerable<T>-Auflistung vom Typ String und verwendet das angegebene Trennzeichen zwischen den einzelnen Membern.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsJoin(String, Object[])Verkettet die Elemente eines Objektarrays und verwendet das angegebene Trennzeichen zwischen den einzelnen Elementen.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsJoin(String, String[])Verkettet alle Elemente eines Zeichenfolgenarrays und verwendet das angegebene Trennzeichen zwischen den einzelnen Elementen.
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsJoin(String, String[], Int32, Int32)Verkettet die angegebenen Elemente eines Zeichenfolgenarrays und verwendet das angegebene Trennzeichen zwischen den einzelnen Elementen.
Öffentliche MethodeStatischer MemberUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsJoin<T>(String, IEnumerable<T>)Verkettet die Member einer Auflistung und verwendet das angegebene Trennzeichen zwischen den einzelnen Membern.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLastIndexOf(Char)Gibt die NULL-basierte Indexposition des letzten Vorkommens eines angegebenen Unicode-Zeichens in dieser Instanz an.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLastIndexOf(String)Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLastIndexOf(Char, Int32)Gibt die NULL-basierte Indexposition des letzten Vorkommens eines angegebenen Unicode-Zeichens in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLastIndexOf(String, Int32)Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLastIndexOf(String, StringComparison)Gibt den NULL-basierten Index des letzten Vorkommens einer angegebenen Zeichenfolge im aktuellen String-Objekt an. Ein Parameter gibt den Typ der Suche für die angegebene Zeichenfolge an.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLastIndexOf(Char, Int32, Int32)Gibt die NULL-basierte Indexposition des letzten Vorkommens des angegebenen Unicode-Zeichens in einer Teilzeichenfolge dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLastIndexOf(String, Int32, Int32)Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLastIndexOf(String, Int32, StringComparison)Gibt den NULL-basierten Index des letzten Vorkommens einer angegebenen Zeichenfolge im aktuellen String-Objekt an. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt. Ein Parameter gibt den Typ des bei der Suche nach der angegebenen Zeichenfolge auszuführenden Vergleichs an.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLastIndexOf(String, Int32, Int32, StringComparison)Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge. Ein Parameter gibt den Typ des bei der Suche nach der angegebenen Zeichenfolge auszuführenden Vergleichs an.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLastIndexOfAny(Char[])Gibt die NULL-basierte Indexposition des letzten Vorkommens eines oder mehrerer angegebener Zeichen eines Unicode-Arrays in dieser Instanz an.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLastIndexOfAny(Char[], Int32)Gibt die NULL-basierte Indexposition des letzten Vorkommens eines oder mehrerer angegebener Zeichen eines Unicode-Arrays in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLastIndexOfAny(Char[], Int32, Int32)Gibt die NULL-basierte Indexposition des letzten Vorkommens eines oder mehrerer angegebener Zeichen eines Unicode-Arrays in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge.
Öffentliche MethodeNormalize()Gibt eine neue Zeichenfolge zurück, deren Textwert mit dieser Zeichenfolge übereinstimmt, deren binäre Darstellung jedoch in der Unicode-Normalisierungsform C vorliegt.
Öffentliche MethodeNormalize(NormalizationForm)Gibt eine neue Zeichenfolge zurück, deren Textwert mit dieser Zeichenfolge übereinstimmt, deren binäre Darstellung jedoch in der angegebenen Unicode-Normalisierungsform vorliegt.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsPadLeft(Int32)Gibt eine neue Zeichenfolge zurück, bei der die Zeichen in dieser Instanz rechtsbündig ausgerichtet werden, indem die linke Seite mit Leerzeichen aufgefüllt wird, um eine angegebene Gesamtlänge zu erreichen.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsPadLeft(Int32, Char)Gibt eine neue Zeichenfolge zurück, bei der die Zeichen in dieser Instanz rechtsbündig ausgerichtet werden, indem die linke Seite mit einem angegebenen Unicode-Zeichen aufgefüllt wird, um eine angegebene Gesamtlänge zu erreichen.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsPadRight(Int32)Gibt eine neue Zeichenfolge zurück, deren Zeichen linksbündig ausgerichtet werden, indem die rechte Seite mit Leerzeichen aufgefüllt wird, um eine angegebene Gesamtlänge zu erreichen.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsPadRight(Int32, Char)Gibt eine neue Zeichenfolge zurück, deren Zeichen linksbündig ausgerichtet werden, indem die rechte Seite mit einem angegebenen Unicode-Zeichen aufgefüllt wird, um eine angegebene Gesamtlänge zu erreichen.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsRemove(Int32)Gibt eine neue Zeichenfolge zurück, in der alle Zeichen in der aktuellen Instanz, beginnend an einer angegebenen Position und sich über die letzte Position fortsetzend, gelöscht wurden.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsRemove(Int32, Int32)Gibt eine neue Zeichenfolge zurück, in der eine bestimmte Anzahl von Zeichen in er aktuellen Instanz, beginnend an einer angegebenen Position, gelöscht wurden.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsReplace(Char, Char)Gibt eine neue Zeichenfolge zurück, in der alle Vorkommen eines angegebenen Unicode-Zeichens in dieser Instanz durch ein anderes angegebenes Unicode-Zeichen ersetzt wurden.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsReplace(String, String)Gibt eine neue Zeichenfolge zurück, in der alle Vorkommen einer angegebenen Zeichenfolge in der aktuellen Instanz durch eine andere angegebene Zeichenfolge ersetzt wurden.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsSplit(Char[])Gibt ein Zeichenfolgenarray zurück, das die Teilzeichenfolgen dieser Instanz enthält, die durch Elemente eines angegebenen Unicode-Zeichenarrays getrennt sind.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsSplit(Char[], Int32)Gibt ein Zeichenfolgenarray zurück, das die Teilzeichenfolgen dieser Instanz enthält, die durch Elemente eines angegebenen Unicode-Zeichenarrays getrennt sind. Ein Parameter gibt die maximale Anzahl zurückzugebender Teilzeichenfolgen an.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsSplit(Char[], StringSplitOptions)Gibt ein Zeichenfolgenarray zurück, das die Teilzeichenfolgen dieser Zeichenfolge enthält, die durch Elemente eines angegebenen Unicode-Zeichenarrays getrennt sind. Ein Parameter gibt an, ob leere Arrayelemente zurückgegeben werden sollen.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsSplit(String[], StringSplitOptions)Gibt ein Zeichenfolgenarray zurück, das die Teilzeichenfolgen dieser Zeichenfolge enthält, die durch Elemente eines angegebenen Zeichenfolgenarrays getrennt sind. Ein Parameter gibt an, ob leere Arrayelemente zurückgegeben werden sollen.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsSplit(Char[], Int32, StringSplitOptions)Gibt ein Zeichenfolgenarray zurück, das die Teilzeichenfolgen dieser Zeichenfolge enthält, die durch Elemente eines angegebenen Unicode-Zeichenarrays getrennt sind. Parameter geben die maximale Anzahl von zurückzugebenden Teilzeichenfolgen an und ob leere Arrayelemente zurückgegeben werden sollen.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsSplit(String[], Int32, StringSplitOptions)Gibt ein Zeichenfolgenarray zurück, das die Teilzeichenfolgen dieser Zeichenfolge enthält, die durch Elemente eines angegebenen Zeichenfolgenarrays getrennt sind. Parameter geben die maximale Anzahl von zurückzugebenden Teilzeichenfolgen an und ob leere Arrayelemente zurückgegeben werden sollen.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsStartsWith(String)Bestimmt, ob der Anfang dieser Zeichenfolgeninstanz mit der angegebenen Zeichenfolge übereinstimmt.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsStartsWith(String, StringComparison)Bestimmt, ob der Anfang dieser Zeichenfolgeninstanz bei einem Vergleich unter Verwendung der angegebenen Vergleichsoption mit der angegebenen Zeichenfolge übereinstimmt.
Öffentliche MethodeStartsWith(String, Boolean, CultureInfo)Bestimmt, ob der Anfang dieser Zeichenfolgeninstanz bei einem Vergleich unter Verwendung der angegebenen Kultur mit der angegebenen Zeichenfolge übereinstimmt.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsSubstring(Int32)Ruft eine Teilzeichenfolge dieser Instanz ab. Die untergeordnete Zeichenfolge beginnt in einer angegebenen Zeichenposition und wird an das Ende der Zeichenfolge fortgesetzt.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsSubstring(Int32, Int32)Ruft eine Teilzeichenfolge dieser Instanz ab. Die Teilzeichenfolge beginnt an einer angegebenen Zeichenposition und hat eine angegebene Länge.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToCharArray()Kopiert die Zeichen dieser Instanz in ein Array von Unicode-Zeichen.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToCharArray(Int32, Int32)Kopiert die Zeichen einer angegebenen Teilzeichenfolge dieser Instanz in ein Array von Unicode-Zeichen.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToLower()Gibt eine in Kleinbuchstaben konvertierte Kopie dieser Zeichenfolge zurück.
Öffentliche MethodeUnterstützt von XNA FrameworkToLower(CultureInfo)Gibt eine in Kleinbuchstaben konvertierte Kopie dieser Zeichenfolge zurück, wobei die Regeln der Groß- und Kleinschreibung der angegebenen Kultur verwendet werden.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToLowerInvariantGibt eine in Kleinbuchstaben konvertierte Kopie dieses String-Objekts zurück, wobei die Regeln der Groß- und Kleinschreibung der invarianten Kultur verwendet werden.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToString()Gibt diese Instanz von String zurück. Es wird keine wirkliche Konvertierung durchgeführt. (Überschreibt Object.ToString().)
Öffentliche MethodeUnterstützt von XNA FrameworkToString(IFormatProvider)Gibt diese Instanz von String zurück. Es wird keine wirkliche Konvertierung durchgeführt.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToUpper()Gibt eine in Großbuchstaben konvertierte Kopie dieser Zeichenfolge zurück.
Öffentliche MethodeUnterstützt von XNA FrameworkToUpper(CultureInfo)Gibt eine in Großbuchstaben konvertierte Kopie dieser Zeichenfolge zurück, wobei die Regeln der Groß- und Kleinschreibung der angegebenen Kultur verwendet werden.
Öffentliche MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToUpperInvariantGibt eine in Großbuchstaben konvertierte Kopie dieses String-Objekts zurück, wobei die Regeln der Groß- und Kleinschreibung der invarianten Kultur verwendet werden.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsTrim()Entfernt alle führenden und nachgestellten Leerraumzeichen aus dem aktuellen String-Objekt.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsTrim(Char[])Entfernt alle führenden und nachgestellten Vorkommen der Zeichen im angegebenen Array aus dem aktuellen String-Objekt.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsTrimEndEntfernt alle nachgestellten Vorkommen der Zeichen im angegebenen Array aus dem aktuellen String-Objekt.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsTrimStartEntfernt alle führenden Vorkommen der Zeichen im angegebenen Array aus dem aktuellen String-Objekt.
Zum Seitenanfang

  NameBeschreibung
Öffentlicher OperatorStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEqualityBestimmt, ob zwei angegebene Zeichenfolgen denselben Wert haben.
Öffentlicher OperatorStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsInequalityBestimmt, ob zwei angegebene Zeichenfolgen verschiedene Werte haben.
Zum Seitenanfang

  NameBeschreibung
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkAggregate<Char>(Func<Char, Char, Char>)Überladen. Wendet eine Akkumulatorfunktion auf eine Sequenz an. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkAggregate<Char, TAccumulate>(TAccumulate, Func<TAccumulate, Char, TAccumulate>)Überladen. Wendet eine Akkumulatorfunktion auf eine Sequenz an. Der angegebene Startwert wird als erster Akkumulatorwert verwendet. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkAggregate<Char, TAccumulate, TResult>(TAccumulate, Func<TAccumulate, Char, TAccumulate>, Func<TAccumulate, TResult>)Überladen. Wendet eine Akkumulatorfunktion auf eine Sequenz an. Der angegebene Startwert wird als erster Akkumulatorwert verwendet, und der Ergebniswert wird mit der angegebenen Funktion ausgewählt. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkAll<Char>Bestimmt, ob alle Elemente einer Sequenz eine Bedingung erfüllen. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkAny<Char>()Überladen. Bestimmt, ob eine Sequenz Elemente enthält. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkAny<Char>(Func<Char, Boolean>)Überladen. Bestimmt, ob ein Element einer Sequenz eine Bedingung erfüllt. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkAsEnumerable<Char>Gibt die Eingabe als IEnumerable<T> zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsAsParallel()Überladen. Ermöglicht die Parallelisierung einer Abfrage. (Durch ParallelEnumerable definiert.)
Öffentliche ErweiterungsmethodeAsParallel<Char>()Überladen. Ermöglicht die Parallelisierung einer Abfrage. (Durch ParallelEnumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsAsQueryable()Überladen. Konvertiert ein IEnumerable in ein IQueryable. (Durch Queryable definiert.)
Öffentliche ErweiterungsmethodeAsQueryable<Char>()Überladen. Konvertiert ein generisches IEnumerable<T> in ein generisches IQueryable<T>. (Durch Queryable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkAverage<Char>(Func<Char, Int32>)Überladen. Berechnet den Durchschnitt einer Sequenz von Int32-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkAverage<Char>(Func<Char, Nullable<Int32>>)Überladen. Berechnet den Durchschnitt einer Sequenz von Int32-Werten, die NULL zulassen, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt wird. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkAverage<Char>(Func<Char, Int64>)Überladen. Berechnet den Durchschnitt einer Sequenz von Int64-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkAverage<Char>(Func<Char, Nullable<Int64>>)Überladen. Berechnet den Durchschnitt einer Sequenz von Int64-Werten, die NULL zulassen und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkAverage<Char>(Func<Char, Single>)Überladen. Berechnet den Durchschnitt einer Sequenz von Single-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkAverage<Char>(Func<Char, Nullable<Single>>)Überladen. Berechnet den Durchschnitt einer Sequenz von Single-Werten, die NULL zulassen und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkAverage<Char>(Func<Char, Double>)Überladen. Berechnet den Durchschnitt einer Sequenz von Double-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkAverage<Char>(Func<Char, Nullable<Double>>)Überladen. Berechnet den Durchschnitt einer Sequenz von Double-Werten, die NULL zulassen und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkAverage<Char>(Func<Char, Decimal>)Überladen. Berechnet den Durchschnitt einer Sequenz von Decimal-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkAverage<Char>(Func<Char, Nullable<Decimal>>)Überladen. Berechnet den Durchschnitt einer Sequenz von Decimal-Werten, die NULL zulassen und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCast<TResult>Wandelt die Elemente eines IEnumerable in den angegebenen Typ um. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkConcat<Char>Verkettet zwei Sequenzen. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkContains<Char>(Char)Überladen. Bestimmt mithilfe des Standardgleichheitsvergleichs, ob eine Sequenz ein angegebenes Element enthält. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkContains<Char>(Char, IEqualityComparer<Char>)Überladen. Bestimmt mithilfe eines angegebenen IEqualityComparer<T>, ob eine Sequenz ein angegebenes Element enthält. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkCount<Char>()Überladen. Gibt die Anzahl der Elemente in einer Sequenz zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkCount<Char>(Func<Char, Boolean>)Überladen. Gibt eine Zahl zurück, die die Anzahl der Elemente in der angegebenen Sequenz angibt, die eine Bedingung erfüllen. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkDefaultIfEmpty<Char>()Überladen. Gibt die Elemente der angegebenen Sequenz zurück, oder den Standardwert des Typparameters in einer Singletonauflistung, wenn die Sequenz leer ist. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkDefaultIfEmpty<Char>(Char)Überladen. Gibt die Elemente der angegebenen Sequenz zurück, oder den angegebenen Wert in einer Singletonauflistung, wenn die Sequenz leer ist. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkDistinct<Char>()Überladen. Gibt mithilfe des Standardgleichheitsvergleichs zum Vergleichen von Werten unterschiedliche Elemente aus einer Sequenz zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkDistinct<Char>(IEqualityComparer<Char>)Überladen. Gibt mithilfe eines angegebenen IEqualityComparer<T> zum Vergleichen von Werten unterschiedliche Elemente aus einer Sequenz zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkElementAt<Char>Gibt das Element an einem angegebenen Index in einer Sequenz zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkElementAtOrDefault<Char>Gibt das Element an einem angegebenen Index in einer Sequenz oder einen Standardwert zurück, wenn der Index außerhalb des gültigen Bereichs liegt. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkExcept<Char>(IEnumerable<Char>)Überladen. Erzeugt die Differenzmenge zweier Sequenzen mithilfe des Standardgleichheitsvergleichs zum Vergleichen von Werten. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkExcept<Char>(IEnumerable<Char>, IEqualityComparer<Char>)Überladen. Erzeugt mithilfe des angegebenen IEqualityComparer<T> zum Vergleichen von Werten die Differenzmenge zweier Sequenzen. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkFirst<Char>()Überladen. Gibt das erste Element einer Sequenz zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkFirst<Char>(Func<Char, Boolean>)Überladen. Gibt das erste Element in einer Sequenz zurück, das eine angegebene Bedingung erfüllt. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkFirstOrDefault<Char>()Überladen. Gibt das erste Element einer Sequenz zurück, oder einen Standardwert, wenn die Sequenz keine Elemente enthält. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkFirstOrDefault<Char>(Func<Char, Boolean>)Überladen. Gibt das erste Element der Sequenz zurück, das eine Bedingung erfüllt, oder einen Standardwert, wenn ein solches Element nicht gefunden wird. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkGroupBy<Char, TKey>(Func<Char, TKey>)Überladen. Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkGroupBy<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)Überladen. Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und vergleicht die Schlüssel mithilfe eines angegebenen Vergleichs. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkGroupBy<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)Überladen. Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und projiziert die Elemente für jede Gruppe mithilfe einer angegebenen Funktion. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkGroupBy<Char, TKey, TResult>(Func<Char, TKey>, Func<TKey, IEnumerable<Char>, TResult>)Überladen. Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und erstellt aus jeder Gruppe und ihrem Schlüssel einen Ergebniswert. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkGroupBy<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)Überladen. Gruppiert die Elemente einer Sequenz entsprechend einer Schlüsselauswahlfunktion. Die Schlüssel werden mithilfe eines Vergleichs verglichen, und die Elemente jeder Gruppe werden mithilfe einer angegebenen Funktion projiziert. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkGroupBy<Char, TKey, TResult>(Func<Char, TKey>, Func<TKey, IEnumerable<Char>, TResult>, IEqualityComparer<TKey>)Überladen. Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und erstellt aus jeder Gruppe und ihrem Schlüssel einen Ergebniswert. Die Schlüssel werden mithilfe eines angegebenen Vergleichs verglichen. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkGroupBy<Char, TKey, TElement, TResult>(Func<Char, TKey>, Func<Char, TElement>, Func<TKey, IEnumerable<TElement>, TResult>)Überladen. Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und erstellt aus jeder Gruppe und ihrem Schlüssel einen Ergebniswert. Die Elemente jeder Gruppe werden mithilfe einer angegebenen Funktion projiziert. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkGroupBy<Char, TKey, TElement, TResult>(Func<Char, TKey>, Func<Char, TElement>, Func<TKey, IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)Überladen. Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und erstellt aus jeder Gruppe und ihrem Schlüssel einen Ergebniswert. Schlüsselwerte werden mithilfe eines angegebenen Vergleichs verglichen, und die Elemente jeder Gruppe werden mithilfe einer angegebenen Funktion projiziert. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkGroupJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, IEnumerable<TInner>, TResult>)Überladen. Korreliert die Elemente von zwei Sequenzen anhand der Gleichheit der Schlüssel und gruppiert die Ergebnisse. Schlüssel werden mithilfe des Standardgleichheitsvergleichs verglichen. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkGroupJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)Überladen. Korreliert die Elemente von zwei Sequenzen anhand der Gleichheit der Schlüssel und gruppiert die Ergebnisse. Schlüssel werden mithilfe eines angegebenen IEqualityComparer<T> verglichen. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkIntersect<Char>(IEnumerable<Char>)Überladen. Erzeugt die Schnittmenge zweier Sequenzen mithilfe des Standardgleichheitsvergleichs zum Vergleichen von Werten. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkIntersect<Char>(IEnumerable<Char>, IEqualityComparer<Char>)Überladen. Erzeugt mithilfe des angegebenen IEqualityComparer<T> zum Vergleichen von Werten die Schnittmenge von zwei Sequenzen. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, TInner, TResult>)Überladen. Korreliert die Elemente von zwei Sequenzen auf der Grundlage von übereinstimmenden Schlüsseln. Schlüssel werden mithilfe des Standardgleichheitsvergleichs verglichen. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, TInner, TResult>, IEqualityComparer<TKey>)Überladen. Korreliert die Elemente von zwei Sequenzen auf der Grundlage von übereinstimmenden Schlüsseln. Schlüssel werden mithilfe eines angegebenen IEqualityComparer<T> verglichen. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkLast<Char>()Überladen. Gibt das letzte Element einer Sequenz zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkLast<Char>(Func<Char, Boolean>)Überladen. Gibt das letzte Element einer Sequenz zurück, das eine angegebene Bedingung erfüllt. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkLastOrDefault<Char>()Überladen. Gibt das letzte Element einer Sequenz zurück, oder einen Standardwert, wenn die Sequenz keine Elemente enthält. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkLastOrDefault<Char>(Func<Char, Boolean>)Überladen. Gibt das letzte Element einer Sequenz zurück, das eine Bedingung erfüllt, oder einen Standardwert, wenn ein solches Element nicht gefunden wird. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkLongCount<Char>()Überladen. Gibt ein Int64 zurück, das die Gesamtanzahl der Elemente in einer Sequenz darstellt. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkLongCount<Char>(Func<Char, Boolean>)Überladen. Gibt ein Int64 zurück, das die Anzahl der Elemente in einer Sequenz darstellt, die eine Bedingung erfüllen. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMax<Char>()Überladen. Gibt den Höchstwert in einer generischen Sequenz zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMax<Char>(Func<Char, Int32>)Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den maximalen Int32-Wert zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMax<Char>(Func<Char, Nullable<Int32>>)Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den maximalen Int32-Wert zurück, der NULL-Werte zulässt. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMax<Char>(Func<Char, Int64>)Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den maximalen Int64-Wert zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMax<Char>(Func<Char, Nullable<Int64>>)Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den maximalen Int64-Wert zurück, der NULL-Werte zulässt. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMax<Char>(Func<Char, Single>)Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den maximalen Single-Wert zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMax<Char>(Func<Char, Nullable<Single>>)Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den maximalen Single-Wert zurück, der NULL-Werte zulässt. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMax<Char>(Func<Char, Double>)Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den maximalen Double-Wert zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMax<Char>(Func<Char, Nullable<Double>>)Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den maximalen Double-Wert zurück, der NULL-Werte zulässt. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMax<Char>(Func<Char, Decimal>)Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den maximalen Decimal-Wert zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMax<Char>(Func<Char, Nullable<Decimal>>)Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den maximalen Decimal-Wert zurück, der NULL-Werte zulässt. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMax<Char, TResult>(Func<Char, TResult>)Überladen. Ruft für jedes Element einer generischen Sequenz eine Transformationsfunktion auf und gibt den höchsten Ergebniswert zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMin<Char>()Überladen. Gibt den Mindestwert in einer generischen Sequenz zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMin<Char>(Func<Char, Int32>)Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den minimalen Int32-Wert zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMin<Char>(Func<Char, Nullable<Int32>>)Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den minimalen Int32-Wert zurück, der NULL-Werte zulässt. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMin<Char>(Func<Char, Int64>)Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den minimalen Int64-Wert zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMin<Char>(Func<Char, Nullable<Int64>>)Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den minimalen Int64-Wert zurück, der NULL-Werte zulässt. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMin<Char>(Func<Char, Single>)Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den minimalen Single-Wert zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMin<Char>(Func<Char, Nullable<Single>>)Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den minimalen Single-Wert zurück, der NULL-Werte zulässt. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMin<Char>(Func<Char, Double>)Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den minimalen Double-Wert zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMin<Char>(Func<Char, Nullable<Double>>)Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den minimalen Double-Wert zurück, der NULL-Werte zulässt. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMin<Char>(Func<Char, Decimal>)Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den minimalen Decimal-Wert zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMin<Char>(Func<Char, Nullable<Decimal>>)Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den minimalen Decimal-Wert zurück, der NULL-Werte zulässt. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkMin<Char, TResult>(Func<Char, TResult>)Überladen. Ruft für jedes Element einer generischen Sequenz eine Transformationsfunktion auf und gibt den niedrigsten Ergebniswert zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsOfType<TResult>Filtert die Elemente eines IEnumerable anhand eines angegebenen Typs. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkOrderBy<Char, TKey>(Func<Char, TKey>)Überladen. Sortiert die Elemente einer Sequenz in aufsteigender Reihenfolge nach einem Schlüssel. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkOrderBy<Char, TKey>(Func<Char, TKey>, IComparer<TKey>)Überladen. Sortiert die Elemente einer Sequenz mithilfe eines angegebenen Vergleichs in aufsteigender Reihenfolge. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkOrderByDescending<Char, TKey>(Func<Char, TKey>)Überladen. Sortiert die Elemente einer Sequenz in absteigender Reihenfolge nach einem Schlüssel. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkOrderByDescending<Char, TKey>(Func<Char, TKey>, IComparer<TKey>)Überladen. Sortiert die Elemente einer Sequenz mithilfe eines angegebenen Vergleichs in absteigender Reihenfolge. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkReverse<Char>Kehrt die Reihenfolge der Elemente in einer Sequenz um. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSelect<Char, TResult>(Func<Char, TResult>)Überladen. Projiziert jedes Element einer Sequenz in ein neues Format. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSelect<Char, TResult>(Func<Char, Int32, TResult>)Überladen. Projiziert jedes Element einer Sequenz in ein neues Format, indem der Index des Elements integriert wird. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSelectMany<Char, TResult>(Func<Char, IEnumerable<TResult>>)Überladen. Projiziert jedes Element einer Sequenz in ein IEnumerable<T> und fasst die resultierenden Sequenzen in einer einzigen Sequenz zusammen. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSelectMany<Char, TResult>(Func<Char, Int32, IEnumerable<TResult>>)Überladen. Projiziert jedes Element einer Sequenz in ein IEnumerable<T> und fasst die resultierenden Sequenzen zu einer einzigen Sequenz zusammen. Der Index jedes Quellelements wird im projizierten Format des jeweiligen Elements verwendet. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSelectMany<Char, TCollection, TResult>(Func<Char, Int32, IEnumerable<TCollection>>, Func<Char, TCollection, TResult>)Überladen. Projiziert jedes Element einer Sequenz in ein IEnumerable<T>, fasst die resultierenden Sequenzen zu einer einzigen Sequenz zusammen und ruft für jedes Element in dieser Sequenz eine Ergebnisauswahlfunktion auf. Der Index jedes Quellelements wird im projizierten Zwischenformat des jeweiligen Elements verwendet. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSelectMany<Char, TCollection, TResult>(Func<Char, IEnumerable<TCollection>>, Func<Char, TCollection, TResult>)Überladen. Projiziert jedes Element einer Sequenz in ein IEnumerable<T>, fasst die resultierenden Sequenzen zu einer einzigen Sequenz zusammen und ruft für jedes Element in dieser Sequenz eine Ergebnisauswahlfunktion auf. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSequenceEqual<Char>(IEnumerable<Char>)Überladen. Bestimmt, ob zwei Sequenzen gleich sind, indem die Elemente mithilfe des Standardgleichheitsvergleichs für ihren Typ verglichen werden. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSequenceEqual<Char>(IEnumerable<Char>, IEqualityComparer<Char>)Überladen. Bestimmt, ob zwei Sequenzen gleich sind, indem ihre Elemente mithilfe eines angegebenen IEqualityComparer<T> verglichen werden. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSingle<Char>()Überladen. Gibt das einzige Element einer Sequenz zurück und löst eine Ausnahme aus, wenn nicht genau ein Element in der Sequenz vorhanden ist. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSingle<Char>(Func<Char, Boolean>)Überladen. Gibt das einzige Element einer Sequenz zurück, das eine angegebene Bedingung erfüllt, und löst eine Ausnahme aus, wenn mehrere solche Elemente vorhanden sind. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSingleOrDefault<Char>()Überladen. Gibt das einzige Element einer Sequenz zurück oder einen Standardwert, wenn die Sequenz leer ist. Diese Methode löst eine Ausnahme aus, wenn mehrere Elemente in der Sequenz vorhanden sind. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSingleOrDefault<Char>(Func<Char, Boolean>)Überladen. Gibt das einzige Element einer Sequenz zurück, das eine angegebene Bedingung erfüllt, oder einen Standardwert, wenn kein solches Element vorhanden ist. Diese Methode löst eine Ausnahme aus, wenn mehrere Elemente die Bedingung erfüllen. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSkip<Char>Umgeht eine festgelegte Anzahl von Elementen in einer Sequenz und gibt dann die übrigen Elemente zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSkipWhile<Char>(Func<Char, Boolean>)Überladen. Umgeht Elemente in einer Sequenz, solange eine angegebene Bedingung true ist, und gibt dann die übrigen Elemente zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSkipWhile<Char>(Func<Char, Int32, Boolean>)Überladen. Umgeht Elemente in einer Sequenz, solange eine angegebene Bedingung true ist, und gibt dann die übrigen Elemente zurück. In der Logik der Prädikatfunktion wird der Index des Elements verwendet. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeSubscribe<Char>(IObserver<Char>)Überladen. (Durch Observable definiert.)
Öffentliche ErweiterungsmethodeSubscribe<Char>(IObserver<Char>, IScheduler)Überladen. (Durch Observable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSum<Char>(Func<Char, Int32>)Überladen. Berechnet die Summe einer Sequenz von Int32-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSum<Char>(Func<Char, Nullable<Int32>>)Überladen. Berechnet die Summe einer Sequenz von Int32-Werten, die NULL zulassen und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSum<Char>(Func<Char, Int64>)Überladen. Berechnet die Summe einer Sequenz von Int64-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSum<Char>(Func<Char, Nullable<Int64>>)Überladen. Berechnet die Summe einer Sequenz von Int64-Werten, die NULL zulassen und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSum<Char>(Func<Char, Single>)Überladen. Berechnet die Summe einer Sequenz von Single-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSum<Char>(Func<Char, Nullable<Single>>)Überladen. Berechnet die Summe einer Sequenz von Single-Werten, die NULL zulassen und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSum<Char>(Func<Char, Double>)Überladen. Berechnet die Summe einer Sequenz von Double-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSum<Char>(Func<Char, Nullable<Double>>)Überladen. Berechnet die Summe einer Sequenz von Double-Werten, die NULL zulassen und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSum<Char>(Func<Char, Decimal>)Überladen. Berechnet die Summe einer Sequenz von Decimal-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkSum<Char>(Func<Char, Nullable<Decimal>>)Überladen. Berechnet die Summe einer Sequenz von Decimal-Werten, die NULL zulassen und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkTake<Char>Gibt eine angegebene Anzahl von zusammenhängenden Elementen ab dem Anfang einer Sequenz zurück. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkTakeWhile<Char>(Func<Char, Boolean>)Überladen. Gibt Elemente aus einer Sequenz zurück, solange eine angegebene Bedingung true ist. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkTakeWhile<Char>(Func<Char, Int32, Boolean>)Überladen. Gibt Elemente aus einer Sequenz zurück, solange eine angegebene Bedingung true ist. In der Logik der Prädikatfunktion wird der Index des Elements verwendet. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkToArray<Char>Erstellt ein Array aus einem IEnumerable<T>. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkToDictionary<Char, TKey>(Func<Char, TKey>)Überladen. Erstellt ein Dictionary<TKey, TValue> aus einem IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkToDictionary<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)Überladen. Erstellt ein Dictionary<TKey, TValue> aus einem IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion und eines angegebenen Schlüsselvergleichs. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkToDictionary<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)Überladen. Erstellt ein Dictionary<TKey, TValue> aus einem IEnumerable<T> entsprechend der angegebenen Schlüsselauswahlfunktion und Elementauswahlfunktion. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkToDictionary<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)Überladen. Erstellt ein Dictionary<TKey, TValue> aus einem IEnumerable<T> entsprechend einer angegebenen Schlüsselauswahlfunktion, einem Vergleich und einer Elementauswahlfunktion. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkToList<Char>Erstellt eine List<T> aus einem IEnumerable<T>. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkToLookup<Char, TKey>(Func<Char, TKey>)Überladen. Erstellt ein Lookup<TKey, TElement> aus einem IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkToLookup<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)Überladen. Erstellt ein Lookup<TKey, TElement> aus einem IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion und eines angegebenen Schlüsselvergleichs. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkToLookup<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)Überladen. Erstellt ein Lookup<TKey, TElement> aus einem IEnumerable<T> entsprechend der angegebenen Schlüsselauswahlfunktion und Elementauswahlfunktion. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkToLookup<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)Überladen. Erstellt ein Lookup<TKey, TElement> aus einem IEnumerable<T> entsprechend einer angegebenen Schlüsselauswahlfunktion, einem Vergleich und einer Elementauswahlfunktion. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeToObservable<Char>()Überladen. (Durch Observable definiert.)
Öffentliche ErweiterungsmethodeToObservable<Char>(IScheduler)Überladen. (Durch Observable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkUnion<Char>(IEnumerable<Char>)Überladen. Erzeugt die Vereinigungsmenge von zwei Sequenzen mithilfe des Standardgleichheitsvergleichs. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkUnion<Char>(IEnumerable<Char>, IEqualityComparer<Char>)Überladen. Erzeugt mithilfe eines angegebenen IEqualityComparer<T> die Vereinigungsmenge von zwei Sequenzen. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkWhere<Char>(Func<Char, Boolean>)Überladen. Filtert eine Sequenz von Werten nach einem Prädikat. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeUnterstützt von XNA FrameworkWhere<Char>(Func<Char, Int32, Boolean>)Überladen. Filtert eine Sequenz von Werten nach einem Prädikat. In der Logik der Prädikatfunktion wird der Index der einzelnen Elemente verwendet. (Durch Enumerable definiert.)
Öffentliche ErweiterungsmethodeZip<Char, TSecond, TResult>Wendet eine Funktion auf die entsprechenden Elemente von zwei Sequenzen an und erzeugt eine Sequenz der Ergebnisse. (Durch Enumerable definiert.)
Zum Seitenanfang

  NameBeschreibung
Öffentliches FeldStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEmptyStellt die leere Zeichenfolge dar. Dieses Feld ist schreibgeschützt.
Zum Seitenanfang

  NameBeschreibung
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIComparable.CompareToVergleicht die aktuelle Instanz mit einem anderen Objekt vom selben Typ und gibt eine ganze Zahl zurück, die angibt, ob die aktuelle Instanz in der Sortierreihenfolge vor oder nach dem anderen Objekt oder an derselben Position auftritt.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToBooleanInfrastruktur. Eine Beschreibung dieses Members finden Sie unter der ToBoolean-Methode.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToByteInfrastruktur. Eine Beschreibung dieses Members finden Sie unter der ToByte-Methode.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToCharInfrastruktur. Eine Beschreibung dieses Members finden Sie unter der ToChar-Methode.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToDateTimeInfrastruktur. Eine Beschreibung dieses Members finden Sie unter der ToDateTime-Methode.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToDecimalInfrastruktur. Eine Beschreibung dieses Members finden Sie unter der ToDecimal-Methode.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToDoubleInfrastruktur. Eine Beschreibung dieses Members finden Sie unter der ToDouble-Methode.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToInt16Infrastruktur. Eine Beschreibung dieses Members finden Sie unter der ToInt16-Methode.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToInt32Infrastruktur. Eine Beschreibung dieses Members finden Sie unter der ToInt32-Methode.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToInt64Infrastruktur. Eine Beschreibung dieses Members finden Sie unter der ToInt64-Methode.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToSByteInfrastruktur. Eine Beschreibung dieses Members finden Sie unter der ToSByte-Methode.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToSingleInfrastruktur. Eine Beschreibung dieses Members finden Sie unter der ToSingle-Methode.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToTypeInfrastruktur. Eine Beschreibung dieses Members finden Sie unter der ToType-Methode.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToUInt16Infrastruktur. Eine Beschreibung dieses Members finden Sie unter der ToUInt16-Methode.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToUInt32Infrastruktur. Eine Beschreibung dieses Members finden Sie unter der ToUInt32-Methode.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToUInt64Infrastruktur. Eine Beschreibung dieses Members finden Sie unter der ToUInt64-Methode.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIEnumerable<Char>.GetEnumeratorGibt einen Enumerator zurück, der das aktuelle String-Objekt durchläuft.
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIEnumerable.GetEnumeratorGibt einen Enumerator zurück, der das aktuelle String-Objekt durchläuft.
Zum Seitenanfang

Eine Zeichenfolge ist eine sequenzielle Auflistung von Unicode-Zeichen, die zum Darstellen von Text verwendet wird. Ein String-Objekt ist eine sequenzielle Auflistung von System.Char-Objekten, die eine Zeichenfolge darstellen. Der Wert des String-Objekts ist der Inhalt der sequenziellen Auflistung und unveränderlich (d. h. schreibgeschützt). Weitere Informationen zu der Unveränderlichkeit von Zeichenfolgen finden Sie im Abschnitt Unveränderlichkeit und die StringBuilder-Klasse weiter unten in diesem Thema. Die Maximalgröße eines String-Objekts im Arbeitsspeicher ist 2 GB oder ungefähr 1 Milliarden Zeichen.

In diesem Abschnitt

Instanziieren eines Zeichenfolgenobjekts
Charobjekte und Unicode-Zeichen
Zeichenfolgen und eingebettete NULL-Zeichen
Zeichenfolgen und Indizes
NULL-Zeichenfolgen und leere Zeichenfolgen
Unveränderlichkeit und die StringBuilder-Klasse
Ordnungszahl für kulturabhängige Vorgänge
Normalisierung
Zeichenfolgenoperationen nach Kategorie

Instanziieren eines Zeichenfolgenobjekts

Sie können auf die folgende Weise ein String-Objekt instanziieren:

  • Durch das Zuweisen eines Zeichenfolgenliterals zu einer String-Variable. Dies ist die am häufigsten verwendete Methode zum Erstellen einer Zeichenfolge. Im folgenden Beispiel wird eine Zuweisung verwendet, um mehrere Zeichenfolgen zu erstellen. Beachten Sie, dass in C# literale umgekehrte Schrägstriche in einer Zeichenfolge mit Escapezeichen versehen oder die gesamte Zeichenfolge in @-Zeichen gesetzt werden muss, da der umgekehrte Schrägstrich ein Escapezeichen ist.

    
    string string1 = "This is a string created by assignment.";
    Console.WriteLine(string1);
    string string2a = "The path is C:\\PublicDocuments\\Report1.doc";
    Console.WriteLine(string2a);
    string string2b = @"The path is C:\PublicDocuments\Report1.doc";
    Console.WriteLine(string2b);
    // The example displays the following output:
    //       This is a string created by assignment.
    //       The path is C:\PublicDocuments\Report1.doc
    //       The path is C:\PublicDocuments\Report1.doc      
    
    
    
  • Durch Aufrufen eines String-Klassenkonstruktors Im folgenden Beispiel werden Zeichenfolgen instanziiert, indem mehrere Klassenkonstruktoren aufgerufen werden. Beachten Sie, dass einige der Konstruktoren Zeiger auf Zeichenarrays oder Bytearrays mit Vorzeichen als Parameter einschließen. Visual Basic unterstützt keine Aufrufe dieser Konstruktoren. Ausführliche Informationen über String finden Sie die Konstruktoren String-Konstruktorzusammenfassung.

    
    char[] chars = { 'w', 'o', 'r', 'd' };
    sbyte[] bytes = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
    // Create a string from a character array.
    string string1 = new string(chars);
    Console.WriteLine(string1);
    
    // Create a string that consists of a character repeated 20 times.
    string string2 = new string('c', 20);
    Console.WriteLine(string2);
    
    string stringFromBytes = null;
    string stringFromChars = null;
    unsafe
    {
       fixed (sbyte* pbytes = bytes)
       {
          // Create a string from a pointer to a signed byte array.
          stringFromBytes = new string(pbytes);
       }
       fixed (char* pchars = chars)
       {
          // Create a string from a pointer to a character array.
          stringFromChars = new string(pchars);
       }
    }
    Console.WriteLine(stringFromBytes);
    Console.WriteLine(stringFromChars);
    // The example displays the following output:
    //       word
    //       cccccccccccccccccccc
    //       ABCDE
    //       word  
    
    
    
  • Mit dem Zeichenfolgenverkettungsoperator ("+" in C# und "&" oder "+" in Visual Basic), um eine einzelne Zeichenfolge aus einer beliebigen Kombination von String-Instanzen und Zeichenfolgenliteralen zu erstellen. Das folgende Beispiel veranschaulicht die Verwendung des Operators für die Zeichenfolgenverkettung.

    
    string string1 = "Today is " + DateTime.Now.ToString("D") + ".";
    Console.WriteLine(string1);
    
    string string2 = "This is one sentence. " + "This is a second. ";
    string2 += "This is a third sentence.";
    Console.WriteLine(string2);
    // The example displays output like the following:
    //    Today is Tuesday, July 06, 2011.
    //    This is one sentence. This is a second. This is a third sentence.
    
    
    
  • Durch das Abrufen einer Eigenschaft oder Aufrufen einer Methode, die eine Zeichenfolge zurückgibt. Das folgende Beispiel wird eine Teilzeichenfolge mithilfe der Methoden der String-Klasse aus einer größeren Zeichenfolge extrahiert.

    
    string sentence = "This sentence has five words.";
    // Extract the second word.
    int startPosition = sentence.IndexOf(" ") + 1;
    string word2 = sentence.Substring(startPosition,
                                      sentence.IndexOf(" ", startPosition) - startPosition);
    Console.WriteLine("Second word: " + word2);
    // The example displays the following output:
    //       Second word: sentence
    
    
    
  • Durch das Aufrufen einer Formatierungsmethode, um einen Wert oder ein Objekt in seine Zeichenfolgendarstellung zu konvertieren. Im folgenden Beispiel wird die kombinierte Formatierung-Funktion, um die Zeichenfolgendarstellung von zwei Objekten in eine Zeichenfolge einzubetten.

    
    DateTime dateAndTime = new DateTime(2011, 7, 6, 7, 32, 0);
    double temperature = 68.3;
    string result = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                  dateAndTime, temperature);
    Console.WriteLine(result);
    // The example displays the following output:
    //       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.      
    
    
    

Charobjekte und Unicode-Zeichen

Jedes Zeichen in einer Zeichenfolge wird durch einen skalaren Unicode-Wert definiert, der auch als Unicode-Codepunkt oder Ordnungszahl (numerischer Wert) des Unicode-Zeichens bezeichnet wird. Jeder Codepunkt wird mit UTF-16 codiert, und der numerische Wert der einzelnen Elemente der Codierung wird durch ein Char-Objekt dargestellt.

Ein einzelnes Char-Objekt stellt i. d. R. einen einzelnen Codepunkt dar, d. h., der numerische Wert von Char ist gleich dem Codepunkt. Der Codepunkt für das Zeichen "a" ist z. B. U+0061. Für einen Codepunkt können aber auch mehrere codierte Elemente (mehr als ein Char-Objekt) erforderlich sein. Der Unicode-Standard definiert drei Typen von Zeichen, die mehreren Char-Objekten entsprechen: Grapheme, zusätzliche Unicode-Codepunkte und Zeichen in den zusätzlichen Ebenen.

  • Ein Graphem wird durch ein Basiszeichen dargestellt, auf das mindestens Kombinationszeichen folgt. Das Zeichen ä wird z. B. durch ein Char-Objekt dargestellt, dessen Codepunkt U+0061 ist, gefolgt von einem Char-Objekt, dessen Codepunkt U+0308 ist. Dieses Zeichen kann auch von einem einzelnen Char-Objekt definiert werden, das über einen Codepunkt von U+00E4 verfügt. Wie das folgende Beispiel zeigt, gibt ein kulturabhängiger Vergleich für Gleichheit an, dass diese zwei Darstellungen gleich sind, obwohl ein gewöhnlicher Ordinalvergleich dies nicht tut. Wenn die zwei Zeichenfolgen jedoch normalisiert werden, gibt ein Ordinalvergleich auch an, dass sie gleich sind. (Weitere Informationen zur Normalisierung von Zeichenfolgen finden Sie im Abschnitt Normalisierung .)

    
    using System;
    using System.Globalization;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\graphemes.txt");
          string grapheme = "\u0061\u0308";
          sw.WriteLine(grapheme);
    
          string singleChar = "\u00e4";
          sw.WriteLine(singleChar);
    
          sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.CurrentCulture));
          sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.Ordinal));
          sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme.Normalize(), 
                                     singleChar.Normalize(), 
                                     StringComparison.Ordinal));
          sw.Close(); 
       }
    }
    // The example produces the following output:
    //       ä
    //       ä
    //       ä = ä (Culture-sensitive): True
    //       ä = ä (Ordinal): False
    //       ä = ä (Normalized Ordinal): True
    
    
    
  • Ein ergänzender Unicode-Codepunkt (ein Ersatzzeichenpaar) wird durch ein Char-Objekt dargestellt, dessen Codepunkt ein hohes Ersatzzeichen gefolgt von einem Char-Objekt ist, dessen Codepunkt ein niedriges Ersatzzeichen ist. Die Codeeinheiten von hohen Ersatzzeichen reichen von U+D800 und U+DBFF. Die Codeeinheiten von Basismembern Ersatzzeichen reichen von U+DC00 und U+DFFF. Ersatzzeichenpaare werden verwendet, um Zeichen in den 16 zusätzlichen Unicode-Ebenen darzustellen. Im folgenden Beispiel wird ein Ersatzzeichenzeichen erstellt und an die Char.IsSurrogatePair(Char, Char)-Methode übergeben, um zu bestimmen, ob es ein Ersatzzeichenpaar ist.

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          string surrogate = "\uD800\uDC03";
          for (int ctr = 0; ctr < surrogate.Length; ctr++) 
             Console.Write("U+{0:X2} ", Convert.ToUInt16(surrogate[ctr]));
    
          Console.WriteLine();
          Console.WriteLine("   Is Surrogate Pair: {0}", 
                            Char.IsSurrogatePair(surrogate[0], surrogate[1]));
       }
    }
    // The example displays the following output:
    //       U+D800 U+DC03
    //          Is Surrogate Pair: True
    
    
    

Zeichenfolgen und eingebettete NULL-Zeichen

String -Objekte in .NET Framework können eingebettete NULL-Zeichen enthalten. Diese zählen zur Länge der Zeichenfolge. In einigen Sprachen wie C und C++ gibt ein NULL-Zeichen jedoch das Ende der Zeichenfolge an, wird nicht als Bestandteil der Zeichenfolge betrachtet und zählt nicht zur Länge der Zeichenfolge. Dies bedeutet, dass folgende allgemeinen Annahmen über Zeichenfolgen, die möglicherweise von C- und C++-Programmierern bzw. bei in C oder C++ verfassten Bibliotheken gemacht werden, nicht notwendigerweise für String-Objekte gelten:

  • Der von der strlen-Funktion oder der wcslen-Funktion zurückgegebene Wert entspricht nicht notwendigerweise String.Length.

  • Die von der strcpy_s-Funktion oder der wcscpy_s-Funktion erstellte Zeichenfolge entspricht nicht notwendigerweise der Zeichenfolge, die von der String.Copy-Methode erstellt wird.

Sie sollten sicherstellen, dass in systemeigenem C- und C++-Code, mit dem String-Objekte instanziiert werden, und Code, dem String-Objekte über Plattformaufrufe übergeben werden, nicht angenommen wird, dass ein eingebettetes NULL-Zeichen das Ende der Zeichenfolge kennzeichnet.

Eingebettete NULL-Zeichen in einer Zeichenfolge werden auch anders behandelt, wenn eine Zeichenfolge sortiert (oder verglichen) wird und wenn eine Zeichenfolge gesucht wird. Wenn Sie kultursensitive Vergleiche zwischen zwei Zeichenfolgen ausführen, werden Nullzeichen ignoriert, einschließlich Vergleiche mithilfe der invarianten Kultur. Sie werden nur für Ordnungszahlvergleiche verwendet oder auch für Ordnungszahlvergleiche, bei denen die Groß-/Kleinschreibung nicht beachtet wird. Andererseits werden eingebettete NULL-Zeichen bei der Suche nach einer Zeichenfolge immer berücksichtigt, wie z. B. Contains, StartsWith und IndexOf.

Zeichenfolgen und Indizes

Ein Index ist die Position eines Char-Objekt, nicht eines Unicode-Zeichens, in einem String. Ein Index ist eine nullbasierte, nicht negative Zahl beginnend an der ersten Position der Zeichenfolge, deren Indexposition null ist. Eine Reihe von Suchmethoden, z. B. IndexOf und LastIndexOf, gibt den Index eines Zeichens oder einer Teilzeichenfolge in der Zeichenfolgeninstanz zurück.

Die Chars-Eigenschaft lässt Sie auf einzelne Char-Objekte durch ihre Indexposition in der Zeichenfolge zugreifen. Da die Chars-Eigenschaft die Standardeigenschaft (in Visual Basic) oder der Indexer (in C#) ist, können Sie auf die einzelnen Char-Objekte in einer Zeichenfolge z. B. mit folgendem Code zugreifen. Dieser Code sucht in einer Zeichenfolge nach Leerzeichen oder Interpunktionszeichen, um zu bestimmen, wie viele Wörter die Zeichenfolge enthält.


using System;

public class Example
{
   public static void Main()
   {
      string s1 = "This string consists of a single short sentence.";
      int nWords = 0;

      s1 = s1.Trim();      
      for (int ctr = 0; ctr < s1.Length; ctr++) {
         if (Char.IsPunctuation(s1[ctr]) | Char.IsWhiteSpace(s1[ctr]))
            nWords++;              
      }
      Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                        s1, nWords);                                                                     
   }
}
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.


Da die String-Klasse die IEnumerable-Schnittstelle implementiert, können Sie auch die Char-Objekte in einer Zeichenfolge mit einem foreach-Konstrukt durchlaufen, wie das folgende Beispiel zeigt.


using System;

public class Example
{
   public static void Main()
   {
      string s1 = "This string consists of a single short sentence.";
      int nWords = 0;

      s1 = s1.Trim();      
      foreach (var ch in s1) {
         if (Char.IsPunctuation(ch) | Char.IsWhiteSpace(ch))
            nWords++;              
      }
      Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                        s1, nWords);                                                                     
   }
}
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.


Aufeinander folgende Indexwerte müssen nicht unbedingt aufeinander folgenden Unicode-Zeichen entsprechen, da ein Unicode-Zeichen als mehr als ein Char-Objekt codiert sein kann. Insbesondere enthält eine Zeichenfolge möglicherweise MULTIZeicheneinheiten Text, die von ein Basiszeichen gebildet werden, das aus einem oder mehreren Kombinationszeichen oder von Ersatzzeichenpaaren folgt. Um mit Unicode-Zeichen statt Char-Objekten zu arbeiten, verwenden Sie die System.Globalization.StringInfo-Klasse und TextElementEnumerator-Klasse. Im folgenden Beispiel wird der Unterschied zwischen Code, der mit Char-Objekten, und Code, der mit Unicode-Zeichen funktioniert, veranschaulicht. Die Anzahl der Zeichen oder Textelemente in jedem Wort eines Satzes werden verglichen. Die Zeichenfolge schließt zwei Sequenzen eines Basiszeichens ein, gefolgt von einem Zeichen ohne Zwischenraum.


using System;
using System.Collections.Generic;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // First sentence of The Mystery of the Yellow Room, by Leroux.
      string opening = "Ce n'est pas sans une certaine émotion que "+
                       "je commence à raconter ici les aventures " +
                       "extraordinaires de Joseph Rouletabille."; 
      // Character counters.
      int nChars = 0;
      // Objects to store word count.
      List<int> chars = new List<int>();
      List<int> elements = new List<int>();

      foreach (var ch in opening) {
         // Skip the ' character.
         if (ch == '\u0027') continue;

         if (Char.IsWhiteSpace(ch) | (Char.IsPunctuation(ch))) {
            chars.Add(nChars);
            nChars = 0;
         }
         else {
            nChars++;
         }
      }

      TextElementEnumerator te = StringInfo.GetTextElementEnumerator(opening);
      while (te.MoveNext()) {
         string s = te.GetTextElement();   
         // Skip the ' character.
         if (s == "\u0027") continue;
         if ( String.IsNullOrEmpty(s.Trim()) | (s.Length == 1 && Char.IsPunctuation(Convert.ToChar(s)))) {
            elements.Add(nChars);         
            nChars = 0;
         }
         else {
            nChars++;
         }
      }

      // Display character counts.
      Console.WriteLine("{0,6} {1,20} {2,20}",
                        "Word #", "Char Objects", "Characters"); 
      for (int ctr = 0; ctr < chars.Count; ctr++) 
         Console.WriteLine("{0,6} {1,20} {2,20}",
                           ctr, chars[ctr], elements[ctr]); 
   }
}
// The example displays the following output:
//       Word #         Char Objects           Characters
//            0                    2                    2
//            1                    4                    4
//            2                    3                    3
//            3                    4                    4
//            4                    3                    3
//            5                    8                    8
//            6                    8                    7
//            7                    3                    3
//            8                    2                    2
//            9                    8                    8
//           10                    2                    1
//           11                    8                    8
//           12                    3                    3
//           13                    3                    3
//           14                    9                    9
//           15                   15                   15
//           16                    2                    2
//           17                    6                    6
//           18                   12                   12


Dieses Beispiel funktioniert mit Textelementen, indem die StringInfo.GetTextElementEnumerator-Methode und die TextElementEnumerator-Klasse verwendet, um alle Textelemente in einer Zeichenfolge aufzulisten. Sie können ein Array auch abrufen, das den Startindex einzelnen Textelements enthält, indem die StringInfo.ParseCombiningCharacters-Methode aufruft.

Weitere Informationen zum Arbeiten mit Einheiten Text statt Einzelpersonen Char-Werte finden Sie die Klasse StringInfo.

NULL-Zeichenfolgen und leere Zeichenfolgen

Eine Zeichenfolge, die deklariert, der aber kein Wert zugewiesen wurde, ist null. Der Versuch, Methoden für diese Zeichenfolge abzurufen, löst eine NullReferenceException aus. Eine NULL-Zeichenfolge unterscheidet sich von einer leeren Zeichenfolge, die eine Zeichenfolge ist, deren Wert "" oder String.Empty ist. In einigen Fällen löst das Übergeben einer NULL-Zeichenfolge oder einer leeren Zeichenfolge als Argument in einem Methodenaufruf eine Ausnahme aus. Die Übergabe einer NULL-Zeichenfolge an die Int32.Parse-Methode löst z. B. eine ArgumentNullException aus, und die Übergabe einer leeren Zeichenfolge löst eine FormatException aus. In anderen Fällen kann ein Methodenargument entweder eine NULL-Zeichenfolge oder eine leere Zeichenfolge sein. Wenn Sie z. B. eine IFormattable-Implementierung für eine Klasse bereitstellen, möchten Sie sowohl eine NULL-Zeichenfolge als auch eine leere Zeichenfolge mit dem allgemeinen ("G") Formatbezeichner gleichsetzen.

Die String-Klasse schließt die folgenden zwei Hilfsmethoden ein, die Ihnen ermöglichen zu testen, ob eine Zeichenfolge null oder leer ist:

  • IsNullOrEmpty , die angibt, ob eine Zeichenfolge null oder gleich String.Empty ist. Mit dieser Methode muss z. B. folgender Code nicht verwendet werden:

    
    if (str == null || str.Equals(String.Empty))
    
    
    
  • IsNullOrWhiteSpace , die angibt, ob eine Zeichenfolge null ist, String.Empty entspricht oder ausschließlich aus Leerstellenzeichen besteht. Mit dieser Methode muss z. B. folgender Code nicht verwendet werden:

    
    if (str == null || str.Equals(String.Empty) || str.Trim().Equals(String.Empty))
    
    
    

Im folgenden Beispiel wird die IsNullOrEmpty-Methode in der IFormattable.ToString-Implementierung einer benutzerdefinierten Temperature-Klasse veranschaulicht. Die Methode unterstützt die Formatzeichenfolgen "G", "C", "F" und "K". Wenn eine leere Formatzeichenfolge oder eine Formatzeichenfolge, deren Wert null ist, an die Methode übergeben wird, wird ihr Wert in die "G"-Formatzeichenfolge geändert.


public string ToString(string format, IFormatProvider provider) 
{
   if (String.IsNullOrEmpty(format)) format = "G";  
   if (provider == null) provider = CultureInfo.CurrentCulture;

   switch (format.ToUpperInvariant())
   {
      // Return degrees in Celsius.    
      case "G":
      case "C":
         return temp.ToString("F2", provider) + "°C";
      // Return degrees in Fahrenheit.
      case "F": 
         return (temp * 9 / 5 + 32).ToString("F2", provider) + "°F";
      // Return degrees in Kelvin.
      case "K":   
         return (temp + 273.15).ToString();
      default:
         throw new FormatException(
               String.Format("The {0} format string is not supported.", 
                             format));
   }                                   
}


Unveränderlichkeit und die StringBuilder-Klasse

Ein String-Objekt wird unveränderlich (schreibgeschützt) genannt, weil dessen Wert nach dem Erstellen nicht mehr geändert werden kann. Methoden, die ein String-Objekt scheinbar ändern, geben in Wirklichkeit ein neues String-Objekt zurück, das die Änderung enthält.

Da Zeichenfolgen unveränderlich sind, können Zeichenfolgenbearbeitungsroutinen, die wiederkehrende Hinzufügungen oder Löschen werden, was wird, einer einzelnen Zeichenfolge sein, eine erhebliche Leistungseinbußen benötigen. Im folgenden Code wird z. B. ein Zufallsgenerator verwendet, um im Bereich 0x0001 bis 0x052F eine Zeichenfolge mit 1000 Zeichen zu erstellen. Obwohl der Code Zeichenfolgenverkettung zu verwenden scheint, um ein neues Zeichen an die vorhandene Zeichenfolge mit dem Namen str anzufügen scheint, erstellt er eigentlich ein neues String-Objekt für jeden Verkettungsvorgang.


using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();

      string str = String.Empty;
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                           false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         str += Convert.ToChar(rnd.Next(1, 0x0530)); 
         if (str.Length % 60 == 0)
            str += Environment.NewLine;          
      }                    
      sw.Write(str);
      sw.Close();
   }
}


Sie können die StringBuilder-Klasse statt der String-Klasse für Vorgänge, die mehrere Änderungen am Wert einer Zeichenfolge vornehmen, verwenden. Im Gegensatz zu Instanzen der String-Klasse sind StringBuilder-Objekte änderbar; wenn Sie Teilzeichenfolgen verketten, anfügen oder aus einer Zeichenfolge löschen, werden die Vorgänge für eine einzelne Zeichenfolge ausgeführt. Wenn Sie mit dem Ändern des Werts eines StringBuilder-Objekts fertig sind, können Sie seine StringBuilder.ToString-Methode aufrufen, um ihn in eine Zeichenfolge zu konvertieren. Im folgenden Beispiel wird die String ersetzt, mit der im vorherigen Beispiel 1000 Zufallszeichen im Bereich 0x0001 bis 0x052F mit einem StringBuilder-Objekt verkettet wurden.


using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      StringBuilder sb = new StringBuilder();
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                                         false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         sb.Append(Convert.ToChar(rnd.Next(1, 0x0530))); 
         if (sb.Length % 60 == 0)
            sb.AppendLine();          
      }                    
      sw.Write(sb.ToString());
      sw.Close();
   }
}


Ordnungszahl für kulturabhängige Vorgänge

Member der String-Klasse führen entweder Ordinalvorgänge oder kulturabhängige (linguistische) Vorgänge für ein String-Objekt aus. Bei einer Ordinaloperation wird der numerische Wert der einzelnen Char-Objekte verwendet. Bei einer kulturabhängigen Operation wird der Wert des String-Objekts verwendet, wobei kulturabhängige Regeln zur Groß- und Kleinschreibung, Sortierung, Formatierung und zum Analysieren berücksichtigt werden. Kulturabhängige Operationen werden im Kontext einer explizit deklarierten Kultur oder implizit mit der aktuellen Kultur ausgeführt. Die zwei Arten von Vorgängen können zu sehr verschiedenen Ergebnissen führen, wenn sie für die gleiche Zeichenfolge ausgeführt werden.

SicherheitshinweisSicherheitshinweis

Wenn in der Anwendung eine Sicherheitsentscheidung über einen Symbolbezeichner wie einen Dateinamen, eine benannte Pipe oder persistente Daten, z. B. textbasierte Daten in einer XML-Datei, durchgeführt wird, sollte bei dem Vorgang anstelle eines kulturabhängigen Vergleichs ein Ordinalvergleich verwendet werden. Die Ursache hierfür ist, dass ein kulturabhängiger Vergleich in Abhängigkeit von der gültigen Kultur unterschiedliche Ergebnisse liefern kann, während ein Ordinalvergleich lediglich vom Binärwert der verglichenen Zeichen abhängig ist.

Wichtiger HinweisWichtig

Die meisten Methoden, die Zeichenfolgenvorgänge ausführen, schließen eine Überladung ein, die über einen Parameter des Typs StringComparison verfügt, wodurch Sie angeben können, ob die Methode einen Ordinalvorgang oder einen kulturabhängigen Vorgang ausführt. Im Allgemeinen sollten Sie diese Überladung aufrufen, um die Absicht vom Methodenaufruf klar zu machen. Best Practices und Leitfaden zum Verwenden von Vorgängen mit Ordnungszahlen und kulturabhängigen Vorgängen für Zeichenfolgen finden Sie unter Empfohlene Vorgehensweisen für die Verwendung von Zeichenfolgen in .NET Framework.

Vorgänge für Umkleiden, Formatierung und Analyse, Vergleich und Sortierung und Tests für Gleichheit können entweder einem ordinalen oder kulturabhängig sein. In den folgenden Abschnitten wird jede Kategorie des Vorgangs erläutert.

s1wwdcbf.collapse_all(de-de,VS.110).gifGroß-/Kleinschreibung

Die Regeln zur Groß- und Kleinschreibung bestimmen, wie die Großschreibung eines Unicode-Zeichens, d. h. der Wechsel zwischen Groß- und Kleinbuchstaben, durchgeführt wird. Oft wird ein Groß-/Kleinschreibevorgang vor einem Zeichenfolgenvergleich ausgeführt. Eine Zeichenfolge könnte z. B. in Großschreibung konvertiert werden, damit sie mit einer anderen großgeschriebenen Zeichenfolge verglichen werden kann. Sie können die Zeichen in einer Zeichenfolge in Kleinbuchstaben konvertieren, indem Sie die ToLower-Methode oder ToLowerInvariant-Methode aufrufen, oder Sie können sie in Großbuchstaben konvertieren, indem Sie die ToUpper-Methode oder ToUpperInvariant-Methode aufrufen. Sie können außerdem mithilfe der TextInfo.ToTitleCase-Methode eine Zeichenfolge in große Anfangsbuchstaben konvertieren.

Groß-/Kleinschreibungsvorgänge können auf den Regeln der aktuellen Kultur, einer angegebenen Kultur oder der invarianten Kultur basieren. Da Schreibungszuordnungen abhängig von der verwendeten Kultur unterscheiden können, kann das Ergebnis der Groß-/Kleinschreibungs-Vorgänge nach Kultur unterscheiden. Die tatsächlichen Unterschiede in der Schreibung liegen in drei Arten:

  • Unterschiede in der Schreibungszuordnung von LATEINISCHER GROSSBUCHSTABE I (U+0049), LATEINISCHER KLEINBUCHSTABE I (U+0069), LATEINISCHER GROSSBUCHSTABE I MIT PUNKT OBEN (U+0130) und LATEINISCHER KLEINBUCHSTABE TÜRKISCHES I (U+0131). In den Kulturen tr-TR (Türkisch (Türkei)) und az-Latn-AZ (Aserbaidschan, Lateinisch) und in den neutralen Kulturen tr, az und az-Latn besteht die Kleinbuchstabenentsprechung von LATEINISCHER GROSSBUCHSTABE I in LATEINISCHER KLEINBUCHSTABE TÜRKISCHES I und die Großbuchstabenentsprechung von LATEINISCHER KLEINBUCHSTABE I in LATEINISCHER KLEINBUCHSTABENS I ist LATEINISCHER GROSSBUCHSTABE I MIT PUNKT OBEN. In allen anderen Kulturen einschließlich die invariante Kultur, sind LATEINISCHER KLEINBUCHSTABE I und LATEINISCHER GROSSBUCHSTABE I Entsprechungen in Klein- und Großbuchstaben.

    Das folgende Beispiel zeigt, wie ein Zeichenfolgenvergleich, die entworfen wird, um Dateisystemzugriff zu verhindern, fehlschlagen kann, wenn er auf einem kulturabhängigen Groß-/Kleinschreibungs-Vergleich beruht. (Die Groß- und Kleinschreibungskonventionen der invarianten Kultur sollten verwendet werden.)

    
    using System;
    using System.Globalization;
    using System.Threading;
    
    public class Example
    {
       const string disallowed = "file";
    
       public static void Main()
       {
          IsAccessAllowed(@"FILE:\\\c:\users\user001\documents\FinancialInfo.txt");
       }
    
       private static void IsAccessAllowed(String resource)
       {
          CultureInfo[] cultures = { CultureInfo.CreateSpecificCulture("en-US"),
                                     CultureInfo.CreateSpecificCulture("tr-TR") };
          String scheme = null;
          int index = resource.IndexOfAny( new Char[] { '\\', '/' } );
          if (index > 0) 
             scheme = resource.Substring(0, index - 1);
    
          // Change the current culture and perform the comparison.
          foreach (var culture in cultures) {
             Thread.CurrentThread.CurrentCulture = culture;
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName);
             Console.WriteLine(resource);
             Console.WriteLine("Access allowed: {0}", 
                               ! String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase));      
             Console.WriteLine();
          }   
       }
    }
    // The example displays the following output:
    //       Culture: English (United States)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: False
    //       
    //       Culture: Turkish (Turkey)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: True
    
    
    
  • Unterschiede bei Zuordnungen zwischen der invarianten Kultur und allen weiteren Kulturen. In diesen Fällen mit Regeln zur Groß-/Kleinschreibung der invarianten Kultur, ein Zeichen in Groß- bzw. Kleinbuchstaben zu ändern ist das gleiche Zeichen zurück. Für alle weiteren Kulturen gibt es ein Zeichen zurück. Einige der betroffenen Zeichen werden in der folgenden Tabelle aufgeführt.

    Zeichen

    Wenn Sie zu geändert werden

    Rückgabe

    MIKROMETERZEICHEN (U+00B5)

    Großbuchstaben

    GRIECHISCHER GROSSBUCHSTABE MU (U+-39C)

    LATEINISCHER GROSSBUCHSTABE I MIT PUNKT OBEN (U+0130)

    Kleinbuchstaben

    LATEINISCHER KLEINBUCHSTABE I (U+0069)

    LATEINISCHER KLEINBUCHSTABE TÜRKISCHES I (U+0131)

    Großbuchstaben

    LATEINISCHER GROSSBUCHSTABE I (U+0049)

    LATEINISCHER KLEINBUCHSTABE LANGES S (U+017F)

    Großbuchstaben

    LATEINISCHER GROSSBUCHSTABE S (U+0053)

    LATEINISCHER GROSSBUCHSTABE D MIT KLEINBUCHSTABE Z MIT CARON (U+01C5)

    Kleinbuchstaben

    LATEINISCHER KLEINBUCHSTABE DZ MIT CARON (U+01C6)

    KOMBINATION GRIECHISCHES YPOGEGRAMMENI (U+0345)

    Großbuchstaben

    GRIECHISCHER GROSSBUCHSTABE IOTA (U+0399)

  • Unterschiede, wie Zuordnungen für Großbuchstaben KombinierteFalls im ASCII-Zeichenbereich zuordnet. In den meisten Kulturen ist ein zweibuchstabiges KombinierteFallspaar gleich der entsprechenden der Groß-/Kleinschreibung in Groß- oder Kleinbuchstaben. Dies gilt nicht für die folgenden der Groß-/Kleinschreibung in den folgenden Kulturen, da in jedem Fall an Digraph verglichen werden:

    • "lJ" und "nJ" in (hr-HR Kroatisch (Kroatien)) Kultur.

    • "cH" cs-CZ (in der tschechisch (Tschechische Republik)) und sk-SK (slowakisch (Slowakei)) Kulturen.

    • "aa" da-DK in (dänisch (Dänemark)) Kultur.

    • "Cs", "DZ", "dZS", "nY", "SZ", "tY" und "zS" hu-HU in (ungarisch (Ungarn)) Kultur.

    • "cH" und "lL im" es-ES_tradnl (Spanisch (Spanien, herkömmliche Sortierreihenfolge)) Kultur.

    • "cH", "GI", "KH", "nG" "NH", "pH", "qU, "und "tR" vi-VN (in der vietnamesisch (Vietnam)) Kultur.

    Es ist jedoch außergewöhnlich, eine Situation auftreten, in der ein kulturabhängiger Vergleich dieser erstellt Probleme zuordnet, da diese von Paaren in festen Zeichenfolgen oder in Bezeichnern selten sind.

Im folgenden Beispiel werden einige der Unterschiede der Regeln zur Groß-/Kleinschreibung zwischen Kulturen beim Konvertieren von Zeichenfolgen in Großschreibung veranschaulicht.


using System;
using System.Globalization;
using System.IO;

public class Example
{
   public static void Main()
   {
      StreamWriter sw = new StreamWriter(@".\case.txt");   
      string[] words = { "file", "sıfır", "Dženana" };
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"),  
                                 new CultureInfo("tr-TR") };

      foreach (var word in words) {
         sw.WriteLine("{0}:", word);
         foreach (var culture in cultures) {
            string name = String.IsNullOrEmpty(culture.Name) ? 
                                 "Invariant" : culture.Name;
            string upperWord = word.ToUpper(culture);
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                         upperWord, ShowHexValue(upperWord));

         }
         sw.WriteLine();  
      }
      sw.Close();
   }

   private static string ShowHexValue(string s)
   {
      string retval = null;
      foreach (var ch in s) {
         byte[] bytes = BitConverter.GetBytes(ch);
         retval += String.Format("{0:X2} {1:X2} ", bytes[1], bytes[0]);     
      }
      return retval;
   } 
}
// The example displays the following output:
//    file:
//        Invariant:    FILE               00 46 00 49 00 4C 00 45 
//            en-US:    FILE               00 46 00 49 00 4C 00 45 
//            tr-TR:    FİLE               00 46 01 30 00 4C 00 45 
//    
//    sıfır:
//        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52 
//            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//    
//    Dženana:
//        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41 
//            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
//            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 


s1wwdcbf.collapse_all(de-de,VS.110).gifFormatierung und Analyse

Formatierung und Analyse sind umgekehrte Vorgänge. Formatierungsregeln bestimmen, wie ein Wert, z. B. ein Datum und eine Uhrzeit oder eine Zahl, zu seiner Zeichenfolgendarstellung konvertiert wird, wohingegen Analyseregeln bestimmen, wie eine Zeichenfolgendarstellung in einen Wert, z. B. ein Datum und eine Uhrzeit, konvertiert wird. Sowohl das Formatieren als auch Analysieren von Regeln ist von kulturellen Konventionen abhängig. Im folgenden Beispiel wird die Mehrdeutigkeit veranschaulicht, die beim Interpretieren einer kulturspezifischen Datumszeichenfolge entstehen kann. Ohne die Konventionen der Kultur zu kennen, die verwendet wurde, um eine Datumszeichenfolge zu erzeugen, ist es nicht möglich, zu wissen, ob 03/01/2011, 3/1/2011 und 01/03/2011 3. Januar 2011 oder 1. März 2011 darstellen.


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime date = new DateTime(2011, 3, 1);
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"), 
                                 new CultureInfo("fr-FR") };

      foreach (var culture in cultures)
         Console.WriteLine("{0,-12} {1}", String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.ToString("d", culture));                                    
   }
}
// The example displays the following output:
//       Invariant    03/01/2011
//       en-US        3/1/2011
//       fr-FR        01/03/2011


Ebenso kann, wie das folgende Beispiel zeigt, eine einzelne Zeichenfolge verschiedene Datumsangaben abhängig von der Kultur erzeugen, deren Konventionen im Analysevorgang verwendet werden.


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string dateString = "07/10/2011";
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 CultureInfo.CreateSpecificCulture("en-GB"), 
                                 CultureInfo.CreateSpecificCulture("en-US") };
      Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}\n", "Date String", "Culture", 
                                                 "Month", "Day");
      foreach (var culture in cultures) {
         DateTime date = DateTime.Parse(dateString, culture);
         Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                           String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.Month, date.Day);
      }                      
   }
}
// The example displays the following output:
//       Date String     Culture    Month      Day
//       
//       07/10/2011    Invariant        7       10
//       07/10/2011        en-GB       10        7
//       07/10/2011        en-US        7       10


s1wwdcbf.collapse_all(de-de,VS.110).gifZeichenfolgenvergleich und Sortierung

Konventionen zum Vergleichen und Sortieren von Zeichenfolgen hängt von Kultur zu Kultur. Zum Beispiel kann die Sortierung anhand der Phonetik oder der visuellen Darstellung von Zeichen. In ostasiatischen Sprachen werden Zeichen anhand der Anzahl der Striche und der Radikale der Ideogramme sortiert. Die Sortierung hängt außerdem von der Reihenfolge ab, die das Alphabet der jeweiligen Sprache bzw. Kultur aufweist. Im Dänischen gibt es beispielsweise das Zeichen "Æ", das im Alphabet nach dem Zeichen "Z" einsortiert ist. Außerdem können Vergleiche die Groß- und Kleinschreibung beachtet die Groß-/Kleinschreibung nicht beachtet werden muss, und in einigen Fällen unterscheiden sich Regeln zur Groß-/Kleinschreibung ebenfalls nach Kultur. Ordinalvergleich verwendet wiederum die Unicode-Codepunkte einzelner Zeichen in einer Zeichenfolge, sofern Zeichenfolgen verglichen und sortiert werden.

Sortierregeln legen die alphabetische Reihenfolge von Unicode-Zeichen sowie die Methode zum Vergleichen zweier Zeichenfolgen fest. Die String.Compare(String, String, StringComparison)-Methode vergleicht z. B. zwei Zeichenfolgen auf der Grundlage des StringComparison-Parameters. Wenn der Parameterwert StringComparison.CurrentCulture ist, führt die Methode einen linguistischen Vergleich aus, der die Konventionen der aktuellen Kultur verwendet; wenn der Parameterwert StringComparison.Ordinal ist, führt die Methode einen Ordinalvergleich aus. Folglich während das folgende Beispiel, wenn amerikanisches US-Englisch ist, der erste Aufruf der String.Compare(String, String, StringComparison)-Methode (mit dem kulturabhängige Vergleich) als "a" kleiner als "A" darstellt, und der zweite Aufruf der gleichen Methode (mithilfe eines ordinalen Vergleichs) "a" als größer als "A" betrachtet.


using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
      Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture));
      Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       1
//       -32


.NET Framework unterstützt Sortierregeln für Wörter, Zeichenfolgen und Ordnungszahlen:

  • Bei einer Wortsortierung wird ein kulturabhängiger Vergleich von Zeichenfolgen durchgeführt, bei dem bestimmten nicht alphanumerischen Unicode-Zeichen u. U. bestimmte Gewichtungen zugeordnet sind. Beispielsweise wird dem Bindestrich (-) ggf. eine sehr geringe Gewichtung zugeordnet, sodass "coop" und "co-op" in einer sortierten Liste nebeneinander angezeigt werden. Eine Liste der String, die Methoden vergleichen, sortieren zwei Zeichenfolgen mithilfe des Worts Regeln, finden Sie im Abschnitt Zeichenfolgenoperationen nach Kategorie.

  • Bei einer Zeichenfolgensortierung wird auch ein kulturabhängiger Vergleich ausgeführt. Sie ähnelt einer Wortsortierung mit dem Unterschied, dass es keine Sonderfälle gibt und alle nicht alphanumerischen Symbole vor allen alphanumerischen Unicode-Zeichen eingeordnet werden. Zwei Zeichenfolgen können mit Zeichenfolgensortierregeln verglichen werden, indem Sie die CompareInfo.Compare-Methodenüberladungen aufrufen, die über einen options-Parameter verfügen, für den der Wert CompareOptions.StringSort angegeben wird. Beachten Sie, dass dies die einzige Methode ist, die .NET Framework bereitstellt, um zwei Zeichenfolgen mit Zeichenfolgensortierregeln zu vergleichen.

  • Eine Ordinalsortierung vergleicht Zeichenfolgen anhand des numerischen Werts jedes Char-Objekts in der Zeichenfolge. Bei einem Ordinalvergleich wird automatisch die Groß- und Kleinschreibung berücksichtigt, da die groß- und kleingeschriebenen Varianten von Zeichen unterschiedliche Codepunkte besitzen. Wenn die Groß- und Kleinschreibung allerdings nicht relevant ist, können Sie einen Ordinalvergleich ohne Berücksichtigung von Groß- und Kleinschreibung angeben. Dies entspricht dem Konvertieren der Zeichenfolge in Großbuchstaben mithilfe der invarianten Kultur und dem anschließenden Ordinalvergleich mit dem Ergebnis. Eine Liste der Methoden String, in die zwei Zeichenfolgen mithilfe der Ordinalsortierregeln vergleichen, finden Sie im Abschnitt Zeichenfolgenoperationen nach Kategorie.

Ein kulturabhängiger Vergleich ist ein Vergleich, bei dem explizit oder implizit ein CultureInfo-Objekt einschließlich einer invarianten Kultur verwendet wird, die durch die CultureInfo.InvariantCulture-Eigenschaft angegeben wird. Die implizite Kultur ist die aktuelle Kultur, die von der Thread.CurrentCulture-Eigenschaft und CultureInfo.CurrentCulture-Eigenschaft angegeben wird. Es gibt bei Änderung der Sortierreihenfolge der alphabetischen Zeichen (das heißt, die Zeichen für die Char.IsLetter-Eigenschaft true zurückgibt), über Kulturen. Sie können einem kulturabhängigen Vergleich angeben, der die Konventionen einer bestimmten Kultur verwendet, indem ein CultureInfo-Objekt einer Zeichenfolgenvergleichsmethode wie Compare(String, String, CultureInfo, CompareOptions) angibt. Sie können einem kulturabhängigen Vergleich angeben, der die Konventionen der aktuellen Kultur verwendet, indem Sie StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase oder jedem Member der Enumeration CompareOptions als CompareOptions.Ordinal oder CompareOptions.OrdinalIgnoreCase in eine entsprechende Überladung der Compare-Methode angibt. Ein kulturabhängiger Vergleich ist im Allgemeinen zum Sortieren geeignet, während ein Ordinalvergleich nicht. Ein Ordinalvergleich ist im Allgemeinen für Situationen geeignet, ob zwei Zeichenfolgen gleich sind, also für das Bestimmen der Identität) während ein kulturabhängiger Vergleich nicht.

Das folgende Beispiel veranschaulicht den Unterschied zwischen einem kulturabhängigen und Ordinalvergleich. Im Ausdruck drei Zeichenfolgen, "Apple", "Æble" und "AEble", mit den Konventionen der da-DK- und en-US-Kulturen (von denen jede die Standardkultur ist, zum Zeitpunkt, das die Compare-Methode aufgerufen wird) sowie des ordinalen Vergleichs aus. Da die Dänisch Sprache das Zeichen "Æ" als einzelner Buchstabe behandelt und es im Alphabet nach "Z" einsortiert sortiert, lautet die Zeichenfolge "Æble" größer als "Apple". jedoch "Æble" wird nicht als äquivalent zu "AEble", sodass "Æble" ist zudem größer als "AEble". Die Kultur hat keinen Buchstaben Æ jedoch Festlichkeiten es als Entsprechung "AE", die erläutern, warum "Æble" kleiner als "Apple" jedoch gleich "AEble" ist. Ordinalvergleich betrachtet hingegen als "Apple" kleiner als "Æble", und ttto "Æble" befinden größer als "AEble".


using System;
using System.Globalization;
using System.Threading;

public class CompareStringSample
{
   public static void Main()
   {
      string str1 = "Apple";
      string str2 = "Æble"; 
      string str3 = "AEble";

      // Set the current culture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));

      // Set the current culture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));

      // Perform an ordinal comparison.
      Console.WriteLine("Ordinal comparison");
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, 
                        String.Compare(str1, str2, StringComparison.Ordinal));
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, 
                        String.Compare(str2, str3, StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       Current culture: da-DK
//       Comparison of Apple with Æble: -1
//       Comparison of Æble with AEble: 1
//       
//       Current culture: en-US
//       Comparison of Apple with Æble: 1
//       Comparison of Æble with AEble: 0
//       
//       Ordinal comparison
//       Comparison of Apple with Æble: -133
//       Comparison of Æble with AEble: 133


Verwenden Sie die folgenden allgemeinen Richtlinien, um eine entsprechende Zeichenfolgenvergleichsmethode Sortier- oder auszuwählen:

  • Wenn Sie die Zeichenfolgen nach die Kultur des Benutzers sortiert werden, sollten Sie sie auf der Konventionen der aktuellen Kultur sortieren. Wenn die Kultur des Benutzers ändert, wird die Reihenfolge der sortierten auch Zeichenfolgen entsprechend. Beispielsweise sollte eine Thesaurus-Anwendung Wörter auf Grundlage der Kultur des Benutzers immer sortieren.

  • Wenn Sie die Zeichenfolgen nach die Konventionen einer bestimmten Kultur sortiert werden, sollten Sie sie sortieren, indem Sie einem CultureInfo-Objekt angeben, das die Kultur an eine Vergleichsmethode darstellt. In einer Anwendung, die die Schüler, um eine bestimmte Sprache beizubringen, können Sie Zeichenfolgen auf Grundlage der Konventionen einer der Kulturen sortiert werden, die diese Sprache auf.

  • Wenn Sie die Reihenfolge von Zeichenfolgen soll, über Kulturen unverändert bleibt, sollten Sie sie entsprechend die Konventionen der invarianten Kultur sortieren oder einen Ordinalvergleich verwenden. Beispielsweise verwenden Sie eine Ordinalsortierung verwendet werden, um die Namen von Dateien, Prozessen, Mutexen oder von benannten Pipes zu organisieren.

  • Einen Vergleich, der eine Sicherheitsentscheidung einschließt (z, ob ein Benutzername gültig ist), sollten Sie einen Ordnungstest Gleichheit immer ausführen, indem Sie eine Überladung der Equals-Methode aufrufen.

HinweisHinweis

Die kulturabhängige Sortierung und die Regeln zur Groß-/Kleinschreibung, die in Zeichenfolgenvergleich verwendet werden, hängen von der Version von .NET Framework ab. In .NET Framework 4.5, das auf das Betriebssystem Windows 8 ausgeführt wird, entspricht Sortierung, Groß-/Kleinschreibung, Normalisierung und Unicode-Zeicheninformationen mit dem Unicode 5.1-Standard 6,0 an. Unter anderen Betriebssystemen entspricht er an den Unicode 5.1-Standard 5,0 an.

Weitere Informationen über die Regeln für das Sortieren nach Wörtern, Zeichenfolgen und Ordnungszahlen finden Sie unter dem Thema System.Globalization.CompareOptions. Zusätzliche Empfehlungen auf, wann jede Regel verwendet wird, finden Sie unter Empfohlene Vorgehensweisen für die Verwendung von Zeichenfolgen in .NET Framework.

Gewöhnlich rufen Sie keine Zeichenfolgenvergleichsmethoden wie Compare auf, um die Sortierreihenfolge von Zeichenfolgen direkt zu bestimmen. Stattdessen werden Vergleichsmethoden von Sortiermethoden, z. B. Array.Sort oder List<T>.Sort, aufgerufen. Im folgenden Beispiel werden vier verschiedene Sortiervorgänge (Wortsortierung mit der aktuellen Kultur, Wortsortierung mit der invarianten Kultur, Ordinalsortierung und Zeichenfolgen mit der invarianten Kultur) ohne eine Zeichenfolgenvergleichsmethode explizit aufzurufen aus, obwohl sie den Typ des Vergleichs angeben, die die Sortierung verwendet wird. Beachten Sie, dass jeder Sortiertyp eine eindeutige Reihenfolge von Zeichenfolgen im Array erzeugt.


using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] strings = { "coop", "co-op", "cooperative", 
                           "co\u00ADoperative", "cœur", "coeur" };

      // Perform a word sort using the current (en-US) culture.
      string[] current = new string[strings.Length]; 
      strings.CopyTo(current, 0); 
      Array.Sort(current, StringComparer.CurrentCulture);

      // Perform a word sort using the invariant culture.
      string[] invariant = new string[strings.Length];
      strings.CopyTo(invariant, 0); 
      Array.Sort(invariant, StringComparer.InvariantCulture);

      // Perform an ordinal sort.
      string[] ordinal = new string[strings.Length];
      strings.CopyTo(ordinal, 0); 
      Array.Sort(ordinal, StringComparer.Ordinal);

      // Perform a string sort using the current culture.
      string[] stringSort = new string[strings.Length];
      strings.CopyTo(stringSort, 0); 
      Array.Sort(stringSort, new SCompare());

      // Display array values
      Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}\n", 
                        "Original", "Word Sort", "Invariant Word", 
                        "Ordinal Sort", "String Sort");
      for (int ctr = 0; ctr < strings.Length; ctr++)
         Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                           strings[ctr], current[ctr], invariant[ctr], 
                           ordinal[ctr], stringSort[ctr] );          
   }
}

// IComparer<String> implementation to perform string sort.
internal class SCompare : IComparer<String>
{
   public int Compare(string x, string y)
   {
      return CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort);
   }
}
// The example displays the following output:
//         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort
//    
//             coop          cœur            cœur         co-op         co-op
//            co-op         coeur           coeur         coeur          cœur
//      cooperative          coop            coop          coop         coeur
//     co­operative         co-op           co-op   cooperative          coop
//             cœur   cooperative     cooperative  co­operative   cooperative
//            coeur  co­operative    co­operative          cœur  co­operative


TippTipp

Intern verwendet .NET Sortierschlüssel, um KulturellSENSITIVE-Zeichenfolgenvergleich zu unterstützen. Jedem Zeichen in einer Zeichenfolge sind mehrere Sortiergewichtungskategorien zugeordnet, darunter nach Skript, alphabetischer Folge, Groß-/Kleinschreibung und diakritischer Gewichtung. Ein Sortierschlüssel, dargestellt durch die SortKey-Klasse, stellt ein Repository für diese Gewichtungen für eine bestimmte Zeichenfolge bereit. Wenn die Anwendung viele Suchen oder Sortieroperationen mit denselben Satz von Zeichenfolgen ausgeführt wird, können Sie die Leistung verbessern, indem Sie für alle Zeichenfolgen Sortierschlüssel generiert und gespeichert, die sie verwendet. Wenn eine Sortierung oder ein Vergleich erforderlich ist, verwenden Sie die Sortierschlüssel anstelle der Zeichenfolgen. Weitere Informationen finden Sie in den Ausführungen zur SortKey-Klasse.

Wenn Sie keine Zeichenfolgenvergleichskonvention angeben, führen Sortiermethoden wie Array.Sort(Array) eine kulturabhängige, die Groß-/Kleinschreibung beachtet Sortierung auf Zeichenfolgen aus. Das folgende Beispiel veranschaulicht, wie das Ändern der aktuellen Kultur die Reihenfolge der sortierten Zeichenfolgen in einem Array aus. Sie erstellt ein Array mit drei Zeichenfolgen. Zuerst wird die System.Threading.Thread.CurrentThread.CurrentCulture-Eigenschaft auf "en-US" festgelegt, und die Array.Sort(Array)-Methode wird aufgerufen. Die sich daraus ergebende Sortierreihenfolge basiert auf den Sortierkonventionen für die Kultur Englisch (USA). Als Nächstes wird die System.Threading.Thread.CurrentThread.CurrentCulture-Eigenschaft auf "da-DK" festgelegt und die Array.Sort-Methode erneut aufgerufen. Die sich daraus ergebende Sortierreihenfolge unterscheidet sich von den Ergebnissen für "en-US", da die Sortierkonventionen für "Dänisch (Dänemark)" verwendet werden.


using System;
using System.Globalization;
using System.Threading;

public class ArraySort 
{
   public static void Main(String[] args) 
   {
      // Create and initialize a new array to store the strings.
      string[] stringArray = { "Apple", "Æble", "Zebra"};

      // Display the values of the array.
      Console.WriteLine( "The original string array:");
      PrintIndexAndValues(stringArray);

      // Set the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      // Sort the values of the array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"en-US\":");
      PrintIndexAndValues(stringArray); 

      // Set the CurrentCulture to "da-DK".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      // Sort the values of the Array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"da-DK\":");
      PrintIndexAndValues(stringArray); 
   }
   public static void PrintIndexAndValues(string[] myArray)  
   {
      for (int i = myArray.GetLowerBound(0); i <= 
            myArray.GetUpperBound(0); i++ )
         Console.WriteLine("[{0}]: {1}", i, myArray[i]);
      Console.WriteLine();      
   }
}
// The example displays the following output:
//       The original string array:
//       [0]: Apple
//       [1]: Æble
//       [2]: Zebra
//       
//       After sorting for the "en-US" culture:
//       [0]: Æble
//       [1]: Apple
//       [2]: Zebra
//       
//       After sorting for the culture "da-DK":
//       [0]: Apple
//       [1]: Zebra
//       [2]: Æble


WarnhinweisVorsicht

Wenn der primäre Zweck in vergleichenden Zeichenfolgen darin besteht, ihre Gleichheit bestimmen, sollten Sie die String.Equals-Methode aufrufen. Sie sollten in der Regel mithilfe von Equals einen Ordinalvergleich ausführen. Die String.Compare-Methode ist hauptsächlich dazu gedacht, Zeichenfolgen zu sortieren.

Zeichenfolgensuchmethoden, z. B. String.StartsWith und String.IndexOf, können auch kulturabhängige Vergleiche oder Ordinalvergleiche ausführen. Im folgenden Beispiel werden die Unterschiede zwischen Ordinalvergleichen und kulturabhängigen Vergleichen, die die IndexOf-Methode verwenden, veranschaulicht. Eine kulturabhängige Suche, in der die aktuelle Kultur Englisch (USA) ist, betrachtet die Teilzeichenfolge "oe" und die Ligatur "œ" als identisch. Da ein bedingter Bindestrich (U+00AD) ein Zeichen mit einer Breite von 0 (null) ist, behandelt die Suche den bedingten Bindestrich als Äquivalent zu Empty und sucht am Anfang der Zeichenfolge eine Übereinstimmung. Eine Ordinalsuche findet andererseits in keinem Fall eine Übereinstimmung.


using System;

public class Example
{
   public static void Main()
   {
      // Search for "oe" and "œu" in "œufs" and "oeufs".
      string s1 = "œufs";
      string s2 = "oeufs";
      FindInString(s1, "oe", StringComparison.CurrentCulture);
      FindInString(s1, "oe", StringComparison.Ordinal);
      FindInString(s2, "œu", StringComparison.CurrentCulture);
      FindInString(s2, "œu", StringComparison.Ordinal);
      Console.WriteLine();

      string s3 = "co\u00ADoperative";
      FindInString(s3, "\u00AD", StringComparison.CurrentCulture);
      FindInString(s3, "\u00AD", StringComparison.Ordinal);
   }

   private static void FindInString(string s, string substring, StringComparison options)
   {
      int result = s.IndexOf(substring, options);
      if (result != -1)
         Console.WriteLine("'{0}' found in {1} at position {2}", 
                           substring, s, result);
      else
         Console.WriteLine("'{0}' not found in {1}", 
                           substring, s);                                                  
   }
}
// The example displays the following output:
//       'oe' found in œufs at position 0
//       'oe' not found in œufs
//       'œu' found in oeufs at position 0
//       'œu' not found in oeufs
//       
//       '­' found in co­operative at position 0
//       '­' found in co­operative at position 2


s1wwdcbf.collapse_all(de-de,VS.110).gifSuchen von Zeichenfolgen

Suche- nach einer Zeichenfolgemethoden, wie String.StartsWith und String.IndexOf, können zu bestimmen Ordnungszeichenfolgenvergleiche ausführen kulturabhängige oder, ob einem Zeichen oder einer Teilzeichenfolge in einer angegebenen Zeichenfolge gefunden wird.

Suchmethoden können Sie die Suche nach einem Zeichen oder das von Zeichen in eine Zeichenfolge oder in die Suche nach einer Teilzeichenfolge in einer Zeichenfolge. Die Ermittlungsmethoden in der String, dass diese Suche für ein einzelnes Zeichen, wie die Methode IndexOf oder eine von Zeichen, wie der IndexOfAny die Möglichkeit, alle eine Ordnungssuche ausführen. Um eine kulturabhängige Suche nach einem Zeichen auszuführen, müssen Sie eine CompareInfo-Methode wie CompareInfo.IndexOf(String, Char) oder CompareInfo.LastIndexOf(String, Char) aufrufen. Beachten Sie, dass die Ergebnisse des Suchens für ein Zeichen, das einem ordinalen und kulturabhängige Vergleich verwendet, sehr unterscheiden können. So kann beispielsweise folgenden Filtern eine Suche für ein zuvor gebildetes Unicode-Zeichen wie die Verbindung "Æ" (U+00C6) jedes Vorkommen seiner Komponenten in der richtigen Reihenfolge, z "AE" (U+041U+0045), je nach Kultur ab. Im folgenden Beispiel wird der Unterschied zwischen String.IndexOf(Char) und den CompareInfo.IndexOf(String, Char)-Methoden bei der Suche für ein einzelnes Zeichen. Die Verbindung "æ" (U+00E6) wird in der Zeichenfolge "Antenne" gefunden, wenn die Konventionen der Kultur, die jedoch nicht verwendet, wenn die Konventionen der da-DK-Kultur oder beim Erstellen des ausführt, ordinalen Vergleichs verwendet.


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String[] cultureNames = { "da-DK", "en-US" };
      CompareInfo ci;
      String str = "aerial";
      Char ch = 'æ';  // U+00E6

      Console.Write("Ordinal comparison -- ");
      Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                        str.IndexOf(ch));

      foreach (var cultureName in cultureNames) {
         ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo;
         Console.Write("{0} cultural comparison -- ", cultureName);
         Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                           ci.IndexOf(str, ch));
      }
   }
}
// The example displays the following output:
//       Ordinal comparison -- Position of 'æ' in aerial: -1
//       da-DK cultural comparison -- Position of 'æ' in aerial: -1
//       en-US cultural comparison -- Position of 'æ' in aerial: 0


Andererseits führen String-Klassenmethoden, die nach einer Zeichenfolge suchen, nicht als ein Zeichen eine kulturabhängige Suche aus, wenn Suchoptionen nicht explizit durch einen Parameter des Typs StringComparison bereitgestellt werden. Die einzige Ausnahme ist Contains, die eine Ordnungssuche ausführt.

s1wwdcbf.collapse_all(de-de,VS.110).gifTests für Gleichheit

Verwenden Sie die String.Compare-Methode, um die Beziehung von zwei Zeichenfolgen in der Sortierreihenfolge zu bestimmen. In der Regel ist dies ein kulturabhängiger Vorgang. Rufen Sie im Gegensatz dazu die String.Equals-Methode auf, um auf Gleichheit zu testen. Da der Test für Gleichheit normalerweise Benutzereingabe mit einer bekannten Zeichenfolge, z. B. einem gültigen Benutzernamen, einem Kennwort oder einem Dateisystempfad, vergleicht, ist es in der Regel ein Ordinalvorgang.

WarnhinweisVorsicht

Es ist möglich, durch das Aufrufen der String.Compare-Methode und Bestimmen, ob der Rückgabewert 0 (null) ist, auf Gleichheit zu testen. Diese Vorgehensweise wird jedoch nicht empfohlen. Um zu bestimmen, ob zwei Zeichenfolgen gleich sind, sollten Sie eine der Überladungen der String.Equals-Methode aufrufen. Die aufzurufende bevorzugte Überladung ist entweder die Instanz-Equals(String, StringComparison)-Methode oder die statische Equals(String, String, StringComparison)-Methode, da beide Methoden einen System.StringComparison-Parameter einschließen, der den Typ des Vergleichs explizit angibt.

Im folgenden Beispiel wird die Gefahr veranschaulicht, einen kulturabhängigen Vergleich für Gleichheit auszuführen, wenn stattdessen ein Ordinalvergleich verwendet werden sollte. In diesem Fall soll der Code Dateisystemzugriff von URLs verhindern, die mit "FILE://" oder "file://" beginnen, indem ein Vergleich des Anfangs einer URL mit der Zeichenfolge "FILE://" ausgeführt wird, bei dem die Groß- und Kleinschreibung nicht berücksichtigt wird. Wenn jedoch ein kulturabhängiger Vergleich mithilfe der Kultur Türkisch (Türkei) für eine URL ausgeführt wird, die mit "file://" beginnt, schlägt der Vergleich auf Gleichheit fehl, weil die Entsprechung der türkischen Großschreibung vom Kleinbuchstaben "i" "İ" anstelle von "I" ist. Als Ergebnis wird Dateisystemzugriff versehentlich erlaubt. Andererseits ist, wenn ein Ordinalvergleich ausgeführt wird, der Vergleich für Gleichheit erfolgreich, und der Dateisystemzugriff wird verweigert.


using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR");      

      string filePath = "file://c:/notes.txt";

      Console.WriteLine("Culture-sensitive test for equality:");
      if (! TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);

      Console.WriteLine("\nOrdinal test for equality:");
      if (! TestForEquality(filePath, StringComparison.OrdinalIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);
   }

   private static bool TestForEquality(string str, StringComparison cmp)
   {
      int position = str.IndexOf("://");
      if (position < 0) return false;

      string substring = str.Substring(0, position);  
      return substring.Equals("FILE", cmp);
   }
}
// The example displays the following output:
//       Culture-sensitive test for equality:
//       Access to file://c:/notes.txt is allowed.
//       
//       Ordinal test for equality:
//       Access to file://c:/notes.txt is not allowed.


Normalisierung

Einige Unicode-Zeichen haben mehrere Darstellungen. Beispielsweise kann eine der folgenden Codepunkte den Buchstaben "ắ" darstellen:

  • U+1EAF

  • U+0103 U+0301

  • U+0061 U+0306 U+0301

Mehrere Darstellungen für ein einzelnes Zeichen führen zu Komplikationen bei Such-, Sortier-, Vergleichs- und anderen Zeichenfolgenoperationen.

Der Unicode-Standard definiert einen als Normalisierung bezeichneten Prozess, der eine binäre Darstellung eines Unicode-Zeichens für jede äquivalente binäre Darstellung dieses Zeichens zurückgibt. Die Normalisierung kann mehrere Algorithmen, so genannte Normalisierungsformen verwenden, die verschiedene Regeln einhalten. .NET Framework unterstützt die Unicode-Normalisierungsformen C, D, KC und KD. Wenn Zeichenfolgen zur gleichen Normalisierungsform normalisiert wurden, können sie mit dem Ordinalvergleich verglichen werden.

Ein Ordinalvergleich stellt einen Binärvergleich des Unicode-Skalarwerts des Entsprechens von Char-Objekten in jeder Zeichenfolge. Die String-Klasse umfasst mehrere Methoden, die einen Ordinalvergleich ausführen können, darunter die folgenden:

Sie können bestimmen, ob eine Zeichenfolge zur Normalisierungsform C normalisiert wird, indem die String.IsNormalized()-Methode aufgerufen wird, oder Sie können die String.IsNormalized(NormalizationForm)-Methode aufrufen, um zu bestimmen, ob eine Zeichenfolge zu einer angegebenen Normalisierungsform normalisiert wird. Sie können auch die String.Normalize()-Methode aufrufen, um eine Zeichenfolge zur Normalisierungsform C zu konvertieren, oder Sie können die String.Normalize(NormalizationForm)-Methode aufrufen, um eine Zeichenfolge in eine angegebene Normalisierungsform zu konvertieren. Ausführliche Informationen über das Normalisieren und das Vergleichen von Zeichenfolgen finden Sie die Methoden Normalize() und Normalize(NormalizationForm).

Das folgende einfache Beispiel veranschaulicht Zeichenfolgennormalisierung. Der Buchstabe "ố" wird auf drei verschiedene Arten in drei unterschiedliche Zeichenfolgen definiert und ein Ordinalvergleich auf Gleichheit verwendet, um zu bestimmen, dass sich jede Zeichenfolge von den anderen zwei Zeichenfolgen unterscheidet. Anschließend wird jede Zeichenfolge in die unterstützten Normalisierungsformen konvertiert und erneut ein Ordinalvergleich aller Zeichenfolgen in einer bestimmten Normalisierungsform ausgeführt. In jedem Fall zeigt der zweite Test für Gleichheit an, dass die Zeichenfolgen gleich sind.


using System;
using System.Globalization;
using System.IO;
using System.Text;

public class Example
{
   private static StreamWriter sw;

   public static void Main()
   {
      sw = new StreamWriter(@".\TestNorm1.txt");

      // Define three versions of the same word. 
      string s1 = "sống";        // create word with U+1ED1
      string s2 = "s\u00F4\u0301ng";
      string s3 = "so\u0302\u0301ng";

      TestForEquality(s1, s2, s3);      
      sw.WriteLine();

      // Normalize and compare strings using each normalization form.
      foreach (string formName in Enum.GetNames(typeof(NormalizationForm)))
      {
         sw.WriteLine("Normalization {0}:\n", formName); 
         NormalizationForm nf = (NormalizationForm) Enum.Parse(typeof(NormalizationForm), formName);
         string[] sn = NormalizeStrings(nf, s1, s2, s3);
         TestForEquality(sn);           
         sw.WriteLine("\n");                                        
      }

      sw.Close();   
   }

   private static void TestForEquality(params string[] words)
   {
      for (int ctr = 0; ctr <= words.Length - 2; ctr++)
         for (int ctr2 = ctr + 1; ctr2 <= words.Length - 1; ctr2++) 
            sw.WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words[ctr], ShowBytes(words[ctr]),
                         words[ctr2], ShowBytes(words[ctr2]),
                         words[ctr].Equals(words[ctr2], StringComparison.Ordinal));
   }

   private static string ShowBytes(string str)
   {
      string result = null;
      foreach (var ch in str)
         result += String.Format("{0} ", Convert.ToUInt16(ch).ToString("X4")); 
      return result.Trim();            
   } 

   private static string[] NormalizeStrings(NormalizationForm nf, params string[] words)
   {
      for (int ctr = 0; ctr < words.Length; ctr++)
         if (! words[ctr].IsNormalized(nf))
            words[ctr] = words[ctr].Normalize(nf); 
      return words;   
   }
}
// The example displays the following output:
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
//       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       
//       Normalization FormC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       
//       
//       Normalization FormKC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormKD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True


Weitere Informationen zur Normalisierung und Normalisierungsformen finden Sie unter System.Text.NormalizationForm sowie Unicode-Standard-Anhang Annex: Unicode-Normalisierungsformen und die Normalisierung FAQ Website unicode.org- an.

Zeichenfolgenoperationen nach Kategorie

Die String-Klasse stellt Member zum Vergleichen von Zeichenfolgen, Testen von Zeichenfolgen auf Gleichheit, Suchen von Zeichen oder Teilzeichenfolgen in einer Zeichenfolge, Ändern einer Zeichenfolge, Extrahieren von Teilzeichenfolgen aus einer Zeichenfolge, Kombinieren von Zeichenfolgen, Formatieren von Werten, Kopieren einer Zeichenfolge und Normalisieren einer Zeichenfolge bereit.

s1wwdcbf.collapse_all(de-de,VS.110).gifVergleichen von Zeichenfolgen

Sie können Zeichenfolgen vergleichen, um ihre relative Position in der Sortierreihenfolge mit den folgenden String-Methoden zu bestimmen:

  • Compare gibt eine ganze Zahl zurück, die die Beziehung von einer Zeichenfolge mit einer zweiten Zeichenfolge in der Sortierreihenfolge angibt.

  • CompareOrdinal gibt eine ganze Zahl zurück, die die Beziehung von einer Zeichenfolge mit einer zweiten Zeichenfolge auf Grundlage eines Vergleiches ihrer Codepunkte angibt.

  • CompareTo gibt eine ganze Zahl zurück, die die Beziehung der aktuellen Zeichenfolgeninstanz mit einer zweiten Zeichenfolge in der Sortierreihenfolge angibt. Die CompareTo(String)-Methode stellt die IComparable- und IComparable<T>-Implementierung für die String-Klasse bereit.

s1wwdcbf.collapse_all(de-de,VS.110).gifTestszeichenfolgen Gleichheit

Sie rufen die Equals-Methode auf, um zu bestimmen, ob zwei Zeichenfolgen identisch sind. Die Instanz Equals(String, String, StringComparison) und die statischen Equals(String, StringComparison)-Überladungen lassen Sie angeben, ob der Vergleich kulturabhängig oder ordinal ist, und ob die Groß- und Kleinschreibung beachtet oder ignoriert wird. Die meisten Tests auf Gleichheit sind ordinal. Vergleiche auf Gleichheit, die Zugriff auf eine Systemressource (z. B. ein Dateisystemobjekt) bestimmen, sollten immer ordinal sein.

s1wwdcbf.collapse_all(de-de,VS.110).gifSuchen der Zeichen in einer Zeichenfolge

Die String-Klasse schließt zwei Arten von Suchmethoden ein:

  • Methoden, die einen Boolean-Wert zurückgeben, um anzugeben, ob eine bestimmte Teilzeichenfolge in einer Zeichenfolgeninstanz vorhanden ist. Dazu gehören die Methoden Contains, EndsWith und StartsWith.

  • Methoden, die die Anfangsposition von einer Teilzeichenfolge in einer Zeichenfolgeninstanz angeben. Dazu gehören die Methoden IndexOf, IndexOfAny, LastIndexOf und LastIndexOfAny.

WarnhinweisVorsicht

Wenn Sie eine Zeichenfolge für ein bestimmtes Muster anstelle einer bestimmten Teilzeichenfolge suchen möchten, sollten Sie reguläre Ausdrücke verwenden. Weitere Informationen finden Sie unter Reguläre Ausdrücke von .NET Framework.

s1wwdcbf.collapse_all(de-de,VS.110).gifÄndern einer Zeichenfolge

Die String-Klasse schließt die folgenden Methoden ein, die den Wert einer Zeichenfolge zu ändern scheinen:

  • Insert fügt eine Zeichenfolge in die aktuelle String-Instanz ein.

  • PadLeft fügt ein oder mehrere Vorkommen eines angegebenen Zeichens am Anfang einer Zeichenfolge ein.

  • PadRight fügt ein oder mehrere Vorkommen eines angegebenen Zeichens am Anfang einer Zeichenfolge ein.

  • Remove löscht eine Teilzeichenfolge aus der aktuellen String-Instanz.

  • Replace ersetzt eine Teilzeichenfolge in der aktuellen String-Instanz durch eine andere Teilzeichenfolge.

  • ToLower und ToLowerInvariant konvertieren alle Zeichen in einer Zeichenfolge in Kleinbuchstaben.

  • ToUpper und ToUpperInvariant konvertieren alle Zeichen in einer Zeichenfolge in Großbuchstaben.

  • Trim entfernt alle Vorkommen eines Zeichens vom Anfang und dem Ende einer Zeichenfolge.

  • TrimEnd entfernt alle Vorkommen eines Zeichens vom Ende einer Zeichenfolge.

  • TrimStart entfernt alle Vorkommen eines Zeichens vom Anfang einer Zeichenfolge.

Wichtiger HinweisWichtig

Alle Zeichenfolgenänderungsmethoden geben ein neues String-Objekt zurück. Sie ändern den Wert der aktuellen Instanz nicht.

s1wwdcbf.collapse_all(de-de,VS.110).gifExtrahieren von Teilzeichenfolgen in einer Zeichenfolge

Die String.Split-Methode trennt eine einzelne Zeichenfolge in mehrere Zeichenfolgen. Überladungen der Methode ermöglichen es Ihnen, mehrere Trennzeichen anzugeben, um die maximale Anzahl von Teilzeichenfolgen zu bestimmen, die die Methode extrahiert, und zu bestimmen, ob leere Zeichenfolgen (die auftreten, wenn Trennzeichen nebeneinander liegen) in den zurückgegebenen Zeichenfolgen enthalten sind.

s1wwdcbf.collapse_all(de-de,VS.110).gifKombination von Zeichenfolgen

Die folgenden String-Methoden können für Zeichenfolgenverkettung verwendet werden:

  • Concat kombiniert eine oder mehrere Teilzeichenfolgen in einer einzelnen Zeichenfolge.

  • Join verkettet Teilzeichenfolgen in ein einzelnes Element und fügt ein Trennzeichen zwischen jeder Teilzeichenfolge hinzu.

s1wwdcbf.collapse_all(de-de,VS.110).gifFormatierungswerte

Die String.Format-Methode verwendet die kombinierte Formatierungsfunktion, um einen oder mehrere Platzhalter in einer Zeichenfolge durch die Zeichenfolgendarstellung eines Objekts oder Werts zu ersetzen. Die Format-Methode wird oft verwendet, um wie folgt vorzugehen:

  • Um die Zeichenfolgendarstellung eines numerischen Werts in eine Zeichenfolge einzubetten.

  • Um die Zeichenfolgendarstellung eines Datums- und Uhrzeitwerts in eine Zeichenfolge einzubetten.

  • Um die Zeichenfolgendarstellung eines Enumerationswerts in eine Zeichenfolge einzubetten.

  • Um die Zeichenfolgendarstellung eines Objekts einzubetten, das die IFormattable-Schnittstelle in einer Zeichenfolge unterstützt.

  • Um eine Teilzeichenfolge in einer größeren Zeichenfolge linksbündig oder rechtsbündig auszurichten.

Ausführliche Informationen zu veranschaulicht und Beispiele finden Sie die Format Überladungszusammenfassung.

s1wwdcbf.collapse_all(de-de,VS.110).gifKopieren einer Zeichenfolge

Sie können die folgenden String-Methoden aufrufen, um eine Kopie einer Zeichenfolge zu erstellen:

  • Clone gibt einen Verweis auf ein vorhandenes String-Objekt zurück.

  • Copy erstellt eine Kopie einer vorhandenen Zeichenfolge.

  • CopyTo kopiert einen Teil einer Zeichenfolge in ein Zeichenarray.

s1wwdcbf.collapse_all(de-de,VS.110).gifNormalisieren einer Zeichenfolge

In Unicode kann ein einzelnes Zeichen mehrere Codepunkte haben. Normalisierung konvertiert diese äquivalenten Zeichen in die gleiche binäre Darstellung. Die String.Normalize-Methode führt die Normalisierung aus, und die String.IsNormalized-Methode bestimmt, ob eine Zeichenfolge normalisiert wird.

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

Dieser Typ ist threadsicher.

Fanden Sie dies hilfreich?
(1500 verbleibende Zeichen)
Vielen Dank für Ihr Feedback.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft