Markieren Sie das Kontrollkästchen Englisch, um die englische Version dieses Artikels anzuzeigen. Sie können den englischen Text auch in einem Popup-Fenster einblenden, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch
Diese Dokumentation wurde archiviert und wird nicht länger gepflegt.

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 FrameworkString(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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifString(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 FrameworkString(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 FrameworkString(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 FrameworkString(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 Position des ersten Zeichens 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 Position des ersten Zeichens innerhalb dieses Arrays, eine Länge und ein Encoding-Objekt angegeben wird.
Zum Seitenanfang

  NameBeschreibung
Öffentliche EigenschaftUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifCharsRuft das Char-Objekt an einer angegebenen Zeichenposition innerhalb des aktuellen String-Objekts ab.
Öffentliche EigenschaftUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifLengthRuft 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 FrameworkCompare(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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifCompare(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 Members1wwdcbf.PortableClassLibrary(de-de,VS.100).gifCompare(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 FrameworkCompare(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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifCompare(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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifCompareOrdinal(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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifCompareOrdinal(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 FrameworkCompareTo(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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifConcat(Object)Erstellt die Zeichenfolgendarstellung eines angegebenen Objekts.
Öffentliche MethodeStatischer MemberUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifConcat(Object[])Verkettet die Zeichenfolgendarstellungen der Elemente in einem angegebenen Object-Array.
Öffentliche MethodeStatischer MemberConcat(IEnumerable<String>)Verkettet die Member einer erstellten IEnumerable<T>-Auflistung vom Typ String.
Öffentliche MethodeStatischer MemberUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifConcat(String[])Verkettet die Elemente eines angegebenen String-Arrays.
Öffentliche MethodeStatischer MemberUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifConcat(Object, Object)Verkettet die Zeichenfolgendarstellungen zweier angegebener Objekte.
Öffentliche MethodeStatischer MemberUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifConcat(String, String)Verkettet zwei angegebene Instanzen von String.
Öffentliche MethodeStatischer MemberUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifConcat(Object, Object, Object)Verkettet die Zeichenfolgendarstellungen von drei angegebenen Objekten.
Öffentliche MethodeStatischer MemberUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifConcat(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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifConcat(String, String, String, String)Verkettet vier angegebene Instanzen von String.
Öffentliche MethodeStatischer MemberConcat<T>(IEnumerable<T>)Verkettet die Member einer IEnumerable<T>-Implementierung.
Öffentliche MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifContainsGibt einen Wert zurück, der angibt, ob das angegebene String-Objekt 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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifCopyToKopiert 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 FrameworkEndsWith(String)Bestimmt, ob das Ende dieser Zeichenfolgeninstanz mit der angegebenen Zeichenfolge übereinstimmt.
Öffentliche MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifEndsWith(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 kulturspezifischen Information mit der angegebenen Zeichenfolge übereinstimmt.
Öffentliche MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifEquals(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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifEquals(String)Bestimmt, ob diese Instanz und ein anderes angegebenes String-Objekt denselben Wert haben.
Öffentliche MethodeStatischer MemberUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifEquals(String, String)Bestimmt, ob zwei angegebene String-Objekte denselben Wert haben.
Öffentliche MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifEquals(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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifEquals(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.
Geschützte MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifFinalize Gibt einem Objekt Gelegenheit, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird. (Von Object geerbt.)
Ö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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifFormat(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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifFormat(IFormatProvider, String, Object[])Ersetzt das Formatelement in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung eines entsprechenden Objekts in einem angegebenen Array. Ein angegebener 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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifGetHashCodeGibt den Hashcode für diese Zeichenfolge zurück. (Überschreibt Object.GetHashCode().)
Öffentliche MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifGetTypeRuft den Type der aktuellen Instanz ab. (Von Object geerbt.)
Öffentliche MethodeUnterstützt von XNA FrameworkGetTypeCodeGibt TypeCode für die String-Klasse zurück.
Öffentliche MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifIndexOf(Char)Gibt den Index des ersten Vorkommens des angegebenen Unicode-Zeichens in dieser Zeichenfolge an.
Öffentliche MethodeUnterstützt von XNA FrameworkIndexOf(String)Gibt den Index des ersten Vorkommens der angegebenen Zeichenfolge in dieser Instanz an.
Öffentliche MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifIndexOf(Char, Int32)Gibt den Index des ersten Vorkommens des angegebenen Unicode-Zeichens in dieser Zeichenfolge an. Die Suche beginnt an einer angegebenen Zeichenposition.
Öffentliche MethodeUnterstützt von XNA FrameworkIndexOf(String, Int32)Gibt den Index des ersten Vorkommens der angegebenen Zeichenfolge in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition.
Öffentliche MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifIndexOf(String, StringComparison)Gibt den 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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifIndexOf(Char, Int32, Int32)Gibt den 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 FrameworkIndexOf(String, Int32, Int32)Gibt den 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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifIndexOf(String, Int32, StringComparison)Gibt den 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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifIndexOf(String, Int32, Int32, StringComparison)Gibt den 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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifIndexOfAny(Char[])Gibt den Index des ersten Vorkommens eines beliebigen Zeichens aus einem angegebenen Array von Unicode-Zeichen in dieser Instanz an.
Öffentliche MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifIndexOfAny(Char[], Int32)Gibt den 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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifIndexOfAny(Char[], Int32, Int32)Gibt den 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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifInsertFügt eine angegebene Instanz von String an einer angegebenen Indexposition in diese Instanz ein.
Ö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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifIsNullOrEmptyGibt an, ob die angegebene Zeichenfolge null oder eine Empty-Zeichenfolge ist.
Öffentliche MethodeStatischer MemberIsNullOrWhiteSpaceGibt an, ob eine angegebene Zeichenfolge null ist, leer ist oder nur aus Leerzeichen besteht.
Öffentliche MethodeStatischer MemberJoin(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 MemberJoin(String, Object[])Verkettet die Elemente eines Objektarrays und verwendet das angegebene Trennzeichen zwischen den einzelnen Elementen.
Öffentliche MethodeStatischer MemberUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifJoin(String, String[])Verkettet alle Elemente eines Zeichenfolgenarrays und verwendet das angegebene Trennzeichen zwischen den einzelnen Elementen.
Öffentliche MethodeStatischer MemberUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifJoin(String, String[], Int32, Int32)Verkettet die angegebenen Elemente eines Zeichenfolgenarrays und verwendet das angegebene Trennzeichen zwischen den einzelnen Elementen.
Öffentliche MethodeStatischer MemberJoin<T>(String, IEnumerable<T>)Verkettet die Member einer Auflistung und verwendet das angegebene Trennzeichen zwischen den einzelnen Membern.
Öffentliche MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifLastIndexOf(Char)Gibt die Indexposition des letzten Vorkommens eines angegebenen Unicode-Zeichens in dieser Instanz an.
Öffentliche MethodeUnterstützt von XNA FrameworkLastIndexOf(String)Gibt die Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an.
Öffentliche MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifLastIndexOf(Char, Int32)Gibt die Indexposition des letzten Vorkommens eines angegebenen Unicode-Zeichens in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition.
Öffentliche MethodeUnterstützt von XNA FrameworkLastIndexOf(String, Int32)Gibt die Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition.
Öffentliche MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifLastIndexOf(String, StringComparison)Gibt den 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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifLastIndexOf(Char, Int32, Int32)Gibt die Indexposition des letzten Vorkommens des angegebenen Unicode-Zeichens in einer Teilzeichenfolge 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 FrameworkLastIndexOf(String, Int32, Int32)Gibt die Indexposition des letzten Vorkommens einer 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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifLastIndexOf(String, Int32, StringComparison)Gibt den Index des letzten Vorkommens einer 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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifLastIndexOf(String, Int32, Int32, StringComparison)Gibt die Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz 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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifLastIndexOfAny(Char[])Gibt die Indexposition des letzten Vorkommens eines oder mehrerer angegebener Zeichen eines Unicode-Arrays in dieser Instanz an.
Öffentliche MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifLastIndexOfAny(Char[], Int32)Gibt die Indexposition des letzten Vorkommens eines oder mehrerer angegebener Zeichen eines Unicode-Arrays in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition.
Öffentliche MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifLastIndexOfAny(Char[], Int32, Int32)Gibt die Indexposition des letzten Vorkommens eines oder mehrerer angegebener Zeichen eines Unicode-Arrays in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition, und es wird eine angegebene Anzahl von Zeichenpositionen überprüft.
Geschützte MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifMemberwiseCloneErstellt eine flache Kopie des aktuellen Object. (Von Object geerbt.)
Ö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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifPadLeft(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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifPadLeft(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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifPadRight(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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifPadRight(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 MethodeRemove(Int32)Löscht alle Zeichen aus dieser Zeichenfolge, beginnend an einer angegebenen Position bis zur letzten Position.
Öffentliche MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifRemove(Int32, Int32)Löscht die angegebene Anzahl von Zeichen ab der angegebenen Position aus dieser Instanz.
Öffentliche MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifReplace(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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifReplace(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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifSplit(Char[])Gibt ein Zeichenfolgenarray zurück, das die Teilzeichenfolgen dieser Instanz enthält, die durch Elemente eines angegebenen Unicode-Zeichenarrays getrennt sind.
Öffentliche MethodeSplit(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 Methodes1wwdcbf.PortableClassLibrary(de-de,VS.100).gifSplit(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 Methodes1wwdcbf.PortableClassLibrary(de-de,VS.100).gifSplit(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 MethodeSplit(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 MethodeSplit(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 FrameworkStartsWith(String)Bestimmt, ob der Anfang dieser Zeichenfolgeninstanz mit der angegebenen Zeichenfolge übereinstimmt.
Öffentliche MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifStartsWith(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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifSubstring(Int32)Ruft eine Teilzeichenfolge dieser Instanz ab. Die Teilzeichenfolge beginnt an einer angegebenen Zeichenposition.
Öffentliche MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifSubstring(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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifToCharArray()Kopiert die Zeichen dieser Instanz in ein Array von Unicode-Zeichen.
Öffentliche MethodeToCharArray(Int32, Int32)Kopiert die Zeichen einer angegebenen Teilzeichenfolge dieser Instanz in ein Array von Unicode-Zeichen.
Öffentliche MethodeUnterstützt von XNA FrameworkToLower()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 Methodes1wwdcbf.PortableClassLibrary(de-de,VS.100).gifToLowerInvariantGibt 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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifToString()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 FrameworkToUpper()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 Methodes1wwdcbf.PortableClassLibrary(de-de,VS.100).gifToUpperInvariantGibt 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 Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifTrim()Entfernt alle führenden und nachgestellten Leerraumzeichen aus dem aktuellen String-Objekt.
Öffentliche MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifTrim(Char[])Entfernt alle führenden und nachgestellten Vorkommen der Zeichen im angegebenen Array aus dem aktuellen String-Objekt.
Öffentliche MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifTrimEndEntfernt alle nachgestellten Vorkommen der Zeichen im angegebenen Array aus dem aktuellen String-Objekt.
Öffentliche MethodeUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifTrimStartEntfernt alle führenden Vorkommen der Zeichen im angegebenen Array aus dem aktuellen String-Objekt.
Zum Seitenanfang

  NameBeschreibung
Öffentlicher OperatorStatischer MemberUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifEqualityBestimmt, ob zwei angegebene Zeichenfolgen denselben Wert haben.
Öffentlicher OperatorStatischer MemberUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifInequalityBestimmt, 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 ErweiterungsmethodeAsParallel()Überladen. Ermöglicht die Parallelisierung einer Abfrage. (Durch ParallelEnumerable definiert.)
Öffentliche ErweiterungsmethodeAsParallel<Char>()Überladen. Ermöglicht die Parallelisierung einer Abfrage. (Durch ParallelEnumerable definiert.)
Öffentliche ErweiterungsmethodeAsQueryable()Überladen. Konvertiert einen IEnumerable in einen 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 FrameworkCast<TResult>Konvertiert die Elemente eines IEnumerable in den angegebenen Typ. (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 oder den Standardwert des Typparameters in einer Singletonauflistung zurück, 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 FrameworkOfType<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 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 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>Führt zwei Sequenzen mit der angegebenen Prädikatfunktion zusammen. (Durch Enumerable definiert.)
Zum Seitenanfang

  NameBeschreibung
Öffentliches FeldStatischer MemberUnterstützt von XNA Frameworks1wwdcbf.PortableClassLibrary(de-de,VS.100).gifEmptyStellt die leere Zeichenfolge dar. Dieses Feld ist schreibgeschützt.
Zum Seitenanfang

  NameBeschreibung
Explizite SchnittstellenimplementierungPrivate MethodeUnterstützt von XNA FrameworkIConvertible.ToBooleanInfrastruktur. Eine Beschreibung dieses Members finden Sie unter ToBoolean.
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 FrameworkIEnumerable.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 zur Unveränderlichkeit von Zeichenfolgen finden Sie im Abschnitt Unveränderlichkeit und die StringBuilder-Klasse.

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.

    
    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 Funktion Kombinierte Formatierung verwendet, 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.      
    
    
    

Zurück zu "Hinweise"

Char-Objekte 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 zum Normalisieren von Zeichenfolgen finden Sie im Abschnitt Normalization.)

    
    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 Codepunkte von hohem Ersatzzeichen reichen von U+D800 bis U+DBFF. Die Codepunkte von niedrigen Ersatzzeichen reichen von U+DC00 bis 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
    
    
    

Zurück zu "Hinweise"

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.

Zurück zu "Hinweise"

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


Zurück zu "Hinweise"

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));
   }                                   
}


Zurück zu "Hinweise"

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 Routinen zur Zeichenfolgenbearbeitung, die wiederholte Hinzufüge- oder Löschvorgänge zu scheinbar einzelnen Zeichenfolgen ausführen, zu bedeutenden Leistungseinbußen führen. 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();
   }
}


Zurück zu "Hinweise"

Ordnungszahl im Vergleich zuKulturabhängige Operationen

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 casing, parsing and formatting, comparison and sorting und testing for equality können entweder ordinal oder kulturabhängig sein. In den folgenden Abschnitten wird jede Kategorie des Vorgangs erläutert.

Groß-/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. 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 


Analysieren und Formatieren

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


Zeichenfolgenvergleich und -sortierung

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, wie das folgende Beispiel zeigt, wenn die aktuelle Kultur amerikanisch ist. Englisch: Der erste Aufruf der String.Compare(String, String, StringComparison)-Methode (mit kulturabhängigem Vergleich) betrachtet "a" als geringer als "A", aber der zweite Aufruf der gleichen Methode (mit Ordinalvergleich) betrachtet "a" als größer als "A".


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-Methoden, die zwei Zeichenfolgen mit Sortierregeln für Wörter vergleichen, finden Sie im Abschnitt String Operations by Category.

  • 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 String-Methoden, die zwei Zeichenfolgen mit Sortierregeln für Ordnungszahlen vergleichen, finden Sie im Abschnitt String Operations by Category.

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. Ein kulturabhängiger Vergleich ist für Sortierung i. d. R. geeignet, ein Ordinalvergleich jedoch nicht. Ein Ordinalvergleich eignet sich für das Bestimmen, ob zwei Zeichenfolgen gleich sind (d. h. für die Bestimmung der Identität), wofür ein kulturabhängiger Vergleich nicht geeignet ist.

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 werden Informationen zu Sortierung, Groß-/Kleinschreibung, Normalisierung und Unicode-Zeichen mit Windows 7 synchronisiert; sie entsprechen dem Standard Unicode 5.1.

Weitere Informationen über die Regeln für das Sortieren nach Wörtern, Zeichenfolgen und Ordnungszahlen finden Sie unter dem Thema System.Globalization.CompareOptions. Empfehlungen zur Verwendung der einzelnen Regeln 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 unter Verwendung der invarianten Kultur, Ordinalsortierung und Zeichenfolgensortierung unter Verwendung der invarianten Kultur) ausgeführt, ohne explizit eine Zeichenfolgenvergleichsmethode aufzurufen. 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


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


Testen auf 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-Methode oder die statische Equals-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.


Zurück zu "Hinweise"

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. Weitere Informationen zur Normalisierung und zu Normalisierungsformularen finden Sie unter System.Text.NormalizationForm.

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.

Im folgenden Beispiel wird die Zeichenfolgennormalisierung veranschaulicht. 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


Zurück zu "Hinweise"

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.

Vergleichen 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-Methode stellt die IComparable- und IComparable<T>-Implementierung für die String-Klasse bereit.

Testen von Zeichenfolgen auf Gleichheit

Sie rufen die Equals-Methode auf, um zu bestimmen, ob zwei Zeichenfolgen identisch sind. Die Instanz Equals und die statischen Equals-Ü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.

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

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

Extrahieren von Teilzeichenfolgen aus 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.

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

Formatieren von Werten

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.

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

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

Zurück zu "Hinweise"

.NET Framework

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

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Unterstützt in:

Windows 7, Windows Vista SP1 oder höher, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (Server Core wird nicht unterstützt), Windows Server 2008 R2 (Server Core wird mit SP1 oder höher unterstützt), Windows Server 2003 SP2

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

Datum

Versionsgeschichte

Grund

Juli 2010

Zweite Hälfte des Abschnitts "Hinweise" wurde ausführlich überarbeitet.

Informationsergänzung.

Juni 2010

Ausführlich überarbeitete erste Hälfte des Abschnitts "Hinweise".

Informationsergänzung.

Anzeigen: