Windows-Apps
Inhaltsverzeichnis reduzieren
Inhaltsverzeichnis erweitern
Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch
Informationen
Das angeforderte Thema wird unten angezeigt. Es ist jedoch nicht in dieser Bibliothek vorhanden.

String-Klasse

 

Veröffentlicht: Oktober 2016

Stellt Text als Sequenz von UTF-16-Codeeinheiten dar.

Informationen zum Durchsuchen des .NET Framework-Quellcodes für diesen Typ finden Sie unter der Reference Source.

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


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

NameBeschreibung
System_CAPS_pubmethodString(Char*)

Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch einen angegebenen Zeiger auf ein Array von Unicode-Zeichen bestimmt wird.

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

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

System_CAPS_pubmethodString(Char[])

Initialisiert eine neue Instanz der String-Klasse mit dem durch ein Array von Unicode-Zeichen angegebenen Wert.

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

System_CAPS_pubmethodString(SByte*)

Initialisiert eine neue Instanz der String-Klasse mit dem durch einen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen angegebenen Wert.

System_CAPS_pubmethodString(SByte*, Int32, Int32)

Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch einen angegebenen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen, die Startposition innerhalb dieses Arrays und die Länge angegeben wird.

System_CAPS_pubmethodString(SByte*, Int32, Int32, Encoding)

Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch einen angegebenen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen, die Startposition innerhalb dieses Arrays, eine Länge und ein Encoding-Objekt angegeben wird.

NameBeschreibung
System_CAPS_pubpropertyChars[Int32]

Ruft das Char-Objekt an einer angegebenen Zeichenposition innerhalb des aktuellen String-Objekts ab.

System_CAPS_pubpropertyLength

Ruft die Anzahl der Zeichen im aktuellen String-Objekt ab.

NameBeschreibung
System_CAPS_pubmethodClone()

Gibt einen Verweis auf diese String-Instanz zurück.

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, Int32, String, Int32, Int32)

Vergleicht zwei angegebene String-Objekte und gibt eine Ganzzahl zurück, welche die relative Position in der Sortierreihenfolge angibt.

System_CAPS_pubmethodSystem_CAPS_staticCompare(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 Ganzzahl zurück, welche die relative Position in der Sortierreihenfolge angibt.

System_CAPS_pubmethodSystem_CAPS_staticCompare(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 Ganzzahl zurück, welche die relative Position in der Sortierreihenfolge angibt.

System_CAPS_pubmethodSystem_CAPS_staticCompare(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 Ganzzahl zurück, welche die Beziehung der beiden Teilzeichenfolgen zueinander in der Sortierreihenfolge angibt.

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, Int32, String, Int32, Int32, StringComparison)

Vergleicht Teilzeichenfolgen von zwei angegebenen String-Objekten gemäß den angegebenen Vergleichsregeln und gibt eine Ganzzahl zurück, welche die relative Position in der Sortierreihenfolge angibt.

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, String)

Vergleicht zwei angegebene String-Objekte und gibt eine Ganzzahl zurück, welche die relative Position in der Sortierreihenfolge angibt.

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, String, Boolean)

Vergleicht zwei angegebene String-Objekte, wobei ihre Groß- und Kleinschreibung entweder ignoriert oder berücksichtigt wird, und gibt eine Ganzzahl zurück, welche die relative Position in der Sortierreihenfolge angibt.

System_CAPS_pubmethodSystem_CAPS_staticCompare(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 Ganzzahl zurück, welche die relative Position in der Sortierreihenfolge angibt.

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, String, CultureInfo, CompareOptions)

Vergleicht zwei angegebene String-Objekte mit den festgelegten Vergleichsoptionen und kulturspezifischen Informationen, die den Vergleich beeinflussen, und gibt eine Ganzzahl zurück, welche die Beziehung der beiden Zeichenfolgen zueinander in der Sortierreihenfolge angibt.

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, String, StringComparison)

Vergleicht zwei angegebene String-Objekte gemäß den angegebenen Vergleichsregeln und gibt eine Ganzzahl zurück, welche die relative Position in der Sortierreihenfolge angibt.

System_CAPS_pubmethodSystem_CAPS_staticCompareOrdinal(String, Int32, String, Int32, Int32)

Vergleicht Teilzeichenfolgen zweier angegebener String-Objekte, indem die numerischen Werte der entsprechenden Char-Objekte in den Teilzeichenfolgen ausgewertet werden.

System_CAPS_pubmethodSystem_CAPS_staticCompareOrdinal(String, String)

Vergleicht zwei String-Objekte, indem die numerischen Werte der entsprechenden Char-Objekte in den Zeichenfolgen ausgewertet werden.

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

System_CAPS_pubmethodCompareTo(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 die angegebene Zeichenfolge aufgeführt wird.

System_CAPS_pubmethodSystem_CAPS_staticConcat(IEnumerable<String>)

Verkettet die Elemente einer erstellten IEnumerable<T>-Auflistung vom Typ String.

System_CAPS_pubmethodSystem_CAPS_staticConcat(Object)

Erstellt die Zeichenfolgendarstellung eines angegebenen Objekts.

System_CAPS_pubmethodSystem_CAPS_staticConcat(Object, Object)

Verkettet die Zeichenfolgendarstellungen zweier angegebener Objekte.

System_CAPS_pubmethodSystem_CAPS_staticConcat(Object, Object, Object)

Verkettet die Zeichenfolgendarstellungen von drei angegebenen Objekten.

System_CAPS_pubmethodSystem_CAPS_staticConcat(Object, Object, Object, Object)

Verkettet die Zeichenfolgenentsprechungen von vier angegebenen Objekten sowie aller in einer optionalen Parameterliste variabler Länger angegebenen Objekte.

System_CAPS_pubmethodSystem_CAPS_staticConcat(Object[])

Verkettet die Zeichenfolgendarstellungen der Elemente in einem angegebenen Object-Array.

System_CAPS_pubmethodSystem_CAPS_staticConcat(String, String)

Verkettet zwei angegebene Instanzen von String.

System_CAPS_pubmethodSystem_CAPS_staticConcat(String, String, String)

Verkettet zwei angegebene Instanzen von String.

System_CAPS_pubmethodSystem_CAPS_staticConcat(String, String, String, String)

Verkettet zwei angegebene Instanzen von String.

System_CAPS_pubmethodSystem_CAPS_staticConcat(String[])

Verkettet die Elemente eines angegebenen String-Arrays.

System_CAPS_pubmethodSystem_CAPS_staticConcat<T>(IEnumerable<T>)

Verkettet die Elemente einer IEnumerable<T>-Implementierung.

System_CAPS_pubmethodContains(String)

Gibt einen Wert zurück, der angibt, ob eine angegebene Teilfolge in dieser Zeichenfolge vorkommt.

System_CAPS_pubmethodSystem_CAPS_staticCopy(String)

Erstellt eine neue Instanz von String mit demselben Wert wie eine angegebene Instanz von String.

System_CAPS_pubmethodCopyTo(Int32, Char[], Int32, Int32)

Kopiert eine angegebene Anzahl von Zeichen von einer angegebenen Position in dieser Instanz an eine angegebene Position in einem Array von Unicode-Zeichen.

System_CAPS_pubmethodEndsWith(String)

Bestimmt, ob das Ende dieser Zeichenfolgeninstanz mit der angegebenen Zeichenfolge übereinstimmt.

System_CAPS_pubmethodEndsWith(String, Boolean, CultureInfo)

Bestimmt, ob das Ende dieser Zeichenfolgeninstanz bei einem Vergleich unter Verwendung der angegebenen kulturspezifischen Information mit der angegebenen Zeichenfolge übereinstimmt.

System_CAPS_pubmethodEndsWith(String, StringComparison)

Bestimmt, ob das Ende dieser Zeichenfolgeninstanz bei einem Vergleich unter Verwendung der angegebenen Vergleichsoption mit der angegebenen Zeichenfolge übereinstimmt.

System_CAPS_pubmethodEquals(Object)

Bestimmt, ob diese Instanz und ein angegebenes Objekt, das ebenfalls ein String-Objekt sein muss, denselben Wert haben.(Überschreibt Object.Equals(Object).)

System_CAPS_pubmethodEquals(String)

Bestimmt, ob diese Instanz und ein anderes angegebenes String-Objekt denselben Wert haben.

System_CAPS_pubmethodSystem_CAPS_staticEquals(String, String)

Bestimmt, ob zwei angegebene String-Objekte denselben Wert haben.

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

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

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object)

Ersetzt die Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung des angegebenen Objekts. Ein Parameter liefert kulturspezifische Formatierungsinformationen.

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object, Object)

Ersetzt die Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung von zwei angegebenen Objekten. Ein Parameter liefert kulturspezifische Formatierungsinformationen.

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object, Object, Object)

Ersetzt die Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung von drei angegebenen Objekten. Ein Parameter liefert kulturspezifische Formatierungsinformationen.

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object[])

Ersetzt die Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellungen entsprechender Objekte in einem angegebenen Array. Ein Parameter liefert kulturspezifische Formatierungsinformationen.

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object)

Ersetzt ein oder mehrere Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung eines angegebenen Objekts.

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object, Object)

Ersetzt die Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung von zwei angegebenen Objekten.

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object, Object, Object)

Ersetzt die Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung von drei angegebenen Objekten.

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object[])

Ersetzt das Formatelement in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung eines entsprechenden Objekts in einem angegebenen Array.

System_CAPS_pubmethodGetEnumerator()

Ruft ein Objekt ab, das die einzelnen Zeichen dieser Zeichenfolge durchlaufen kann.

System_CAPS_pubmethodGetHashCode()

Gibt den Hashcode für diese Zeichenfolge zurück.(Überschreibt Object.GetHashCode().)

System_CAPS_pubmethodGetType()

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

System_CAPS_pubmethodGetTypeCode()

Gibt einen TypeCode für das String zurück.

System_CAPS_pubmethodIndexOf(Char)

Gibt den NULL-basierten Index des ersten Vorkommens des angegebenen Unicode-Zeichens in dieser Zeichenfolge an.

System_CAPS_pubmethodIndexOf(Char, Int32)

Gibt den NULL-basierten Index des ersten Vorkommens des angegebenen Unicode-Zeichens in dieser Zeichenfolge an. Die Suche beginnt an einer angegebenen Zeichenposition.

System_CAPS_pubmethodIndexOf(Char, Int32, Int32)

Gibt den NULL-basierten Index des ersten Vorkommens des angegebenen Zeichens in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition, und es wird eine angegebene Anzahl von Zeichenpositionen überprüft.

System_CAPS_pubmethodIndexOf(String)

Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge in dieser Instanz an.

System_CAPS_pubmethodIndexOf(String, Int32)

Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition.

System_CAPS_pubmethodIndexOf(String, Int32, Int32)

Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition, und es wird eine angegebene Anzahl von Zeichenpositionen überprüft.

System_CAPS_pubmethodIndexOf(String, Int32, Int32, StringComparison)

Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge im aktuellen String-Objekt an. Parameter geben die Anfangssuchposition in der aktuellen Zeichenfolge, die Anzahl der Zeichen in der aktuellen Zeichenfolge und den Typ der Suche für die angegebene Zeichenfolge an.

System_CAPS_pubmethodIndexOf(String, Int32, StringComparison)

Gibt den nullbasierten 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.

System_CAPS_pubmethodIndexOf(String, StringComparison)

Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge im aktuellen String-Objekt an. Ein Parameter gibt den Typ der Suche für die angegebene Zeichenfolge an.

System_CAPS_pubmethodIndexOfAny(Char[])

Gibt den NULL-basierten Index des ersten Vorkommens eines beliebigen Zeichens aus einem angegebenen Array von Unicode-Zeichen in dieser Instanz an.

System_CAPS_pubmethodIndexOfAny(Char[], Int32)

Gibt den NULL-basierten Index des ersten Vorkommens eines beliebigen Zeichens aus einem angegebenen Array von Unicode-Zeichen in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition.

System_CAPS_pubmethodIndexOfAny(Char[], Int32, Int32)

Gibt den NULL-basierten Index des ersten Vorkommens eines beliebigen Zeichens aus einem angegebenen Array von Unicode-Zeichen in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition, und es wird eine angegebene Anzahl von Zeichenpositionen überprüft.

System_CAPS_pubmethodInsert(Int32, String)

Gibt eine neue Zeichenfolge zurück, in der eine angegebene Zeichenfolge an einer angegebenen Indexposition in dieser Instanz eingefügt wird.

System_CAPS_pubmethodSystem_CAPS_staticIntern(String)

Ruft den Verweis des Systems auf den angegebenen String ab.

System_CAPS_pubmethodSystem_CAPS_staticIsInterned(String)

Ruft einen Verweis auf einen angegebenen String ab.

System_CAPS_pubmethodIsNormalized()

Gibt an, ob diese Zeichenfolge in der Unicode-Normalisierungsform C vorliegt.

System_CAPS_pubmethodIsNormalized(NormalizationForm)

Gibt an, ob diese Zeichenfolge in der angegebenen Unicode-Normalisierungsform vorliegt.

System_CAPS_pubmethodSystem_CAPS_staticIsNullOrEmpty(String)

Gibt an, ob die angegebene Zeichenfolge null oder eine Empty-Zeichenfolge ist.

System_CAPS_pubmethodSystem_CAPS_staticIsNullOrWhiteSpace(String)

Gibt an, ob eine angegebene Zeichenfolge null ist, leer ist oder nur aus Leerzeichen besteht.

System_CAPS_pubmethodSystem_CAPS_staticJoin(String, IEnumerable<String>)

Verkettet die Member einer erstellten IEnumerable<T>-Auflistung vom Typ String und verwendet das angegebene Trennzeichen zwischen den einzelnen Membern.

System_CAPS_pubmethodSystem_CAPS_staticJoin(String, Object[])

Verkettet die Elemente eines Objektarrays und verwendet das angegebene Trennzeichen zwischen den einzelnen Elementen.

System_CAPS_pubmethodSystem_CAPS_staticJoin(String, String[])

Verkettet alle Elemente eines Zeichenfolgenarrays und verwendet das angegebene Trennzeichen zwischen den einzelnen Elementen.

System_CAPS_pubmethodSystem_CAPS_staticJoin(String, String[], Int32, Int32)

Verkettet die angegebenen Elemente eines Zeichenfolgenarrays und verwendet das angegebene Trennzeichen zwischen den einzelnen Elementen.

System_CAPS_pubmethodSystem_CAPS_staticJoin<T>(String, IEnumerable<T>)

Verkettet die Member einer Auflistung und verwendet das angegebene Trennzeichen zwischen den einzelnen Membern.

System_CAPS_pubmethodLastIndexOf(Char)

Gibt die NULL-basierte Indexposition des letzten Vorkommens eines angegebenen Unicode-Zeichens in dieser Instanz an.

System_CAPS_pubmethodLastIndexOf(Char, Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens eines angegebenen Unicode-Zeichens in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt.

System_CAPS_pubmethodLastIndexOf(Char, Int32, Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens des angegebenen Unicode-Zeichens in einer Teilzeichenfolge dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge.

System_CAPS_pubmethodLastIndexOf(String)

Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an.

System_CAPS_pubmethodLastIndexOf(String, Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt.

System_CAPS_pubmethodLastIndexOf(String, Int32, Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge.

System_CAPS_pubmethodLastIndexOf(String, Int32, Int32, StringComparison)

Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge. Ein Parameter gibt den Typ des bei der Suche nach der angegebenen Zeichenfolge auszuführenden Vergleichs an.

System_CAPS_pubmethodLastIndexOf(String, Int32, StringComparison)

Gibt den NULL-basierten Index des letzten Vorkommens einer angegebenen Zeichenfolge im aktuellen String-Objekt an. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt. Ein Parameter gibt den Typ des bei der Suche nach der angegebenen Zeichenfolge auszuführenden Vergleichs an.

System_CAPS_pubmethodLastIndexOf(String, StringComparison)

Gibt den NULL-basierten Index des letzten Vorkommens einer angegebenen Zeichenfolge im aktuellen String-Objekt an. Ein Parameter gibt den Typ der Suche für die angegebene Zeichenfolge an.

System_CAPS_pubmethodLastIndexOfAny(Char[])

Gibt die NULL-basierte Indexposition des letzten Vorkommens eines oder mehrerer angegebener Zeichen eines Unicode-Arrays in dieser Instanz an.

System_CAPS_pubmethodLastIndexOfAny(Char[], Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens eines oder mehrerer angegebener Zeichen eines Unicode-Arrays in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt.

System_CAPS_pubmethodLastIndexOfAny(Char[], Int32, Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens eines oder mehrerer angegebener Zeichen eines Unicode-Arrays in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge.

System_CAPS_pubmethodNormalize()

Gibt eine neue Zeichenfolge zurück, deren Textwert mit dieser Zeichenfolge übereinstimmt, deren binäre Darstellung jedoch in der Unicode-Normalisierungsform C vorliegt.

System_CAPS_pubmethodNormalize(NormalizationForm)

Gibt eine neue Zeichenfolge zurück, deren Textwert mit dieser Zeichenfolge übereinstimmt, deren binäre Darstellung jedoch in der angegebenen Unicode-Normalisierungsform vorliegt.

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

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

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

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

System_CAPS_pubmethodRemove(Int32)

Gibt eine neue Zeichenfolge zurück, in der alle Zeichen in der aktuellen Instanz, beginnend an einer angegebenen Position und sich über die letzte Position fortsetzend, gelöscht wurden.

System_CAPS_pubmethodRemove(Int32, Int32)

Gibt eine neue Zeichenfolge zurück, in der eine bestimmte Anzahl von Zeichen in er aktuellen Instanz, beginnend an einer angegebenen Position, gelöscht wurden.

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

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

System_CAPS_pubmethodSplit(Char[])

Unterteilt eine Zeichenfolge anhand der Zeichen in einem Array in Teilzeichenfolgen.

System_CAPS_pubmethodSplit(Char[], Int32)

Unterteilt eine Zeichenfolge anhand der Zeichen in einem Array in eine maximale Anzahl von Teilzeichenfolgen. Sie geben außerdem die maximale Anzahl der zurückzugebenden Teilzeichenfolgen an.

System_CAPS_pubmethodSplit(Char[], Int32, StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der Zeichen in einem Array in eine maximale Anzahl von Teilzeichenfolgen.

System_CAPS_pubmethodSplit(Char[], StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der Zeichen in einem Array in Teilzeichenfolgen. Sie können angeben, ob die Teilzeichenfolgen auch leere Arrayelemente umfassen.

System_CAPS_pubmethodSplit(String[], Int32, StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der Zeichenfolgen in einem Array in eine maximale Anzahl von Teilzeichenfolgen. Sie können angeben, ob die Teilzeichenfolgen auch leere Arrayelemente umfassen.

System_CAPS_pubmethodSplit(String[], StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der Zeichenfolgen in einem Array in Teilzeichenfolgen. Sie können angeben, ob die Teilzeichenfolgen auch leere Arrayelemente umfassen.

System_CAPS_pubmethodStartsWith(String)

Bestimmt, ob der Anfang dieser Zeichenfolgeninstanz mit der angegebenen Zeichenfolge übereinstimmt.

System_CAPS_pubmethodStartsWith(String, Boolean, CultureInfo)

Bestimmt, ob der Anfang dieser Zeichenfolgeninstanz bei einem Vergleich unter Verwendung der angegebenen Kultur mit der angegebenen Zeichenfolge übereinstimmt.

System_CAPS_pubmethodStartsWith(String, StringComparison)

Bestimmt, ob der Anfang dieser Zeichenfolgeninstanz bei einem Vergleich unter Verwendung der angegebenen Vergleichsoption mit der angegebenen Zeichenfolge übereinstimmt.

System_CAPS_pubmethodSubstring(Int32)

Ruft eine Teilzeichenfolge dieser Instanz ab. Die untergeordnete Zeichenfolge beginnt in einer angegebenen Zeichenposition und wird an das Ende der Zeichenfolge fortgesetzt.

System_CAPS_pubmethodSubstring(Int32, Int32)

Ruft eine Teilzeichenfolge dieser Instanz ab. Die Teilzeichenfolge beginnt an einer angegebenen Zeichenposition und hat eine angegebene Länge.

System_CAPS_pubmethodToCharArray()

Kopiert die Zeichen dieser Instanz in ein Array von Unicode-Zeichen.

System_CAPS_pubmethodToCharArray(Int32, Int32)

Kopiert die Zeichen einer angegebenen Teilzeichenfolge dieser Instanz in ein Array von Unicode-Zeichen.

System_CAPS_pubmethodToLower()

Gibt eine in Kleinbuchstaben konvertierte Kopie dieser Zeichenfolge zurück.

System_CAPS_pubmethodToLower(CultureInfo)

Gibt eine in Kleinbuchstaben konvertierte Kopie dieser Zeichenfolge zurück, wobei die Regeln der Groß- und Kleinschreibung der angegebenen Kultur verwendet werden.

System_CAPS_pubmethodToLowerInvariant()

Gibt eine in Kleinbuchstaben konvertierte Kopie dieses String-Objekts zurück, wobei die Regeln der Groß- und Kleinschreibung der invarianten Kultur verwendet werden.

System_CAPS_pubmethodToString()

Gibt diese Instanz von String zurück. Es wird keine wirkliche Konvertierung durchgeführt.(Überschreibt Object.ToString().)

System_CAPS_pubmethodToString(IFormatProvider)

Gibt diese Instanz von String zurück. Es wird keine wirkliche Konvertierung durchgeführt.

System_CAPS_pubmethodToUpper()

Gibt eine in Großbuchstaben konvertierte Kopie dieser Zeichenfolge zurück.

System_CAPS_pubmethodToUpper(CultureInfo)

Gibt eine in Großbuchstaben konvertierte Kopie dieser Zeichenfolge zurück, wobei die Regeln der Groß- und Kleinschreibung der angegebenen Kultur verwendet werden.

System_CAPS_pubmethodToUpperInvariant()

Gibt eine in Großbuchstaben konvertierte Kopie dieses String-Objekts zurück, wobei die Regeln der Groß- und Kleinschreibung der invarianten Kultur verwendet werden.

System_CAPS_pubmethodTrim()

Entfernt alle führenden und nachgestellten Leerraumzeichen aus dem aktuellen String-Objekt.

System_CAPS_pubmethodTrim(Char[])

Entfernt alle führenden und nachgestellten Vorkommen der Zeichen im angegebenen Array aus dem aktuellen String-Objekt.

System_CAPS_pubmethodTrimEnd(Char[])

Entfernt alle nachgestellten Vorkommen der Zeichen im angegebenen Array aus dem aktuellen String-Objekt.

System_CAPS_pubmethodTrimStart(Char[])

Entfernt alle nachgestellten Vorkommen der Zeichen im angegebenen Array aus dem aktuellen String-Objekt.

NameBeschreibung
System_CAPS_pubfieldSystem_CAPS_staticEmpty

Stellt die leere Zeichenfolge dar. Dieses Feld ist schreibgeschützt.

NameBeschreibung
System_CAPS_puboperatorSystem_CAPS_staticEquality(String, String)

Bestimmt, ob zwei angegebene Zeichenfolgen denselben Wert haben.

System_CAPS_puboperatorSystem_CAPS_staticInequality(String, String)

Bestimmt, ob zwei angegebene Zeichenfolgen verschiedene Werte haben.

NameBeschreibung
System_CAPS_pubinterfaceSystem_CAPS_privmethodIEnumerable<Char>.GetEnumerator()

Gibt einen Enumerator zurück, der das aktuelle String-Objekt durchläuft.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIEnumerable.GetEnumerator()

Gibt einen Enumerator zurück, der das aktuelle String-Objekt durchläuft.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter ToBoolean.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter ToByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter ToChar.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter ToDateTime.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter ToDecimal.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter ToDouble.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter ToInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter ToInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter ToInt64.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter ToSByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter ToSingle.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter ToType.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter ToUInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter ToUInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Eine Beschreibung dieses Elements finden Sie unter ToUInt64.

NameBeschreibung
System_CAPS_pubmethodAggregate<Char>(Func<Char, Char, Char>)

Überladen. Wendet eine Akkumulatorfunktion auf eine Sequenz an.(Definiert durch Enumerable.)

System_CAPS_pubmethodAggregate<Char, TAccumulate>(TAccumulate, Func<TAccumulate, Char, TAccumulate>)

Überladen. Wendet eine Akkumulatorfunktion auf eine Sequenz an. Der angegebene Startwert wird als erster Akkumulatorwert verwendet.(Definiert durch Enumerable.)

System_CAPS_pubmethodAggregate<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.(Definiert durch Enumerable.)

System_CAPS_pubmethodAll<Char>(Func<Char, Boolean>)

Bestimmt, ob alle Elemente einer Sequenz eine Bedingung erfüllen.(Definiert durch Enumerable.)

System_CAPS_pubmethodAny<Char>()

Überladen. Bestimmt, ob eine Sequenz Elemente enthält.(Definiert durch Enumerable.)

System_CAPS_pubmethodAny<Char>(Func<Char, Boolean>)

Überladen. Bestimmt, ob ein Element einer Sequenz eine Bedingung erfüllt.(Definiert durch Enumerable.)

System_CAPS_pubmethodAsEnumerable<Char>()

Gibt die Eingabe als IEnumerable<T>.(Definiert durch Enumerable.)

System_CAPS_pubmethodAsParallel()

Überladen. Ermöglicht die Parallelisierung einer Abfrage.(Definiert durch ParallelEnumerable.)

System_CAPS_pubmethodAsParallel<Char>()

Überladen. Ermöglicht die Parallelisierung einer Abfrage.(Definiert durch ParallelEnumerable.)

System_CAPS_pubmethodAsQueryable()

Überladen. Konvertiert ein IEnumerable zu einer IQueryable.(Definiert durch Queryable.)

System_CAPS_pubmethodAsQueryable<Char>()

Überladen. Konvertiert ein generisches IEnumerable<T> auf einen generischen IQueryable<T>.(Definiert durch Queryable.)

System_CAPS_pubmethodAverage<Char>(Func<Char, Decimal>)

Überladen. Berechnet den Durchschnitt einer Sequenz von Decimal Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definiert durch Enumerable.)

System_CAPS_pubmethodAverage<Char>(Func<Char, Double>)

Überladen. Berechnet den Durchschnitt einer Sequenz von Double Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definiert durch Enumerable.)

System_CAPS_pubmethodAverage<Char>(Func<Char, Int32>)

Überladen. Berechnet den Durchschnitt einer Sequenz von Int32 Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definiert durch Enumerable.)

System_CAPS_pubmethodAverage<Char>(Func<Char, Int64>)

Überladen. Berechnet den Durchschnitt einer Sequenz von Int64 Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definiert durch Enumerable.)

System_CAPS_pubmethodAverage<Char>(Func<Char, Nullable<Decimal>>)

Überladen. Berechnet den Durchschnitt einer Sequenz von NULL-Werte zu Decimal Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definiert durch Enumerable.)

System_CAPS_pubmethodAverage<Char>(Func<Char, Nullable<Double>>)

Überladen. Berechnet den Durchschnitt einer Sequenz von NULL-Werte zu Double Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definiert durch Enumerable.)

System_CAPS_pubmethodAverage<Char>(Func<Char, Nullable<Int32>>)

Überladen. Berechnet den Durchschnitt einer Sequenz von NULL-Werte zu Int32 Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definiert durch Enumerable.)

System_CAPS_pubmethodAverage<Char>(Func<Char, Nullable<Int64>>)

Überladen. Berechnet den Durchschnitt einer Sequenz von NULL-Werte zu Int64 Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definiert durch Enumerable.)

System_CAPS_pubmethodAverage<Char>(Func<Char, Nullable<Single>>)

Überladen. Berechnet den Durchschnitt einer Sequenz von NULL-Werte zu Single Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definiert durch Enumerable.)

System_CAPS_pubmethodAverage<Char>(Func<Char, Single>)

Überladen. Berechnet den Durchschnitt einer Sequenz von Single Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definiert durch Enumerable.)

System_CAPS_pubmethodCast<TResult>()

Wandelt die Elemente einer IEnumerable in den angegebenen Typ.(Definiert durch Enumerable.)

System_CAPS_pubmethodConcat<Char>(IEnumerable<Char>)

Verkettet zwei Sequenzen.(Definiert durch Enumerable.)

System_CAPS_pubmethodContains<Char>(Char)

Überladen. Bestimmt, ob eine Sequenz ein angegebenes Element enthält, mithilfe des Standardgleichheitsvergleichs.(Definiert durch Enumerable.)

System_CAPS_pubmethodContains<Char>(Char, IEqualityComparer<Char>)

Überladen. Bestimmt, ob eine Sequenz ein angegebenes Element enthält, mit einem angegebenen IEqualityComparer<T>.(Definiert durch Enumerable.)

System_CAPS_pubmethodCount<Char>()

Überladen. Gibt die Anzahl der Elemente in einer Sequenz zurück.(Definiert durch Enumerable.)

System_CAPS_pubmethodCount<Char>(Func<Char, Boolean>)

Überladen. Gibt eine Zahl, die darstellt, wie viele Elemente in der angegebenen Sequenz eine Bedingung erfüllen.(Definiert durch Enumerable.)

System_CAPS_pubmethodDefaultIfEmpty<Char>()

Überladen. Gibt die Elemente der angegebenen Sequenz oder den Standardwert des Typparameters in einer singletonauflistung zurück, wenn die Sequenz leer ist.(Definiert durch Enumerable.)

System_CAPS_pubmethodDefaultIfEmpty<Char>(Char)

Überladen. Gibt die Elemente der angegebenen Sequenz oder den angegebenen Wert in einer singletonauflistung zurück, wenn die Sequenz leer ist.(Definiert durch Enumerable.)

System_CAPS_pubmethodDistinct<Char>()

Überladen. Gibt Sie mithilfe des Standardgleichheitsvergleichs zum Vergleichen von Werten unterschiedliche Elemente aus einer Sequenz zurück.(Definiert durch Enumerable.)

System_CAPS_pubmethodDistinct<Char>(IEqualityComparer<Char>)

Überladen. Gibt unterschiedliche Elemente aus einer Sequenz mithilfe eines angegebenen IEqualityComparer<T> zum Vergleichen von Werten.(Definiert durch Enumerable.)

System_CAPS_pubmethodElementAt<Char>(Int32)

Gibt das Element am angegebenen Index in einer Sequenz zurück.(Definiert durch Enumerable.)

System_CAPS_pubmethodElementAtOrDefault<Char>(Int32)

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.(Definiert durch Enumerable.)

System_CAPS_pubmethodExcept<Char>(IEnumerable<Char>)

Überladen. Erzeugt die Differenzmenge von zwei Sequenzen mithilfe des Standardgleichheitsvergleichs zum Vergleichen von Werten.(Definiert durch Enumerable.)

System_CAPS_pubmethodExcept<Char>(IEnumerable<Char>, IEqualityComparer<Char>)

Überladen. Erzeugt die Differenzmenge von zwei Sequenzen unter Verwendung des angegebenen IEqualityComparer<T> zum Vergleichen von Werten.(Definiert durch Enumerable.)

System_CAPS_pubmethodFirst<Char>()

Überladen. Gibt das erste Element einer Sequenz zurück.(Definiert durch Enumerable.)

System_CAPS_pubmethodFirst<Char>(Func<Char, Boolean>)

Überladen. Gibt das erste Element in einer Sequenz zurück, das eine angegebene Bedingung erfüllt.(Definiert durch Enumerable.)

System_CAPS_pubmethodFirstOrDefault<Char>()

Überladen. Gibt das erste Element einer Sequenz oder einen Standardwert zurück, wenn die Sequenz keine Elemente enthält.(Definiert durch Enumerable.)

System_CAPS_pubmethodFirstOrDefault<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.(Definiert durch Enumerable.)

System_CAPS_pubmethodGroupBy<Char, TKey>(Func<Char, TKey>)

Überladen. Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion.(Definiert durch Enumerable.)

System_CAPS_pubmethodGroupBy<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.(Definiert durch Enumerable.)

System_CAPS_pubmethodGroupBy<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.(Definiert durch Enumerable.)

System_CAPS_pubmethodGroupBy<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.(Definiert durch Enumerable.)

System_CAPS_pubmethodGroupBy<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.(Definiert durch Enumerable.)

System_CAPS_pubmethodGroupBy<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.(Definiert durch Enumerable.)

System_CAPS_pubmethodGroupBy<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.(Definiert durch Enumerable.)

System_CAPS_pubmethodGroupBy<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.(Definiert durch Enumerable.)

System_CAPS_pubmethodGroupJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, IEnumerable<TInner>, TResult>)

Überladen. Korreliert die Elemente zweier Sequenzen basierend auf der Gleichheit der Schlüssel und gruppiert die Ergebnisse. Schlüssel werden mithilfe des Standardgleichheitsvergleichs verglichen.(Definiert durch Enumerable.)

System_CAPS_pubmethodGroupJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)

Überladen. Korreliert die Elemente zweier Sequenzen basierend auf der Gleichheit der Schlüssel und gruppiert die Ergebnisse. Schlüssel werden mithilfe eines angegebenen IEqualityComparer<T> verglichen.(Definiert durch Enumerable.)

System_CAPS_pubmethodIntersect<Char>(IEnumerable<Char>)

Überladen. Erzeugt die Schnittmenge von zwei Sequenzen mithilfe des Standardgleichheitsvergleichs zum Vergleichen von Werten.(Definiert durch Enumerable.)

System_CAPS_pubmethodIntersect<Char>(IEnumerable<Char>, IEqualityComparer<Char>)

Überladen. Erzeugt die Schnittmenge von zwei Sequenzen unter Verwendung des angegebenen IEqualityComparer<T> zum Vergleichen von Werten.(Definiert durch Enumerable.)

System_CAPS_pubmethodJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, TInner, TResult>)

Überladen. Korreliert die Elemente zweier Sequenzen basierend auf übereinstimmenden Schlüsseln. Schlüssel werden mithilfe des Standardgleichheitsvergleichs verglichen.(Definiert durch Enumerable.)

System_CAPS_pubmethodJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, TInner, TResult>, IEqualityComparer<TKey>)

Überladen. Korreliert die Elemente zweier Sequenzen basierend auf übereinstimmenden Schlüsseln. Schlüssel werden mithilfe eines angegebenen IEqualityComparer<T> verglichen.(Definiert durch Enumerable.)

System_CAPS_pubmethodLast<Char>()

Überladen. Gibt das letzte Element einer Sequenz zurück.(Definiert durch Enumerable.)

System_CAPS_pubmethodLast<Char>(Func<Char, Boolean>)

Überladen. Gibt das letzte Element einer Sequenz zurück, das eine angegebene Bedingung erfüllt.(Definiert durch Enumerable.)

System_CAPS_pubmethodLastOrDefault<Char>()

Überladen. Gibt das letzte Element einer Sequenz oder einen Standardwert zurück, wenn die Sequenz keine Elemente enthält.(Definiert durch Enumerable.)

System_CAPS_pubmethodLastOrDefault<Char>(Func<Char, Boolean>)

Überladen. Gibt das letzte Element einer Sequenz, das eine Bedingung erfüllt, oder einen Standardwert zurück, wenn ein solches Element nicht gefunden wird.(Definiert durch Enumerable.)

System_CAPS_pubmethodLongCount<Char>()

Überladen. Gibt eine Int64 , die die Gesamtanzahl von Elementen in einer Sequenz darstellt.(Definiert durch Enumerable.)

System_CAPS_pubmethodLongCount<Char>(Func<Char, Boolean>)

Überladen. Gibt ein Int64 das darstellt, wie viele Elemente in einer Sequenz eine Bedingung erfüllen.(Definiert durch Enumerable.)

System_CAPS_pubmethodMax<Char>()

Überladen. Gibt den Maximalwert in einer generischen Sequenz zurück.(Definiert durch Enumerable.)

System_CAPS_pubmethodMax<Char>(Func<Char, Decimal>)

Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt die maximale Decimal Wert.(Definiert durch Enumerable.)

System_CAPS_pubmethodMax<Char>(Func<Char, Double>)

Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt die maximale Double Wert.(Definiert durch Enumerable.)

System_CAPS_pubmethodMax<Char>(Func<Char, Int32>)

Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt die maximale Int32 Wert.(Definiert durch Enumerable.)

System_CAPS_pubmethodMax<Char>(Func<Char, Int64>)

Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt die maximale Int64 Wert.(Definiert durch Enumerable.)

System_CAPS_pubmethodMax<Char>(Func<Char, Nullable<Decimal>>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer Sequenz und gibt den Höchstwert zurück auf NULL festlegbare Decimal Wert.(Definiert durch Enumerable.)

System_CAPS_pubmethodMax<Char>(Func<Char, Nullable<Double>>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer Sequenz und gibt den Höchstwert zurück auf NULL festlegbare Double Wert.(Definiert durch Enumerable.)

System_CAPS_pubmethodMax<Char>(Func<Char, Nullable<Int32>>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer Sequenz und gibt den Höchstwert zurück auf NULL festlegbare Int32 Wert.(Definiert durch Enumerable.)

System_CAPS_pubmethodMax<Char>(Func<Char, Nullable<Int64>>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer Sequenz und gibt den Höchstwert zurück auf NULL festlegbare Int64 Wert.(Definiert durch Enumerable.)

System_CAPS_pubmethodMax<Char>(Func<Char, Nullable<Single>>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer Sequenz und gibt den Höchstwert zurück auf NULL festlegbare Single Wert.(Definiert durch Enumerable.)

System_CAPS_pubmethodMax<Char>(Func<Char, Single>)

Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt die maximale Single Wert.(Definiert durch Enumerable.)

System_CAPS_pubmethodMax<Char, TResult>(Func<Char, TResult>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer generischen Sequenz und gibt den höchsten Ergebniswert zurück.(Definiert durch Enumerable.)

System_CAPS_pubmethodMin<Char>()

Überladen. Gibt den Mindestwert in einer generischen Sequenz zurück.(Definiert durch Enumerable.)

System_CAPS_pubmethodMin<Char>(Func<Char, Decimal>)

Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den kleinsten Decimal Wert.(Definiert durch Enumerable.)

System_CAPS_pubmethodMin<Char>(Func<Char, Double>)

Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den kleinsten Double Wert.(Definiert durch Enumerable.)

System_CAPS_pubmethodMin<Char>(Func<Char, Int32>)

Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den kleinsten Int32 Wert.(Definiert durch Enumerable.)

System_CAPS_pubmethodMin<Char>(Func<Char, Int64>)

Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den kleinsten Int64 Wert.(Definiert durch Enumerable.)

System_CAPS_pubmethodMin<Char>(Func<Char, Nullable<Decimal>>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer Sequenz und gibt den kleinsten NULL-Werte zu Decimal Wert.(Definiert durch Enumerable.)

System_CAPS_pubmethodMin<Char>(Func<Char, Nullable<Double>>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer Sequenz und gibt den kleinsten NULL-Werte zu Double Wert.(Definiert durch Enumerable.)

System_CAPS_pubmethodMin<Char>(Func<Char, Nullable<Int32>>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer Sequenz und gibt den kleinsten NULL-Werte zu Int32 Wert.(Definiert durch Enumerable.)

System_CAPS_pubmethodMin<Char>(Func<Char, Nullable<Int64>>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer Sequenz und gibt den kleinsten NULL-Werte zu Int64 Wert.(Definiert durch Enumerable.)

System_CAPS_pubmethodMin<Char>(Func<Char, Nullable<Single>>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer Sequenz und gibt den kleinsten NULL-Werte zu Single Wert.(Definiert durch Enumerable.)

System_CAPS_pubmethodMin<Char>(Func<Char, Single>)

Überladen. Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf und gibt den kleinsten Single Wert.(Definiert durch Enumerable.)

System_CAPS_pubmethodMin<Char, TResult>(Func<Char, TResult>)

Überladen. Ruft eine Transformationsfunktion für jedes Element einer generischen Sequenz und gibt den niedrigsten Ergebniswert zurück.(Definiert durch Enumerable.)

System_CAPS_pubmethodOfType<TResult>()

Filtert die Elemente einer IEnumerable auf Grundlage eines angegebenen Typs.(Definiert durch Enumerable.)

System_CAPS_pubmethodOrderBy<Char, TKey>(Func<Char, TKey>)

Überladen. Sortiert die Elemente einer Sequenz in aufsteigender Reihenfolge nach einem Schlüssel.(Definiert durch Enumerable.)

System_CAPS_pubmethodOrderBy<Char, TKey>(Func<Char, TKey>, IComparer<TKey>)

Überladen. Sortiert die Elemente einer Sequenz in aufsteigender Reihenfolge mithilfe eines angegebenen Vergleichs.(Definiert durch Enumerable.)

System_CAPS_pubmethodOrderByDescending<Char, TKey>(Func<Char, TKey>)

Überladen. Sortiert die Elemente einer Sequenz in absteigender Reihenfolge nach einem Schlüssel.(Definiert durch Enumerable.)

System_CAPS_pubmethodOrderByDescending<Char, TKey>(Func<Char, TKey>, IComparer<TKey>)

Überladen. Sortiert die Elemente einer Sequenz mithilfe eines angegebenen Vergleichs in absteigender Reihenfolge.(Definiert durch Enumerable.)

System_CAPS_pubmethodReverse<Char>()

Kehrt die Reihenfolge der Elemente in einer Sequenz.(Definiert durch Enumerable.)

System_CAPS_pubmethodSelect<Char, TResult>(Func<Char, TResult>)

Überladen. Projiziert jedes Element einer Sequenz in ein neues Format.(Definiert durch Enumerable.)

System_CAPS_pubmethodSelect<Char, TResult>(Func<Char, Int32, TResult>)

Überladen. Projiziert jedes Element einer Sequenz in ein neues Formular durch den Index des Elements integriert wird.(Definiert durch Enumerable.)

System_CAPS_pubmethodSelectMany<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.(Definiert durch Enumerable.)

System_CAPS_pubmethodSelectMany<Char, TResult>(Func<Char, Int32, IEnumerable<TResult>>)

Überladen. Projiziert jedes Element einer Sequenz in ein IEnumerable<T>, und fasst die resultierenden Sequenzen in einer einzigen Sequenz zusammen. Der Index jedes Quellelements wird im projizierten Format des jeweiligen Elements verwendet.(Definiert durch Enumerable.)

System_CAPS_pubmethodSelectMany<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.(Definiert durch Enumerable.)

System_CAPS_pubmethodSelectMany<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.(Definiert durch Enumerable.)

System_CAPS_pubmethodSequenceEqual<Char>(IEnumerable<Char>)

Überladen. Bestimmt, ob zwei Sequenzen gleich sind, indem die Elemente mithilfe des Standardgleichheitsvergleichs für ihren Typ verglichen werden.(Definiert durch Enumerable.)

System_CAPS_pubmethodSequenceEqual<Char>(IEnumerable<Char>, IEqualityComparer<Char>)

Überladen. Bestimmt, ob zwei Sequenzen gleich sind, indem ihre Elemente mithilfe eines angegebenen verglichen IEqualityComparer<T>.(Definiert durch Enumerable.)

System_CAPS_pubmethodSingle<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.(Definiert durch Enumerable.)

System_CAPS_pubmethodSingle<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.(Definiert durch Enumerable.)

System_CAPS_pubmethodSingleOrDefault<Char>()

Überladen. Gibt das einzige Element einer Sequenz bzw. einen Standardwert zurück, wenn die Sequenz leer ist. Diese Methode löst eine Ausnahme aus, wenn mehr als ein Element in der Sequenz vorhanden ist.(Definiert durch Enumerable.)

System_CAPS_pubmethodSingleOrDefault<Char>(Func<Char, Boolean>)

Überladen. Gibt das einzige Element einer Sequenz, das eine angegebene Bedingung erfüllt, oder einen Standardwert zurück, wenn kein solches Element vorhanden ist. Diese Methode löst eine Ausnahme aus, wenn mehrere Elemente die Bedingung erfüllen.(Definiert durch Enumerable.)

System_CAPS_pubmethodSkip<Char>(Int32)

Umgeht eine festgelegte Anzahl von Elementen in einer Sequenz und gibt dann die übrigen Elemente zurück.(Definiert durch Enumerable.)

System_CAPS_pubmethodSkipWhile<Char>(Func<Char, Boolean>)

Überladen. Umgeht Elemente in einer Sequenz, solange eine angegebene Bedingung true ist, und gibt dann die übrigen Elemente zurück.(Definiert durch Enumerable.)

System_CAPS_pubmethodSkipWhile<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.(Definiert durch Enumerable.)

System_CAPS_pubmethodSum<Char>(Func<Char, Decimal>)

Überladen. Berechnet die Summe einer Sequenz von Decimal Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definiert durch Enumerable.)

System_CAPS_pubmethodSum<Char>(Func<Char, Double>)

Überladen. Berechnet die Summe einer Sequenz von Double Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definiert durch Enumerable.)

System_CAPS_pubmethodSum<Char>(Func<Char, Int32>)

Überladen. Berechnet die Summe einer Sequenz von Int32 Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definiert durch Enumerable.)

System_CAPS_pubmethodSum<Char>(Func<Char, Int64>)

Überladen. Berechnet die Summe einer Sequenz von Int64 Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definiert durch Enumerable.)

System_CAPS_pubmethodSum<Char>(Func<Char, Nullable<Decimal>>)

Überladen. Berechnet die Summe einer Sequenz von NULL-Werte zu Decimal Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definiert durch Enumerable.)

System_CAPS_pubmethodSum<Char>(Func<Char, Nullable<Double>>)

Überladen. Berechnet die Summe einer Sequenz von NULL-Werte zu Double Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definiert durch Enumerable.)

System_CAPS_pubmethodSum<Char>(Func<Char, Nullable<Int32>>)

Überladen. Berechnet die Summe einer Sequenz von NULL-Werte zu Int32 Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definiert durch Enumerable.)

System_CAPS_pubmethodSum<Char>(Func<Char, Nullable<Int64>>)

Überladen. Berechnet die Summe einer Sequenz von NULL-Werte zu Int64 Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definiert durch Enumerable.)

System_CAPS_pubmethodSum<Char>(Func<Char, Nullable<Single>>)

Überladen. Berechnet die Summe einer Sequenz von NULL-Werte zu Single Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definiert durch Enumerable.)

System_CAPS_pubmethodSum<Char>(Func<Char, Single>)

Überladen. Berechnet die Summe einer Sequenz von Single Werte, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden.(Definiert durch Enumerable.)

System_CAPS_pubmethodTake<Char>(Int32)

Gibt eine angegebene Anzahl von zusammenhängenden Elementen ab dem Anfang einer Sequenz zurück.(Definiert durch Enumerable.)

System_CAPS_pubmethodTakeWhile<Char>(Func<Char, Boolean>)

Überladen. Gibt Elemente aus einer Sequenz zurück, solange eine angegebene Bedingung true ist.(Definiert durch Enumerable.)

System_CAPS_pubmethodTakeWhile<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.(Definiert durch Enumerable.)

System_CAPS_pubmethodToArray<Char>()

Erstellt ein Array aus einem IEnumerable<T>.(Definiert durch Enumerable.)

System_CAPS_pubmethodToDictionary<Char, TKey>(Func<Char, TKey>)

Überladen. Erstellt eine Dictionary<TKey, TValue> aus einem IEnumerable<T> entsprechend einer angegebenen Schlüsselauswahlfunktion.(Definiert durch Enumerable.)

System_CAPS_pubmethodToDictionary<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)

Überladen. Erstellt eine Dictionary<TKey, TValue> aus einem IEnumerable<T> entsprechend einer angegebenen Schlüsselauswahlfunktion und eines angegebenen Schlüsselvergleichs.(Definiert durch Enumerable.)

System_CAPS_pubmethodToDictionary<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)

Überladen. Erstellt eine Dictionary<TKey, TValue> aus einem IEnumerable<T> entsprechend der angegebenen Schlüsselauswahlfunktion und Elementauswahlfunktion.(Definiert durch Enumerable.)

System_CAPS_pubmethodToDictionary<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)

Überladen. Erstellt eine Dictionary<TKey, TValue> aus einem IEnumerable<T> entsprechend einer angegebenen Schlüsselauswahlfunktion, einem Vergleich und einer Elementauswahlfunktion.(Definiert durch Enumerable.)

System_CAPS_pubmethodToList<Char>()

Erstellt ein List<T> aus einem IEnumerable<T>.(Definiert durch Enumerable.)

System_CAPS_pubmethodToLookup<Char, TKey>(Func<Char, TKey>)

Überladen. Erstellt eine Lookup<TKey, TElement> aus einem IEnumerable<T> entsprechend einer angegebenen Schlüsselauswahlfunktion.(Definiert durch Enumerable.)

System_CAPS_pubmethodToLookup<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)

Überladen. Erstellt eine Lookup<TKey, TElement> aus einem IEnumerable<T> entsprechend einer angegebenen Schlüsselauswahlfunktion und eines angegebenen Schlüsselvergleichs.(Definiert durch Enumerable.)

System_CAPS_pubmethodToLookup<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)

Überladen. Erstellt eine Lookup<TKey, TElement> aus einem IEnumerable<T> entsprechend der angegebenen Schlüsselauswahlfunktion und Elementauswahlfunktion.(Definiert durch Enumerable.)

System_CAPS_pubmethodToLookup<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)

Überladen. Erstellt eine Lookup<TKey, TElement> aus einem IEnumerable<T> entsprechend einer angegebenen Schlüsselauswahlfunktion, einem Vergleich und einer Elementauswahlfunktion.(Definiert durch Enumerable.)

System_CAPS_pubmethodUnion<Char>(IEnumerable<Char>)

Überladen. Erzeugt die Vereinigungsmenge von zwei Sequenzen mithilfe des Standardgleichheitsvergleichs.(Definiert durch Enumerable.)

System_CAPS_pubmethodUnion<Char>(IEnumerable<Char>, IEqualityComparer<Char>)

Überladen. Erzeugt die Vereinigungsmenge von zwei Sequenzen mithilfe eines angegebenen IEqualityComparer<T>.(Definiert durch Enumerable.)

System_CAPS_pubmethodWhere<Char>(Func<Char, Boolean>)

Überladen. Filtert eine Sequenz von Werten basierend auf einem Prädikat.(Definiert durch Enumerable.)

System_CAPS_pubmethodWhere<Char>(Func<Char, Int32, Boolean>)

Überladen. Filtert eine Sequenz von Werten basierend auf einem Prädikat. In der Logik der Prädikatfunktion wird der Index der einzelnen Elemente verwendet.(Definiert durch Enumerable.)

System_CAPS_pubmethodZip<Char, TSecond, TResult>(IEnumerable<TSecond>, Func<Char, TSecond, TResult>)

Wendet eine angegebene Funktion auf die entsprechenden Elemente von zwei Sequenzen eine Sequenz der Ergebnisse erzeugen.(Definiert durch Enumerable.)

System_CAPS_noteHinweis

Die .NET Framework-Quellcodes für diesen Typ finden Sie unter der Reference Source. Sie können den Quellcode online Durchsuchen, Referenz für die Offlineanzeige herunterladen und schrittweise durchlaufen (inklusive Patches und Updates) während des Debuggens; see instructions.

Eine Zeichenfolge ist eine sequenzielle Auflistung von Zeichen, die zum Darstellen von Text verwendet wird. Ein String Objekt ist eine sequenzielle Auflistung von System.Char Objekte, die darstellen, eine Zeichenfolge; ein System.Char -Objekt entspricht einer Codeeinheit UTF-16. Der Wert, der die String Objekt befindet sich der Inhalt der sequenziellen Auflistung von System.Char Objekte und Wert unveränderlich ist (d. h., sie ist schreibgeschützt). Weitere Informationen über die Unveränderlichkeit von Zeichenfolgen, finden Sie unter der Unveränderlichkeit und der StringBuilder-Klasse weiter unten in diesem Thema. Die maximale Größe einer String Objekt im Arbeitsspeicher ist 2 GB oder ungefähr 1 Milliarde Zeichen.

In diesem Abschnitt

Instanziieren ein String-Objekt
Char-Objekte und Unicode-Zeichen
Zeichenfolgen und Unicode-Standard
Zeichenfolgen und eingebettete Null-Zeichen
Zeichenfolgen und Indizes
NULL-Zeichenfolgen und leere Zeichenfolgen
Unveränderlichkeit und der StringBuilder-Klasse
Ordnungszahl im Vergleich zu kulturabhängige Operationen
Normalisierung
Zeichenfolgenoperationen nach Kategorie

Instanziieren Sie ein String Objekt auf folgende Weise:

  • Durch Zuweisen eines Zeichenfolgenliterals zu einer String Variable. Dies ist die am häufigsten verwendete Methode zum Erstellen einer Zeichenfolge. Im folgenden Beispiel wird die Zuordnung zum Erstellen von mehreren Zeichenfolgen. Beachten Sie, dass in C# geschrieben, da der umgekehrte Schrägstrich (\) ein Escapezeichen ist, literal umgekehrte Schrägstriche in einer Zeichenfolge mit Escapezeichen versehen werden müssen oder die gesamte Zeichenfolge muss mit vorangestelltem @-Zeichen sein.

    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 einer String Klassenkonstruktor. Im folgende Beispiel werden Zeichenfolgen durch Aufrufen von mehreren Klassenkonstruktoren instanziiert. Beachten Sie, dass einige der Konstruktoren Zeiger auf Zeichen oder mit Vorzeichen Bytearrays als Parameter enthalten. Visual Basic unterstützt keine Aufrufe dieser Konstruktoren. Ausführliche Informationen zu String Konstruktoren finden Sie unter der String Konstruktor Zusammenfassung.

    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  
    
  • Mithilfe des Operators für zeichenfolgenverkettung (+ in C# geschrieben und / oder + in Visual Basic) So erstellen Sie eine einzelne Zeichenfolge aus einer beliebigen Kombination String Instanzen und Zeichenfolgenliterale. Das folgende Beispiel veranschaulicht die Verwendung der der Operator für 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.
    
  • Abrufen einer Eigenschaft oder eine Methode aufrufen, die eine Zeichenfolge zurückgibt. Das folgende Beispiel verwendet die Methoden der String Klasse, um eine Unterzeichenfolge aus einer größeren Zeichenfolge zu extrahieren.

    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 Aufrufen einer Formatierungsmethode um einen Wert oder ein Objekt in seine Zeichenfolgendarstellung zu konvertieren. Im folgenden Beispiel wird die kombinierte Formatierung Funktion, um die Zeichenfolgendarstellung von zwei Objekten in eine Zeichenfolge einzubetten.

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

Jedes Zeichen in einer Zeichenfolge wird durch einen skalaren Unicodewert, auch als einen Unicode-Codepunkt oder den Ordinalwert des Unicode-Zeichens (numerisch) definiert. Jeden Codepunkt mithilfe von UTF-16-Codierung codiert ist, und der numerische Wert der einzelnen Elemente der Codierung wird dargestellt, indem ein Char Objekt.

System_CAPS_noteHinweis

Beachten Sie Folgendes: Da ein String -Instanz besteht aus einer sequenziellen Auflistung von UTF-16-Codeeinheiten, es ist möglich, erstellen Sie eine String -Objekt, das keine Unicode-Zeichenfolge wohlgeformt ist. Beispielsweise ist es möglich, eine Zeichenfolge zu erstellen, die ein niedriges Ersatzzeichen ohne entsprechenden hohes Ersatzzeichen ist. Obwohl einige Methoden, z. B. die Methoden der Codierung und Decodierung von Objekten in der System.Text Namespace, möglicherweise führt Überprüfungen, um sicherzustellen, dass Zeichenfolgen wohlgeformt sind String Klassenmember gewährleisten nicht, dass eine Zeichenfolge wohlgeformt ist.

Ein einzelnes Char Objekt stellt normalerweise eine einzelne Codepunkt, d. h. den numerischen Wert der Char Codepunkt entspricht. Z. B. den Codepunkt für das Zeichen "a" ist U + 0061 ist. Allerdings erfordert ein Codepunkt möglicherweise mehr als eine codiertes Element (mehr als ein Char Objekt). Die Unicode-Standard definiert zwei Typen von Zeichen, die entsprechen mit mehreren Char Objekte: Graphemes und ergänzende Unicode-Codepunkten, die die zusätzlichen Ebenen von Unicode-Zeichen entsprechen.

  • Eine zwischen graphemgruppen wird durch ein Basiszeichen gefolgt von mindestens Kombinationszeichen dargestellt. Das Zeichen "ä" wird beispielsweise dargestellt, durch ein Char Objekt, dessen Codepunkt U + 0061 ist, gefolgt von einem Char Objekt, dessen Codepunkt U + 0308. Diese Zeichen kann auch über einen einzelnen definiert Char Objekt, das einen Codepunkt U + 00E4 verfügt. Wie im folgenden Beispiel wird gezeigt, gibt ein kulturabhängiger Vergleich, Gleichheit, dass diese zwei Darstellungen gleich sind, obwohl Sie ein Ordinalvergleich durch normaler nicht der Fall ist. Wenn die beiden Zeichenfolgen normalisiert werden, gibt hingegen ein ordinalen Vergleich auch, dass sie gleich sind. (Weitere Informationen zum Normalisieren von Zeichenfolgen finden Sie unter der Normalisierung Abschnitt.)

    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
    
  • Eine Unicode ergänzende Codepunkt (ein Ersatzzeichenpaar) wird durch eine Char -Objekt, dessen Codepunkt ein hohes Ersatzzeichen ist, gefolgt von einer Char -Objekt, dessen Codepunkt ein niedriges Ersatzzeichen ist. Die Codeeinheiten der hohe Ersatzzeichen zwischen U + D800 und U + DBFF liegt. Die Codeeinheiten der niedrige Ersatzzeichen liegen zwischen U + DC00 und U + DFFF. Ersatzzeichenpaare werden verwendet, um Zeichen in die 16 ergänzenden Unicode-Ebenen darstellen. Das folgende Beispiel erstellt ein Ersatzzeichen und übergibt es an die Char.IsSurrogatePair(Char, Char) Methode, um zu bestimmen, ob es sich um 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
    

Zeichen in einer Zeichenfolge von UTF-16-codierte Codeeinheiten, die entsprechen dargestellt sind Char Werte.

Jedes Zeichen in einer Zeichenfolge verfügt über eine Kategorie zugeordneten Unicode-Zeichen, die in .NET Framework durch dargestellt wird die UnicodeCategory Enumeration. Die Kategorie eines Zeichens oder ein Ersatzzeichenpaar kann bestimmt werden, durch Aufrufen der CharUnicodeInfo.GetUnicodeCategory Methode.

.NET Framework behält eine eigene Tabelle von Zeichen und ihrer entsprechenden Kategorien, der sicherstellt, dass eine Version von .NET Framework, die auf anderen Plattformen ausgeführt Kategorieinformationen identische Zeichen zurückgibt. Die folgende Tabelle enthält die Versionen von .NET Framework und die Versionen im Unicode-Standard, auf denen ihre Zeichenkategorien basieren.

.NET Framework-Version

Version des Unicode-Standards

.NET Framework 1.1

The Unicode Standard, Version 4.0.0

.NET Framework 2.0

The Unicode Standard, Version 5.0.0

.NET Framework 3.5

The Unicode Standard, Version 5.0.0

.NET Framework 4

The Unicode Standard, Version 5.0.0

.NET Framework 4.5

The Unicode Standard, Version 6.3.0

.NET Framework 4.5.1

The Unicode Standard, Version 6.3.0

.NET Framework 4.5.2

The Unicode Standard, Version 6.3.0

.NET Framework 4.6

The Unicode Standard, Version 6.3.0

.NET Framework 4.6.1

The Unicode Standard, Version 6.3.0

.NET Framework 4.6.2

The Unicode Standard, Version 8.0.0

Darüber hinaus unterstützt .NET Framework Zeichenfolgenvergleich und Sortierung basierend auf den Unicode-Standard. In Versionen von .NET Framework über die .NET Framework 4, .NET Framework verwaltet eine eigenen Tabelle von Zeichenfolgendaten. Dies gilt auch, beginnend mit .NET Framework-Versionen der .NET Framework 4.5 auf Windows 7 ausgeführt wird. Beginnend mit der .NET Framework 4.5 auf Windows 8 und höheren Versionen von Windows-Betriebssystem ausgeführt wird, die die Common Language Runtime-Delegaten Zeichenfolge Vergleichs- und Sortiervorgänge für das Betriebssystem. Die folgende Tabelle enthält die Versionen von .NET Framework und die Versionen im Unicode-Standard, auf welches Zeichen Vergleich und Sortierung basieren.

.NET Framework-Version

Version des Unicode-Standards

.NET Framework 1.1

The Unicode Standard, Version 4.0.0

.NET Framework 2.0

The Unicode Standard, Version 5.0.0

.NET Framework 3.5

The Unicode Standard, Version 5.0.0

.NET Framework 4

The Unicode Standard, Version 5.0.0

.NET Framework 4.5und höher unter Windows 7

The Unicode Standard, Version 5.0.0

.NET Framework 4.5und höher unter Windows 8 und höheren Windows-Betriebssysteme

The Unicode Standard, Version 6.3.0

In .NET Framework eine String Objekt kann eingebettete Null-Zeichen, die Anzahl der im Rahmen der Länge der Zeichenfolge enthalten. Jedoch in einigen Sprachen wie C# und C++, ein Null-Zeichen gibt das Ende einer Zeichenfolge, die nicht als einen Teil der Zeichenfolge und wird als Teil der Länge der Zeichenfolge nicht gezählt. Dies bedeutet, dass die folgenden allgemeinen Annahmen, die C- und C++-Programmierer oder Bibliotheken, die in C oder C++ geschriebene über Zeichenfolgen, die möglicherweise nicht unbedingt gültig, wenn Sie zugewiesen sind String Objekte:

  • Der zurückgegebene Wert den strlen oder wcslen Funktionen entspricht nicht unbedingt String.Length.

  • Die Zeichenfolge, die erstellt, indem die strcpy_s oder wcscpy_s Funktionen ist nicht unbedingt identisch mit der Zeichenfolge erstellt, indem die String.Copy Methode.

Sie sollten sicherstellen, dass diese systemeigene C- und C++-Code, der instanziiert String Benutzerobjekten und Code, der übergeben wird String Objekte über Platform aufrufen, sollte Sie nicht davon ausgegangen, dass ein eingebettetes Null-Zeichen das Ende der Zeichenfolge markiert.

Eingebettete Null-Zeichen in einer Zeichenfolge werden ebenfalls anders behandelt werden, wenn eine Zeichenfolge sortiert (oder verglichen) und eine Zeichenfolge durchsucht wird. NULL-Zeichen werden ignoriert, wenn kulturabhängige Vergleiche zwischen zwei Zeichenfolgen, einschließlich vergleichen, die mit der invarianten Kultur ausgeführt. Diese sind nur für die Ordinalvergleiche von ordinal oder Groß-/Kleinschreibung berücksichtigt. Andererseits, eingebettete Null-Zeichen werden immer berücksichtigt, wenn eine Zeichenfolge mit Methoden wie z. B. Suche Contains, StartsWith, und IndexOf.

Ein Index ist die Position des eine Char Objekt (nicht in ein Unicode-Zeichen) in einem String. Ein Index ist eine nullbasierte, nicht negative Zahl, die von der ersten Position in der Zeichenfolge beginnt, der Indexposition 0 (null) ist. Eine Reihe von Methoden wie z. B. IndexOf und LastIndexOf, zurückgeben den Index eines Zeichens oder einer Teilzeichenfolge in der Zeichenfolgeninstanz.

Die Chars Eigenschaft ermöglicht den Zugriff auf einzelne Char Objekte durch ihre Indexposition in der Zeichenfolge. Da die Chars Eigenschaft ist die Standardeigenschaft (in Visual Basic) oder Indexer (in c#), können Sie die einzelnen zugreifen Char Objekte in einer Zeichenfolge durch folgenden Code verwenden. Dieser Code sucht nach Leerzeichen oder Satzzeichen in eine Zeichenfolge, 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 implementiert die IEnumerable -Schnittstelle, Sie können auch durchlaufen die Char Objekte in einer Zeichenfolge mit einer foreach Konstrukt, wie im folgenden Beispiel gezeigt.

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 entspricht möglicherweise nicht aufeinander folgenden Unicode-Zeichen, da ein Zeichen möglicherweise Unicode codiert als mehr als ein Char Objekt. Insbesondere kann eine Zeichenfolge mehreren Zeichen Einheiten von Text enthalten, die durch ein Basiszeichen gefolgt durch eine oder mehrere Kombinationszeichen oder von Ersatzzeichenpaaren gebildet werden. Arbeiten mit Unicode-Zeichen anstelle von Char verwenden Sie die Objekte, die System.Globalization.StringInfo und TextElementEnumerator Klassen. Das folgende Beispiel veranschaulicht den Unterschied zwischen Code, mit der Funktionsweise Char Benutzerobjekten und Code, die mit Unicode-Zeichen. Die Anzahl der Zeichen oder Textelemente in der jedes Wort im Satz verglichen. Die Zeichenfolge enthält zwei Sequenzen von eines Basiszeichens gefolgt von einer Kombination von Zeichen.

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

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

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

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

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

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

Dieses Beispiel funktioniert mit Textelemente mithilfe der StringInfo.GetTextElementEnumerator Methode und die TextElementEnumerator Klasse, um die Textelemente einer Zeichenfolge aufgelistet. Sie können auch ein Array, das durch Aufrufen der Startindex des jedes Textelement enthält Abrufen der StringInfo.ParseCombiningCharacters Methode.

Weitere Informationen zum Arbeiten mit Einheiten eher Text als einzelne Char -Werte finden Sie in der StringInfo Klasse.

Eine Zeichenfolge, die deklariert wurde, jedoch wurde kein Wert zugewiesen ist null. Beim Aufrufen von Methoden für diese Zeichenfolge löst eine NullReferenceException. Eine null-Zeichenfolge unterscheidet sich von einer leeren Zeichenfolge, d. h. eine Zeichenfolge, deren Wert "" oder String.Empty. In einigen Fällen löst eine Ausnahme aus, wenn Sie eine null-Zeichenfolge oder eine leere Zeichenfolge als Argument in einem Methodenaufruf übergeben. Z. B. eine null-Zeichenfolge zu übergeben der Int32.Parse -Methode löst eine ArgumentNullException, und übergeben einer leeren Zeichenfolge löst eine FormatException. In anderen Fällen kann ein Methodenargument eine null-Zeichenfolge oder eine leere Zeichenfolge sein. Wenn Sie bereit sind z. B. eine IFormattable Implementierung für eine Klasse, eine null-Zeichenfolge und eine leere Zeichenfolge mit der allgemeine Formatbezeichner ("G") entsprechen soll.

Die String Klasse enthält die folgenden zwei Hilfsmethoden, mit denen Sie überprüfen, ob eine Zeichenfolge ist null oder leer:

  • IsNullOrEmpty, der angibt, ob eine Zeichenfolge entweder ist null oder gleich String.Empty. Diese Methode entfällt die Notwendigkeit, den folgenden Code verwenden:

    if (str == null || str.Equals(String.Empty))
    
  • IsNullOrWhiteSpace, der angibt, ob eine Zeichenfolge ist null, gleich String.Empty, oder ausschließlich aus Leerzeichen besteht. Diese Methode entfällt die Notwendigkeit, den folgenden Code verwenden:

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

Im folgenden Beispiel wird die IsNullOrEmpty Methode in der IFormattable.ToString Implementierung eines benutzerdefinierten Temperature Klasse. Die Methode unterstützt die Formatzeichenfolgen "G", "C", "F" und "K". Wenn eine leere Zeichenfolge oder ein Format, dessen Wert eine Zeichenfolge ist null übergeben wird an die Methode wird der Wert in der Formatzeichenfolge "G" 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));
   }                                   
}

Ein String Objekt heißt unveränderlich (schreibgeschützt), da der Wert kann nicht geändert werden, nachdem es erstellt wurde. Methoden, die angezeigt werden, so ändern Sie eine String Objekt zurückgeben tatsächlich ein neues String -Objekt, das die Änderung enthält.

Da Zeichenfolgen unveränderlich sind, so lange Zeichenfolge-manipulationsroutinen, die ausführen hinzugefügten oder gelöschten, was angezeigt wird, sein, dass eine einzelne Zeichenfolge erhebliche Leistungseinbußen genauen kann wiederholt. Der folgende Code verwendet beispielsweise einen Zufallszahlengenerator So erstellen Sie eine Zeichenfolge mit 1000 Zeichen im Bereich 0 x 0001, 0x052F an. Obwohl der Code zum Verketten von Zeichenfolgen zu verwenden wird, um ein neues Zeichen in die vorhandene Zeichenfolge mit dem Namen Anfügen str, tatsächlich wird ein neuer 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();
   }
}

Können Sie die StringBuilder -Klasse statt der String Klasse für Vorgänge, die mehrere Änderungen an den Wert einer Zeichenfolge vornehmen. Im Gegensatz zu Instanzen der String Klasse StringBuilder Objekte sind änderbar; beim Verketten, Anfügen oder Teilzeichenfolgen aus einer Zeichenfolge zu löschen, werden die Vorgänge auf einer einzelnen Zeichenfolge. Nach Abschluss des Ändern des Werts einer StringBuilder -Objekts können Sie erreichen die StringBuilder.ToString Methode in eine Zeichenfolge zu konvertieren. Im folgende Beispiel ersetzt die String zum Verketten von 1000 zufälligen Zeichen im Bereich 0 x 0001 bis 0x052F mit im vorherigen Beispiel verwendet eine StringBuilder Objekt.

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

Mitglieder der String Klasse ordinal oder kulturabhängige (linguistische) Vorgänge ausführen, auf eine String Objekt. Ein ordinal Vorgang ausgeführt wird, nach dem numerischen Wert der einzelnen Char Objekt. Eine kulturabhängige Operation wird der Wert von der String-Objekt, und nimmt kulturspezifische Groß-/Kleinschreibung, Sortierung Formatierung und Analyse Regeln berücksichtigt. Kulturabhängige Operationen im Kontext einer explizit deklarierten Kultur oder die implizite aktuelle Kultur ausgeführt werden. Die zwei Arten von Vorgängen können sehr unterschiedliche Ergebnisse erzeugen, wenn sie auf die gleiche Zeichenfolge ausgeführt werden.

.NET Framework unterstützt auch kulturunabhängige linguistische Zeichenfolgenoperationen mit der invarianten Kultur (CultureInfo.InvariantCulture), die lose basiert auf den kultureinstellungen des der englischen Sprache, die unabhängig von der Region. Im Gegensatz zu anderen System.Globalization.CultureInfo Einstellungen, die von der invarianten Kultur ist sichergestellt, dass auf einem einzelnen Computer, von System zu System und in .NET Framework-Versionen konsistent bleiben. Die invariante Kultur kann als eine Art schwarzes Kästchen, die Stabilität von Zeichenfolgenvergleichen wird sichergestellt, dass Sicht- und Reihenfolge in allen Kulturen gleich.

System_CAPS_security Sicherheit Hinweis

Wenn Ihre Anwendung eine sicherheitsentscheidung zu einer symbolischen Bezeichner, z. B. einen Dateinamen stellt oder Pipes benannte oder zu persistente Daten, z. B. die textbasierten Daten in eine XML-Datei, sollten der Vorgang einen ordinalen Vergleich anstelle einer kulturabhängigen Vergleich verwenden. Grund hierfür ist ein kulturabhängiger Vergleich aktiviert ist, je nach Kultur unterschiedliche Ergebnisse führen kann hingegen ein ordinalen Vergleich ausschließlich auf den binären Wert der verglichenen Zeichen abhängig ist.

System_CAPS_importantWichtig

Die meisten Methoden zum Ausführen von Zeichenfolgenoperationen enthalten eine Überladung, die einen vom Typ Parameter StringComparison, können Sie angeben, ob die Methode einen ordinalen oder kulturabhängigen Vorgang ausführt. Im Allgemeinen sollten Sie diese Überladung, um den Zweck der Methode Methodenaufrufs eindeutig anzugeben aufrufen. Best Practices und Anleitungen für die Verwendung von Ordnungszahlen und kulturabhängige Operations mit Zeichenfolgen finden Sie unter Empfohlene Vorgehensweisen für die Verwendung von Zeichenfolgen in .NET Framework.

Vorgänge für Schreibweise, analysieren und formatieren, Vergleich und Sortierung, und Testen auf Gleichheit kann ordinal oder kulturabhängig sein. Den folgenden Abschnitten werden die einzelnen Kategorien des Vorgangs.

System_CAPS_tipTipp

Sie sollten immer eine methodenüberladung aufrufen, die den Zweck der Methode Methodenaufrufs eindeutig macht. Z. B. statt der Compare(String, String) Methode einen kulturabhängiger Vergleich von zwei Zeichenfolgen durchgeführt wird, wird mit den Konventionen der aktuellen Kultur, rufen Sie die Compare(String, String, StringComparison) Methode mit einem Wert von StringComparison.CurrentCulture für die comparisonType Argument. Weitere Informationen finden Sie unter Empfohlene Vorgehensweisen für die Verwendung von Zeichenfolgen in .NET Framework.

Regeln Groß-und Kleinschreibung bestimmen, wie die Groß-/Kleinschreibung von einem Unicode-Zeichen ändern. z. B. von Klein-in Großbuchstaben konvertiert wurden. Häufig wird ein Schreibweise Vorgang vor einem Zeichenfolgenvergleich ausgeführt. Beispielsweise kann eine Zeichenfolge in Großbuchstaben konvertiert werden, damit es mit einer anderen Zeichenfolge in Großbuchstaben verglichen werden kann. Sie können die Zeichen in einer Zeichenfolge durch den Aufruf in Kleinbuchstaben konvertieren die ToLower oder ToLowerInvariant Methode, und Sie können diese durch Aufrufen von Großbuchstaben konvertieren die ToUpper oder ToUpperInvariant Methode. Darüber hinaus können Sie die TextInfo.ToTitleCase Methode zum Konvertieren einer Zeichenfolge in titelschreibung.

Schreibweise Vorgänge können auf den Regeln der aktuellen Kultur, einer angegebenen Kultur oder der invarianten Kultur basieren. Da schreibungszuordnungen abhängig von der verwendeten Kultur variieren können, kann das Ergebnis der Schreibweise Vorgänge basierend auf der Kultur variieren. Die tatsächliche Unterschiede in Groß-/Kleinschreibung gibt drei Arten:

  • Unterschiede in der Groß-/Kleinschreibung Zuordnung von LATIN CAPITAL LETTER I (U + 0049), kleine Buchstaben LATEINISCH I (U + 0069), LATIN CAPITAL LETTER I mit Punkt oben (U + 0130) und LATIN kleine Buchstaben ohne Punkte I (U + 0131). Das tr-TR (Türkisch (Türkei)) und az-Latn-AZ (Aserbaidschan, Lateinisch) Kulturen im tr, az und az-Latn neutralen Kulturen die kleinbuchstabenentsprechung von LATIN CAPITAL LETTER I ist LATIN kleine Buchstaben ohne Punkte I und der entsprechende Großbuchstabe LATIN kleine Buchstaben I LATIN CAPITAL LETTER I mit Punkt oben ist. In anderen Kulturen einschließlich der invarianten Kultur, kleine Buchstaben LATEINISCH I und LATIN CAPITAL LETTER ich und Großbuchstaben, Kleinbuchstaben Entsprechungen sind.

    Im folgenden Beispiel wird veranschaulicht, wie ein Zeichenfolgenvergleich entwickelt um zu verhindern, dass bei der normalen Dateisystemzugriffs fehlschlagen können, wenn es auf einem Vergleich kulturabhängig Groß-/Kleinschreibung beruht. (Die Groß-/ Kleinschreibungskonventionen der invarianten Kultur sollte verwendet werden.)

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

    Zeichen

    Wenn in geändert

    Returns

    NM-ZEICHEN (U + 00B5)

    Großbuchstaben

    GRIECHISCH GROSSBUCHSTABE MU (U +-39C)

    LATIN CAPITAL LETTER ICH PUNKT OBEN (U + 0130)

    Kleinbuchstaben

    KLEINE LATEINISCHE BUCHSTABEN I (U + 0069)

    LATEINISCHE KLEINBUCHSTABEN OHNE PUNKTE ICH (U + 0131)

    Großbuchstaben

    LATIN CAPITAL LETTER ICH (U + 0049)

    KLEINES LATEINISCHES LANGE S (U + 017F.)

    Großbuchstaben

    LATIN CAPITAL LETTER S (U + 0053)

    LATIN CAPITAL LETTER D MIT KLEINEN BUCHSTABEN Z MIT HÁČEK (U + 01C 5)

    Kleinbuchstaben

    KLEINES LATEINISCHES DZ MIT HÁČEK (U + 01C 6)

    KOMBINIEREN VON YPOGRAMMENI (U + 0345)

    Großbuchstaben

    GRIECHISCH GROSSBUCHSTABE IOTA (U + 0399)

  • Unterschiede in der Groß-Kleinschreibung von zweibuchstabigen Paaren mit gemischter Groß-Kleinschreibung aus dem ASCII-Zeichenbereich. In den meisten Kulturen entspricht ein zweistelliger gemischter Groß-/Kleinschreibung-Paar an das entsprechende Paar aus zwei Buchstaben bestehende Groß- oder Kleinbuchstaben. Dies gilt nicht für die folgenden zwei Buchstaben bestehende-Paare in der folgenden Kulturen, da in jedem Fall an einen Digraph verglichen werden:

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

    • "cH" in der Cs-CZ (Tschechisch (Tschechische Republik)) und Kulturen sk-SK (Slowakisch (Slowakei)).

    • "aA" in der Kultur da-DK (Dänisch (Dänemark)).

    • "cS", "dZ", "dZS", "nY", "sZ", "tY" und "zS" in der Kultur Hu-HU (Ungarisch (Ungarn)).

    • "cH" und "lL" in der Kultur es-ES_tradnl (Spanisch (Spanien, Traditionelle Sortierung)).

    • "cH", "gI", "kH", "nG", "nH", "pH", "qU", "tH" und "tR" in der Kultur des vi-VN (Vietnamesisch (Vietnam)).

    Es ist jedoch ungewöhnlich, die eine Situation, in der ein kulturabhängiger Vergleich dieser Paare Probleme erstellt, auftreten, da diese Paare feste Zeichenfolgen oder Bezeichner nicht üblich sind.

Das folgende Beispiel veranschaulicht einige der Unterschiede in Regeln Groß-und Kleinschreibung zwischen Kulturen beim Konvertieren von Zeichenfolgen in Großbuchstaben.

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 

Formatierung und Analyse sind umgekehrte Vorgänge. Formatierungsregeln bestimmen, wie einen Wert, z. B. ein Datum und Uhrzeit oder einer Zahl in die Zeichenfolgendarstellung konvertieren während Analyseregeln bestimmen, wie eine Zeichenfolgendarstellung auf einen Wert wie ein Datum und eine Uhrzeit konvertiert. Kulturelle Konventionen hängen sowohl Formatierung und Analyse für Regeln. Das folgende Beispiel veranschaulicht die Mehrdeutigkeit, die auftreten kann, wenn eine kulturspezifische Datumszeichenfolge zu interpretieren. Ohne zu wissen, die Konventionen der Kultur, 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 am 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

Auf ähnliche Weise wie im folgenden Beispiel wird gezeigt, kann eine einzelne Zeichenfolge verschiedene Datumsangaben abhängig von der Kultur erzeugen, deren Konventionen in der 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

Konventionen für den Vergleich und Sortierung von Zeichenfolgen variieren Kulturen. Beispielsweise kann die Sortierreihenfolge für Phonetics oder für die visuelle Darstellung der Zeichen basieren. In ostasiatischen Sprachen werden Zeichen anhand der Anzahl der Striche und der Radikale der Ideogramme sortiert. Die Sortierung hängt außerdem von der Reihenfolge ab, die das Alphabet der jeweiligen Sprache bzw. Kultur aufweist. Im Dänischen gibt es beispielsweise das Zeichen "Æ", das im Alphabet nach dem Zeichen "Z" einsortiert ist. Darüber hinaus Vergleiche können Groß- und Kleinschreibung beachtet werden, und in einigen Fällen Regeln Groß-und Kleinschreibung unterscheiden sich auch von Kultur. Ordinalvergleich verwendet andererseits, die Unicode-Codepunkten der einzelnen Zeichen in eine Zeichenfolge, die beim Vergleichen und Sortieren von Zeichenfolgen.

Sortierregeln, die bestimmen, dass die alphabetische Reihenfolge von Unicode-Zeichen und wie zwei Zeichenfolgen miteinander vergleichen. Z. B. die String.Compare(String, String, StringComparison) Methode vergleicht zwei Zeichenfolgen, die auf der Grundlage der StringComparison Parameter. Wenn der Parameterwert ist StringComparison.CurrentCulture, die Methode führt einen linguistischen Vergleich, der die Konventionen der aktuellen Kultur; verwendet, wenn der Parameterwert ist StringComparison.Ordinal, die Methode führt einen Ordinalvergleich. Folglich, wie im folgenden Beispiel gezeigt, wenn die aktuelle Kultur "USA" Englisch, der erste Aufruf der String.Compare(String, String, StringComparison) (mithilfe von kulturabhängigen Vergleich) Methode betrachtet "a" kleiner als "A", aber der zweite Aufruf von derselben Methode (mit Ordinalvergleich) betrachtet "a" 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 Word, String und Ordinalsortierung:

  • 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 ggf. wird der Bindestrich (-) eine sehr geringe Gewichtung zugeordnet, sodass "Coop" und "Co-op" in einer sortierten Liste nebeneinander angezeigt werden. Eine Liste der StringMethoden, die zwei Zeichenfolgen mithilfe von Word-Sortierregeln, Vergleichen finden Sie unter der Zeichenfolgenoperationen nach Kategorie Abschnitt.

  • Eine Sortierung Zeichenfolge führt auch einen kulturabhängigen Vergleich. Es ähnelt der eine Sortierung Wort identisch, es keine spezielle Fälle gibt und alle nicht alphanumerische Symbole, vor den alphanumerischen Unicode-Zeichen stammen. Zwei Zeichenfolgen können verglichen werden, mithilfe von Zeichenfolgensortierregeln durch Aufrufen der CompareInfo.Compare methodenüberladungen, die über eine options Parameter bereitgestellte Wert CompareOptions.StringSort. Beachten Sie, dass dies die einzige Methode, die .NET Framework zum Vergleichen von zwei Zeichenfolgen mithilfe von Zeichenfolgensortierregeln bereitstellt.

  • Eine Ordinalsortierung vergleicht Zeichenfolgen anhand des numerischen Werts jedes Char-Objekts in der Zeichenfolge. Ein ordinalen Vergleich ist automatisch die Groß-/Kleinschreibung beachtet, da die Groß- und Kleinbuchstaben Versionen eines Zeichens unterschiedliche Codepunkte aufweisen. Wenn die Anfrage nicht wichtig ist, können Sie einen ordinalen Vergleich angeben, der Groß-und Kleinschreibung berücksichtigt. Dies entspricht dem Konvertieren der Zeichenfolge in Großbuchstaben unter Verwendung der invarianten Kultur und anschließend einen Ordinalvergleich ausführen, auf dem Ergebnis. Eine Liste der String Methoden, die zwei Zeichenfolgen mithilfe von ordinalen Sortierregeln Vergleichen finden Sie unter der Zeichenfolgenoperationen nach Kategorie Abschnitt.

Ein kulturabhängiger Vergleich ist ein Vergleich, der explizit oder implizit verwendet eine CultureInfo -Objekts, einschließlich der invarianten Kultur, die von angegeben wird die CultureInfo.InvariantCulture Eigenschaft. Die implizite Kultur ist die aktuelle Kultur, der durch angegeben ist die Thread.CurrentCulture und CultureInfo.CurrentCulture Eigenschaften. Es gibt erhebliche Variation in der Sortierreihenfolge der alphabetischen Zeichen (d. h. Zeichen, für die die Char.IsLetter -Eigenschaft gibt true) zwischen Kulturen. Sie können angeben, dass einen kulturabhängiger Vergleich, der die Konventionen einer bestimmten Kultur durch Angabe verwendet eine CultureInfo -Objekt an eine Methode zum Zeichenfolgenvergleich wie Compare(String, String, CultureInfo, CompareOptions). Sie können angeben, dass einen kulturabhängiger Vergleich, der durch Angabe der Konventionen der aktuellen Kultur verwendet StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase, oder ein Member des der CompareOptions Enumeration außer CompareOptions.Ordinal oder CompareOptions.OrdinalIgnoreCase an eine entsprechende Überladung der der Compare Methode. Ein kulturabhängiger Vergleich eignet sich in der Regel für die Sortierung hingegen ein ordinalen Vergleich nicht ist. Ein ordinalen Vergleich eignet sich im Allgemeinen zu bestimmen, ob zwei Zeichenfolgen gleich sind (d. h. für die Bestimmung der Identität) dagegen ein kulturabhängigen Vergleich nicht ist.

Das folgende Beispiel veranschaulicht den Unterschied zwischen ordinalen Vergleich kulturabhängig. Im Beispiel ergibt drei Zeichenfolgen, "Apple", "Æble" und "AEble" ordinalen Vergleich mit den Konventionen der Kulturen da-DK "und" En-US (von denen jede die Standardkultur ist, zum Zeitpunkt der Compare -Methode aufgerufen wird). Da die dänische Sprache das Zeichen "Æ" als ein einzelner Buchstabe wird und sortiert es im Alphabet nach "Z", ist die Zeichenfolge "Æble" größer als "Apple". "Æble" ist jedoch nicht äquivalent zu "AEble", interpretiert, damit "Æble" auch "AEble" größer ist. Der Kultur En-US interpretiert als äquivalent zu "AE", die erläutern, warum "Æble" kleiner als "Apple", aber "AEble" gleich ist jedoch nicht der Buchstabe "Æ" enthalten. Ordinalvergleich durch, hält andererseits, "Apple" niedriger sein als "Æble" und "Æble" größer als "AEble" sein.

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

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

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

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

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

Verwenden Sie die folgenden allgemeinen Richtlinien, um eine entsprechende Sortierung oder Zeichenfolge Vergleichsmethode auszuwählen:

  • Wenn Sie basierend auf der Kultur des Benutzers die Zeichenfolgen, die sortiert werden soll, sollten basierend auf den Konventionen der aktuellen Kultur sortiert werden. Wenn die Kultur des Benutzers geändert wird, wird die Reihenfolge der sortierten Zeichenfolgen auch entsprechend geändert. Eine Thesaurus-Anwendung sollte beispielsweise immer Wörter, die basierend auf der Kultur des Benutzers sortieren.

  • Gegebenenfalls die Zeichenfolgen, die sortiert werden basierend auf den Konventionen einer bestimmten Kultur bestellen Sie diese durch Angabe einer CultureInfo -Objekt, das die Kultur für eine Vergleichsmethode darstellt. Beispielsweise sollen in eine Anwendung, Studenten eine bestimmte Sprache zu unterrichten, Zeichenfolgen, um sortiert zu werden basierend auf den Konventionen einer Kulturen, die diese Sprache spricht.

  • Wenn Sie die Reihenfolge von Zeichenfolgen zwischen Kulturen unverändert bleiben soll, sollten Sie in beliebiger Reihenfolge basierend auf den Konventionen der invarianten Kultur oder verwenden einen Ordinalvergleich durch. Beispielsweise würde eine Ordinalsortierung verwenden, um die Namen der Dateien, Prozesse, Mutexe zu organisieren oder named Pipes.

  • Einen Vergleich, der eine sicherheitsentscheidung (z. B., ob ein Benutzernamen gültig ist) umfasst, sollten Sie immer einen Ordinalzahlen Test auf Gleichheit ausführen, durch Aufruf einer Überladung von der Equals Methode.

System_CAPS_noteHinweis

Der kulturabhängige Sortierung und Groß-/Kleinschreibung in Zeichenfolgenvergleich verwendete Regeln hängen von der Version von .NET Framework. In der .NET Framework 4.5 unter der Windows 8 Betriebssystem, Sortierung, Groß-/Kleinschreibung, Normalisierung und Unicode-Zeicheninformationen entspricht dem Standard Unicode 6.0. Auf anderen Betriebssystemen entspricht die Unicode 5.0-Standard es.

Weitere Informationen zum Word Zeichenfolge und Ordinalsortierung finden Sie unter der System.Globalization.CompareOptions Thema. Weitere Empfehlungen dazu, wann jeder Regel verwenden, finden Sie unter Empfohlene Vorgehensweisen für die Verwendung von Zeichenfolgen in .NET Framework.

Normalerweise rufen Sie nicht Zeichenfolge Vergleichsmethoden, z. B. Compare direkt auf die Sortierreihenfolge von Zeichenfolgen zu bestimmen. Stattdessen werden die Methoden zum Zeichenfolgenvergleich Methoden wie z. B. beim Sortieren aufgerufen Array.Sort oder List<T>.Sort. Im folgenden Beispiel wird vier verschiedene Sortieroperationen (Word-Sortierung verwenden, die aktuelle Kultur, Word-Sortierung mit der invarianten Kultur Ordinalsortierung und Zeichenfolge Sortieren mit der invarianten Kultur) ohne expliziten Aufruf einer Methode zum Zeichenfolgenvergleich, obwohl sie den Typ des Vergleichs mit angeben. Beachten Sie, dass jede Art von Sortierreihenfolge erzeugt eine eindeutige Sortierung von Zeichenfolgen im Array.

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
System_CAPS_tipTipp

.NET Framework verwendet intern Sortierschlüssel Culturallysensitive Zeichenfolgenvergleich zu unterstützen. Jedem Zeichen in einer Zeichenfolge sind mehrere Sortiergewichtungskategorien zugeordnet, darunter nach Skript, alphabetischer Folge, Groß-/Kleinschreibung und diakritischer Gewichtung. Ein Sortierschlüssel, dargestellt durch die SortKey Klasse, ein Repository mit diesen Gewichtungen für eine bestimmte Zeichenfolge enthält. Wenn eine große Anzahl von suchen oder Sortiervorgänge auf den gleichen Satz von Zeichenfolgen in Ihre app ausgeführt wird, können Sie die Leistung verbessern, indem generieren und zu speichern Sortierschlüssel für alle Zeichenfolgen, die verwendet werden. Wenn eine Sortierung oder ein Vergleich erforderlich ist, verwenden Sie den Sortierschlüssel anstelle von Zeichenfolgen. Weitere Informationen finden Sie in den Ausführungen zur SortKey-Klasse.

Wenn Sie eine Konvention, die Zeichenfolge Vergleich angeben, Sortieren Sie Methoden wie z. B. Array.Sort(Array) führen Sie eine Sortierung kulturabhängig, Groß-/Kleinschreibung für Zeichenfolgen. Im folgende Beispiel wird veranschaulicht, wie die Reihenfolge der sortierten Zeichenfolgen in einem Array ändern die aktuelle Kultur auf auswirkt. Erstellt ein Array von drei Zeichenfolgen. Zuerst wird die System.Threading.Thread.CurrentThread.CurrentCulture-Eigenschaft auf "en-US" festgelegt, und die Array.Sort(Array)-Methode wird aufgerufen. Die sich daraus ergebende Sortierreihenfolge basiert auf den Sortierkonventionen für die Kultur Englisch (USA). Als Nächstes wird die System.Threading.Thread.CurrentThread.CurrentCulture-Eigenschaft auf "da-DK" festgelegt und die Array.Sort-Methode erneut aufgerufen. Die sich daraus ergebende Sortierreihenfolge unterscheidet sich von den Ergebnissen für "en-US", da die Sortierkonventionen für "Dänisch (Dänemark)" verwendet werden.

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

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

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

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

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

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

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

Wenn der primäre Zweck in Vergleichen von Zeichenfolgen ist, um zu bestimmen, ob sie gleich sind, rufen Sie die String.Equals Methode. Sie sollten in der Regel verwenden Equals einen Ordinalvergleich ausführen. Die String.Compare -Methode dient in erster Linie zum Sortieren von Zeichenfolgen.

Zeichenfolgensuchmethoden, z. B. String.StartsWith und String.IndexOf, auch können kulturabhängig oder Ordnungszahl Zeichenfolgenvergleiche ausführen. Das folgende Beispiel veranschaulicht die Unterschiede zwischen der Ordinalzahl und kulturabhängige Vergleiche mit der IndexOf Methode. Eine kulturabhängige Suche, in der die aktuelle Kultur Englisch (Vereinigte Staaten) ist, betrachtet die Teilzeichenfolge "Oe" entsprechend der Ligatur "œ". Da Sie ein bedingten Bindestrich (U + 00AD) eine Breite von NULL-Zeichen ist, behandelt die Suche den bedingten Bindestrich als Entsprechung zu Empty und findet eine Übereinstimmung am Anfang der Zeichenfolge. Eine Ordinalsuche ist in beiden Fällen andererseits, keine Übereinstimmung gefunden.

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

Zeichenfolgensuchmethoden, z. B. String.StartsWith und String.IndexOf, auch ausführen, kulturabhängig oder Ordnungszahl Zeichenfolgenvergleiche zu bestimmen, ob ein Zeichen oder eine Teilzeichenfolge in einer angegebenen Zeichenfolge gefunden wird.

Die Suche Methoden in der String -Klasse, die für ein einzelnes Zeichen wie z. B. Suchen derIndexOf Methode oder zu einem Satz von Zeichen, wie z. B. die IndexOfAny -Methode, eine Ordinalsuche Portverweise. Um eine kulturabhängige Suche nach einem Zeichen auszuführen, rufen Sie eine CompareInfo Methode z. B. CompareInfo.IndexOf(String, Char) oder CompareInfo.LastIndexOf(String, Char). Beachten Sie, dass die Ergebnisse der Suche nach einem Zeichen mit einem ordinalen und kulturabhängige Vergleich sehr unterschiedlich sein können. Beispielsweise könnte eine Suche für ein zusammengesetztes Unicode-Zeichen, z. B. die Ligatur "Æ" (U + 00 C 6) entspricht jedem Vorkommen der Komponenten in der richtigen Reihenfolge, z. B. "AE" (U + 041U + 0045), abhängig von der Kultur. Das folgende Beispiel veranschaulicht den Unterschied zwischen der String.IndexOf(Char) und CompareInfo.IndexOf(String, Char) Methoden bei der Suche nach einem einzelnen Zeichen. Die Ligatur "Æ" (U + 00E6) wird in der Zeichenfolge "Luftbild" bei Verwendung der Konventionen der Kultur En-US, jedoch nicht, wenn die Konventionen der Kultur da-DK verwendet oder wenn Sie einen Ordinalvergleich ausführen gefunden.

using System;
using System.Globalization;

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

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

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

Andererseits, String -Klassenmethoden, die Suche nach einer Zeichenfolge statt eines Zeichens eine kulturabhängige Suche ausführen, wenn Suchoptionen durch einen Parameter vom Typ nicht explizit angegeben werden StringComparison. Die einzige Ausnahme ist Contains, die eine Ordinalsuche durchführt.

Verwenden der String.Compare Methode, um die Beziehung der beiden Zeichenfolgen in der Sortierreihenfolge festzulegen. Dies ist normalerweise eine kulturabhängige Operation. Im Gegensatz dazu rufen Sie die String.Equals Methode auf Gleichheit. Da der Test auf Gleichheit Benutzereingaben mit einigen bekannten Zeichenfolge, z. B. einen gültigen Benutzernamen, ein Kennwort oder einen Dateisystempfad, in der Regel verglichen wird er in der Regel eine Ordinalzahl Vorgang.

System_CAPS_warningWarnung

Es ist möglich, die Gleichheit zu prüfende durch Aufrufen der String.Compare -Methode und bestimmen, ob der Rückgabewert 0 (null) ist. Dieses Vorgehen wird jedoch nicht empfohlen. Um zu bestimmen, ob zwei Zeichenfolgen gleich sind, sollten Sie eine der Überladungen der Aufrufen der String.Equals Methode. Die bevorzugte Überladung aufrufen, ist entweder die Instanz Equals(String, StringComparison) -Methode oder die statische Equals(String, String, StringComparison) -Methode, da beide Methoden enthalten eine System.StringComparison Parameter, der den Typ des Vergleichs explizit angibt.

Das folgende Beispiel veranschaulicht die Gefahr der Ausführung eines kulturabhängigen Vergleichs, Gleichheit, wenn eine Ordinalzahl einer sollte stattdessen verwendet werden. In diesem Fall ist der Zweck des Codes zu Dateisystemzugriff von URLs zu verhindern, die mit "FILE://" oder "file://" beginnt, durch Ausführen des Anfangs einer URL mit der Zeichenfolge "FILE://" Groß-und Kleinschreibung unterschieden. Jedoch wenn ein kulturabhängiger Vergleich unter Verwendung der Kultur Türkisch (Türkei) in einer URL, die mit "file://" beginnt, ausgeführt wird, fehlschlägt, der Vergleich Gleichheit, weil der türkischen Sprache entsprechende Großbuchstabe den Kleinbuchstaben "i" "İ" anstelle von "I" ist. Daher wird Dateisystemzugriff versehentlich zulässig. Andererseits, ein ordinalen Vergleich durchgeführt wird, wird der Vergleich Gleichheit ist erfolgreich, und Dateisystemzugriff verweigert wird.

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.

Mehrere Darstellungen müssen einige Unicodezeichen. 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 erschweren suchen, sortieren, Abgleich und andere Zeichenfolgenoperationen.

Im Unicode-standard definiert eine sogenannte Normalisierung, die eine binäre Darstellung eines Unicode-Zeichens für jede der entsprechende binäre Darstellung zurückgibt. Normalisierung können mehrere Algorithmen, so genannte Normalisierung Formulare, die verschiedenen Regeln entsprechen. .NET Framework unterstützt Unicode-Normalisierung Forms C, D, KC und KD. Wenn Sie Zeichenfolgen in der gleichen Normalisierungsform normalisiert wurden, können sie mithilfe von ordinalen Vergleich verglichen werden.

Ein ordinalen Vergleich ist ein binärer Vergleich von der Unicode-Skalarwert des entsprechenden Char Objekte in jeder Zeichenfolge. DieString Klasse enthält eine Reihe von Methoden, die einen Ordinalvergleich durch, u. a. folgende ausführen können:

Sie können bestimmen, ob eine Zeichenfolge in der Normalisierungsform C, durch Aufrufen normalisiert wird der String.IsNormalized() -Methode, oder Sie rufen die String.IsNormalized(NormalizationForm) Methode, um zu bestimmen, ob eine Zeichenfolge in einer angegebenen Normalisierungsform normalisiert wird. Sie können auch aufrufen, die String.Normalize() Methode zum Konvertieren einer Zeichenfolge in der Normalisierungsform C, oder Sie können Aufrufen der String.Normalize(NormalizationForm) Methode zum Konvertieren einer Zeichenfolge in einer angegebenen Normalisierungsform. Ausführliche Informationen zu normalisieren, und Vergleichen von Zeichenfolgen finden Sie die Normalize() und Normalize(NormalizationForm) Methoden.

Das folgende einfache Beispiel veranschaulicht die Normalisierung von Zeichenfolgen. Er definiert den Buchstaben "ố" auf drei verschiedene Arten in drei verschiedenen Zeichenfolgen und einen ordinalen Vergleich Gleichheit verwendet, um zu bestimmen, dass jede Zeichenfolge von den anderen beiden Zeichenfolgen unterscheidet. Er jede Zeichenfolge wird dann an den Formularen unterstützten Normalisierung konvertiert, und führt erneut einen ordinalen Vergleich einer Zeichenfolge in einer angegebenen Normalisierungsform. In jedem Fall zeigt der zweite Test auf Gleichheit an, dass die Zeichenfolgen gleich sind.

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

public class Example
{
   private static StreamWriter sw;

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

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

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

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

      sw.Close();   
   }

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

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

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

Weitere Informationen zur Normalisierung und Normalisierung Forms finden Sie unter System.Text.NormalizationForm, als auch Unicode Standard Annex #15: Unicode Normalization Forms und Normalization FAQ unicode.org-Website.

Die String Klasse enthält Elemente für das Vergleichen von Zeichenfolgen, Testen von Zeichenfolgen auf Gleichheit, Suchen von Zeichen oder Teilzeichenfolgen in einer Zeichenfolge, die Änderung einer Zeichenfolge, die Teilzeichenfolgen in einer Zeichenfolge, die Kombination von Zeichenfolgen, Formatieren von Werten, Kopieren einer Zeichenfolge und Normalisieren einer Zeichenfolge zu extrahieren.

Sie können Zeichenfolgen vergleichen, um ihre relative Position in der Sortierreihenfolge bestimmen mithilfe der Folgendes StringMethoden:

  • CompareGibt eine ganze Zahl, die die Beziehung aus einer Zeichenfolge in eine zweite Zeichenfolge in der Sortierreihenfolge angibt.

  • CompareOrdinalGibt eine ganze Zahl, die die Beziehung von einer Zeichenfolge mit einer zweiten Zeichenfolge basierend auf einem Vergleich ihrer Codepunkte angibt.

  • CompareToGibt eine ganze Zahl, die die Beziehung von der aktuellen Zeichenfolgeninstanz in eine zweite Zeichenfolge in der Sortierreihenfolge angibt. Die CompareTo(String) Methode stellt der IComparable und IComparable<T> Implementierungen für die String Klasse.

Rufen Sie die Equals Methode, um zu bestimmen, ob zwei Zeichenfolgen gleich sind. Die Instanz Equals(String, String, StringComparison) und der statischen Equals(String, StringComparison) Überladungen können Sie angeben, ob der Vergleich kulturabhängig oder Ordinalzahl ist, und gibt an, ob Fall berücksichtigt oder ignoriert wird. Die meisten Tests Gleichheit Ordinalvergleiche darstellen, und Vergleiche auf Gleichheit, die bestimmen, den Zugriff auf eine Systemressource (z. B. ein Dateisystemobjekt) sollten immer ordinal sein.

Die String Klasse enthält zwei Arten von Suchmethoden:

System_CAPS_warningWarnung

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

Die String Klasse enthält die folgenden Methoden, die zum Ändern des Werts einer Zeichenfolge angezeigt werden:

  • InsertFügt eine Zeichenfolge in der aktuellen String Instanz.

  • PadLeftFügt eine oder mehrere Vorkommen eines angegebenen Zeichens am Anfang einer Zeichenfolge ein.

  • PadRightFügt eine oder mehrere Vorkommen eines angegebenen Zeichens am Anfang einer Zeichenfolge ein.

  • RemoveLöscht eine Teilzeichenfolge aus dem aktuellen String Instanz.

  • Replaceersetzt eine Teilzeichenfolge durch eine andere Teilzeichenfolge in der aktuellen String Instanz.

  • ToLowerund ToLowerInvariant konvertiert alle Zeichen in einer Zeichenfolge in Kleinbuchstaben.

  • ToUpperund ToUpperInvariant konvertiert alle Zeichen in einer Zeichenfolge in Großbuchstaben konvertiert wurden.

  • TrimEntfernt alle Vorkommen von einem Zeichen am Anfang und Ende einer Zeichenfolge.

  • TrimEndEntfernt alle Vorkommen eines Zeichens vom Ende einer Zeichenfolge.

  • TrimStartEntfernt alle Vorkommen eines Zeichens vom Anfang einer Zeichenfolge.

System_CAPS_importantWichtig

Alle Zeichenfolgenmethoden Änderung eine neue zurückgeben String Objekt. Ändern sie nicht den Wert der aktuellen Instanz.

Die String.Split Methode trennt eine einzelne Zeichenfolge in mehrere Zeichenfolgen zu trennen. Überladungen der Methode ermöglichen Ihnen die Angabe mehrerer Trennzeichen, um die maximale Anzahl von Teilzeichenfolgen zu bestimmen, von dem die Methode extrahiert, und um zu bestimmen, ob leere Zeichenfolgen (die auftreten, wenn es sich bei Trennzeichen nebeneinander angeordnet sind) für die zurückgegebenen Zeichenfolgen enthalten sind.

Die folgenden String Methoden für das Verketten von Zeichenfolgen verwendet werden können:

  • Concatwerden ein oder mehrere Teilzeichenfolgen in einer einzelnen Zeichenfolge kombiniert.

  • Joinverkettet eine oder mehrere Teilzeichenfolgen in ein einzelnes Element und fügt ein Trennzeichen zwischen den Teilzeichenfolgen.

Die String.Format Methode verwendet die Funktion für kombinierte Formatierung, um einen oder mehrere Platzhalter in einer Zeichenfolge durch die Zeichenfolgendarstellung für einige Objekte oder Werte zu ersetzen. Die Format Methode wird häufig verwendet, um die folgenden Aktionen ausführen:

  • So betten Sie die Darstellung eines numerischen Werts in einer Zeichenfolge ein.

  • Die Zeichenfolgendarstellung eines Werts für Datum und Uhrzeit in eine Zeichenfolge eingebettet werden sollen.

  • Die angegebene Zeichenfolgendarstellung eines Enumerationswerts in eine Zeichenfolge eingebettet werden sollen.

  • So betten Sie die Zeichenfolgendarstellung eines Objekts ein, die unterstützt die IFormattable Schnittstelle in einer Zeichenfolge.

  • Rechtsbündig oder eine Teilzeichenfolge in einem Feld innerhalb einer größeren Zeichenfolge linksbündig.

Ausführliche Informationen zum Formatieren von Operationen und Beispiele finden Sie unter der Format Zusammenfassung überladen.

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

  • CloneGibt einen Verweis auf ein vorhandenes String Objekt.

  • Copyerstellt eine Kopie einer vorhandenen Zeichenfolge an.

  • CopyToKopiert einen Teil einer Zeichenfolge in ein Zeichenarray.

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

Weitere Informationen und ein Beispiel finden Sie unter der Normalisierung weiter oben in diesem Thema.

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

Dieser Typ ist threadsicher.

Zurück zum Anfang
Anzeigen:
© 2017 Microsoft