String Klasse
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Stellt Text als Sequenz von UTF-16-Codeeinheiten dar.
public ref class System::String sealed : IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>public ref class System::String sealed : ICloneable, IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>public ref class System::String sealed : ICloneable, IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, IParsable<System::String ^>, ISpanParsable<System::String ^>, System::Collections::Generic::IEnumerable<char>public ref class System::String sealed : ICloneable, IComparable, IConvertible, System::Collections::IEnumerablepublic ref class System::String sealed : IComparable, IComparable<System::String ^>, IEquatable<System::String ^>, System::Collections::IEnumerablepublic ref class System::String sealed : IComparable, IComparable<System::String ^>, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>public sealed class String : IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, IParsable<string>, ISpanParsable<string>, System.Collections.Generic.IEnumerable<char>[System.Serializable]
public sealed class String : ICloneable, IComparable, IConvertible, System.Collections.IEnumerable[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>public sealed class String : IComparable, IComparable<string>, IEquatable<string>, System.Collections.IEnumerablepublic sealed class String : IComparable, IComparable<string>, IEquatable<string>, System.Collections.Generic.IEnumerable<char>type string = class
interface seq<char>
interface IEnumerable
interface IComparable
interface IComparable<string>
interface IConvertible
interface IEquatable<string>type string = class
interface seq<char>
interface IEnumerable
interface ICloneable
interface IComparable
interface IComparable<string>
interface IConvertible
interface IEquatable<string>type string = class
interface seq<char>
interface IEnumerable
interface ICloneable
interface IComparable
interface IComparable<string>
interface IConvertible
interface IEquatable<string>
interface IParsable<string>
interface ISpanParsable<string>type string = class
interface seq<char>
interface IEnumerable
interface IComparable
interface IComparable<string>
interface IConvertible
interface IEquatable<string>
interface ICloneable[<System.Serializable>]
type string = class
interface IComparable
interface ICloneable
interface IConvertible
interface IEnumerable[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type string = class
interface IComparable
interface ICloneable
interface IConvertible
interface IComparable<string>
interface seq<char>
interface IEnumerable
interface IEquatable<string>[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type string = class
interface IComparable
interface ICloneable
interface IConvertible
interface IEnumerable
interface IComparable<string>
interface seq<char>
interface IEquatable<string>type string = class
interface IEnumerable
interface IComparable
interface IComparable<string>
interface IEquatable<string>type string = class
interface IComparable
interface IComparable<string>
interface IEquatable<string>
interface seq<char>
interface IEnumerablePublic NotInheritable Class String
Implements IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String)Public NotInheritable Class String
Implements ICloneable, IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String)Public NotInheritable Class String
Implements ICloneable, IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String), IParsable(Of String), ISpanParsable(Of String)Public NotInheritable Class String
Implements ICloneable, IComparable, IConvertible, IEnumerablePublic NotInheritable Class String
Implements IComparable, IComparable(Of String), IEnumerable, IEquatable(Of String)Public NotInheritable Class String
Implements IComparable, IComparable(Of String), IEnumerable(Of Char), IEquatable(Of String)- Vererbung
-
String
- Attribute
- Implementiert
Hinweise
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 Objekten, die eine Zeichenfolge darstellen. Ein System.Char -Objekt entspricht einer UTF-16-Codeeinheit. Der Wert des String -Objekts ist der Inhalt der sequenziellen Auflistung von System.Char Objekten, und dieser Wert ist unveränderlich (d. a. er ist schreibgeschützt). Weitere Informationen zur Unveränderlichkeit von Zeichenfolgen finden Sie im Abschnitt Unveränderlichkeit und stringBuilder-Klasse . Die maximale Größe eines String Objekts im Arbeitsspeicher beträgt 2 GB oder etwa 1 Milliarde Zeichen.
Weitere Informationen zu Unicode, UTF-16, Codeeinheiten, Codepunkten und den Char Typen und Rune finden Sie unter Einführung in die Zeichencodierung in .NET.
In diesem Abschnitt
Instanziieren eines String-Objekts
Char-Objekte und Unicode-Zeichen
Zeichenfolgen und der Unicode-Standard
Zeichenfolgen und eingebettete NULL-Zeichen
Zeichenfolgen und Indizes
NULL-Zeichenfolgen und leere Zeichenfolgen
Unveränderlichkeit und die StringBuilder-Klasse
Ordinal- und kulturabhängige Vorgänge
Normalisierung
Zeichenfolgenvorgänge nach Kategorie
Instanziieren eines String-Objekts
Sie können ein String -Objekt auf folgende Weise instanziieren:
Durch Zuweisen eines Zeichenfolgenliterals zu einer String Variablen. Dies ist die am häufigsten verwendete Methode zum Erstellen einer Zeichenfolge. Im folgenden Beispiel wird die Zuweisung verwendet, um mehrere Zeichenfolgen zu erstellen. Beachten Sie, dass in C# und F#, da der umgekehrte Schrägstrich (\) ein Escapezeichen ist, literale umgekehrte Schrägstriche in einer Zeichenfolge mit Escapezeichen versehen werden müssen, oder die gesamte Zeichenfolge muss @in Anführungszeichen gesetzt werden.
using namespace System; void main() { String^ string1 = "This is a string created by assignment."; Console::WriteLine(string1); String^ string2a = "The path is C:\\PublicDocuments\\Report1.doc"; Console::WriteLine(string2a); } // The example displays the following output: // This is a string created by assignment. // The path is C:\PublicDocuments\Report1.docstring 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.doclet string1 = "This is a string created by assignment." printfn "%s" string1 let string2a = "The path is C:\\PublicDocuments\\Report1.doc" printfn "%s" string2a let string2b = @"The path is C:\PublicDocuments\Report1.doc" printfn "%s" 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.docDim string1 As String = "This is a string created by assignment." Console.WriteLine(string1) Dim string2 As String = "The path is C:\PublicDocuments\Report1.doc" Console.WriteLine(string2) ' The example displays the following output: ' This is a string created by assignment. ' The path is C:\PublicDocuments\Report1.docDurch Aufrufen eines String Klassenkonstruktors. Im folgenden Beispiel werden Zeichenfolgen instanziiert, indem mehrere Klassenkonstruktoren aufgerufen werden. Beachten Sie, dass einige der Konstruktoren Zeiger auf Zeichenarrays oder signierte Bytearrays als Parameter enthalten. Visual Basic unterstützt keine Aufrufe dieser Konstruktoren. Ausführliche Informationen zu String Konstruktoren finden Sie in der String Konstruktorzusammenfassung.
using namespace System; void main() { wchar_t chars[5] = L"word"; char bytes[6] = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 }; // Create a string from a character array. String^ string1 = gcnew String(chars); Console::WriteLine(string1); // Create a string that consists of a character repeated 20 times. String^ string2 = gcnew String('c', 20); Console::WriteLine(string2); String^ stringFromBytes = nullptr; String^ stringFromChars = nullptr; char * pbytes = &bytes[0]; // Create a string from a pointer to a signed byte array. stringFromBytes = gcnew String(pbytes); wchar_t* pchars = &chars[0]; // Create a string from a pointer to a character array. stringFromChars = gcnew String(pchars); Console::WriteLine(stringFromBytes); Console::WriteLine(stringFromChars); Console::ReadLine(); } // The example displays the following output: // word // cccccccccccccccccccc // ABCDE // wordchar[] 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 // wordlet chars = [| 'w'; 'o'; 'r'; 'd' |] let bytes = [| 0x41y; 0x42y; 0x43y; 0x44y; 0x45y; 0x00y |] // Create a string from a character array. let string1 = String chars printfn "%s" string1 // Create a string that consists of a character repeated 20 times. let string2 = String('c', 20) printfn "%s" string2 let stringFromBytes = // Create a string from a pointer to a signed byte array. use pbytes = fixed bytes String pbytes let stringFromChars = // Create a string from a pointer to a character array. use pchars = fixed chars String pchars printfn $"{stringFromBytes}" printfn $"{stringFromChars}" // The example displays the following output: // word // cccccccccccccccccccc // ABCDE // wordDim chars() As Char = { "w"c, "o"c, "r"c, "d"c } ' Create a string from a character array. Dim string1 As New String(chars) Console.WriteLine(string1) ' Create a string that consists of a character repeated 20 times. Dim string2 As New String("c"c, 20) Console.WriteLine(string2) ' The example displays the following output: ' word ' ccccccccccccccccccccMithilfe des Zeichenfolgenverkettungsoperators (+ in C# und F# und & oder + in Visual Basic) können Sie eine einzelne Zeichenfolge aus einer beliebigen Kombination von String Instanzen und Zeichenfolgenliteralen erstellen. Im folgenden Beispiel wird die Verwendung des Zeichenfolgenverkettungsoperators veranschaulicht.
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.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.let string1 = "Today is " + DateTime.Now.ToString("D") + "." printfn $"{string1}" let string2 = "This is one sentence. " + "This is a second. " let string2 = string2 + "This is a third sentence." printfn $"{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.Dim string1 As String = "Today is " + Date.Now.ToString("D") + "." Console.WriteLine(string1) Dim string2 As String = "This is one sentence. " + "This is a second. " string2 += "This is a third sentence." Console.WriteLine(string2) ' The example displays output like the following: ' Today is Tuesday, July 06, 2011. ' This is one sentence. This is a second. This is a third sentence.Durch Abrufen einer Eigenschaft oder Aufrufen einer Methode, die eine Zeichenfolge zurückgibt. Im folgenden Beispiel werden die Methoden der String -Klasse verwendet, um eine Teilzeichenfolge 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);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: sentencelet sentence = "This sentence has five words." // Extract the second word. let startPosition = sentence.IndexOf " " + 1 let word2 = sentence.Substring(startPosition, sentence.IndexOf(" ", startPosition) - startPosition) printfn $"Second word: {word2}" // The example displays the following output: // Second word: sentenceDim sentence As String = "This sentence has five words." ' Extract the second word. Dim startPosition As Integer = sentence.IndexOf(" ") + 1 Dim word2 As String = sentence.Substring(startPosition, sentence.IndexOf(" ", startPosition) - startPosition) Console.WriteLine("Second word: " + word2) ' The example displays the following output: ' Second word: sentenceDurch Aufrufen einer Formatierungsmethode, um einen Wert oder ein Objekt in seine Zeichenfolgendarstellung zu konvertieren. Im folgenden Beispiel wird die zusammengesetzte Formatierungsfunktion verwendet, um die Zeichenfolgendarstellung von zwei Objekten in eine Zeichenfolge einzubetten.
DateTime^ dateAndTime = gcnew 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.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.let dateAndTime = DateTime(2011, 7, 6, 7, 32, 0) let temperature = 68.3 String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.", dateAndTime, temperature) |> printfn "%s" // The example displays the following output: // At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.Dim dateAndTime As DateTime = #07/06/2011 7:32:00AM# Dim temperature As Double = 68.3 Dim result As String = 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.
Char-Objekte und Unicode-Zeichen
Jedes Zeichen in einer Zeichenfolge wird durch einen unicode-skalaren Wert definiert, der auch als Unicode-Codepunkt oder als Ordnungswert (numerischer Wert) des Unicode-Zeichens bezeichnet wird. Jeder Codepunkt wird mithilfe der UTF-16-Codierung codiert, und der numerische Wert jedes Elements der Codierung wird durch ein Char -Objekt dargestellt.
Hinweis
Beachten Sie, dass es möglich ist, ein Objekt zu erstellenString, das keine wohlgeformte Unicode-Zeichenfolge ist, da ein String instance aus einer sequenziellen Auflistung von UTF-16-Codeeinheiten besteht. Beispielsweise ist es möglich, eine Zeichenfolge mit einem niedrigen Ersatz ohne ein entsprechendes hohes Ersatzzeichen zu erstellen. Obwohl einige Methoden, z. B. die Methoden zum Codieren und Decodieren von Objekten im System.Text Namespace, Überprüfungen durchführen, um sicherzustellen, dass Zeichenfolgen wohlgeformt sind, String stellen Klassenmember nicht sicher, dass eine Zeichenfolge wohlgeformt ist.
Ein einzelnes Char Objekt stellt in der Regel einen einzelnen Codepunkt dar. Das heißt, der numerische Wert des Char entspricht dem Codepunkt. Beispielsweise ist der Codepunkt für das Zeichen "a" U+0061. Ein Codepunkt erfordert jedoch möglicherweise mehr als ein codiertes Element (mehr als ein Char Objekt). Der Unicode-Standard definiert zwei Typen von Zeichen, die mehreren Char Objekten entsprechen: Grapheme und zusätzliche Unicode-Codepunkte, die Zeichen in den zusätzlichen Unicode-Ebenen entsprechen.
Ein Graphem wird durch ein Basiszeichen gefolgt von einem oder mehreren kombinierenden Zeichen dargestellt. Das Zeichen ä wird beispielsweise durch ein Char Objekt dargestellt, dessen Codepunkt U+0061 ist, gefolgt von einem Char Objekt, dessen Codepunkt U+0308 ist. Dieses Zeichen kann auch durch ein einzelnes Char Objekt definiert werden, das über einen Codepunkt von U+00E4 verfügt. Wie das folgende Beispiel zeigt, zeigt ein kultursensibler Vergleich für Gleichheit, dass diese beiden Darstellungen gleich sind, obwohl ein gewöhnlicher Ordnungsvergleich dies nicht tut. Wenn die beiden Zeichenfolgen jedoch normalisiert sind, gibt ein Ordnungsvergleich auch an, dass sie gleich sind. (Weitere Informationen zum Normalisieren von Zeichenfolgen finden Sie im Abschnitt Normalisierung .)
using namespace System; using namespace System::Globalization; using namespace System::IO; void main() { StreamWriter^ sw = gcnew StreamWriter(".\\graphemes.txt"); String^ grapheme = L"a" + L"\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): Trueusing 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): Trueopen System open System.IO do use sw = new StreamWriter(@".\graphemes.txt") let grapheme = "\u0061\u0308" sw.WriteLine grapheme let 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)) // The example produces the following output: // ä // ä // ä = ä (Culture-sensitive): True // ä = ä (Ordinal): False // ä = ä (Normalized Ordinal): TrueImports System.Globalization Imports System.IO Module Example Public Sub Main() Dim sw As New StreamWriter(".\graphemes.txt") Dim grapheme As String = ChrW(&H0061) + ChrW(&h0308) sw.WriteLine(grapheme) Dim singleChar As String = ChrW(&h00e4) 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() End Sub End Module ' The example produces the following output: ' ä ' ä ' ä = ä (Culture-sensitive): True ' ä = ä (Ordinal): False ' ä = ä (Normalized Ordinal): TrueEin zusätzlicher Unicode-Codepunkt (ein Ersatzpaar) wird durch ein Char Objekt dargestellt, dessen Codepunkt ein hohes Ersatzobjekt ist, gefolgt von einem Char Objekt, dessen Codepunkt eine niedrige Ersatzinstanz ist. Die Codeeinheiten von hohen Ersatzangeboten reichen von U+D800 bis U+DBFF. Die Codeeinheiten niedriger Ersatzgeräte reichen von U+DC00 bis U+DFFF. Ersatzpaare werden verwendet, um Zeichen in den 16 zusätzlichen Unicode-Ebenen darzustellen. Im folgenden Beispiel wird ein Ersatzzeichen erstellt und an die Char.IsSurrogatePair(Char, Char) -Methode übergeben, um zu bestimmen, ob es sich um ein Ersatzpaar handelt.
using namespace System; void main() { String^ surrogate = L"\xD800\xDC03" ; for (int ctr = 0; ctr < surrogate->Length; ctr++) Console::Write("U+{0:X4} ", Convert::ToUInt16(surrogate[ctr])); Console::WriteLine(); Console::WriteLine(" Is Surrogate Pair: {0}", Char::IsSurrogatePair(surrogate[0], surrogate[1])); Console::ReadLine(); } // The example displays the following output: // U+D800 U+DC03 // Is Surrogate Pair: Truestring surrogate = "\uD800\uDC03"; for (int ctr = 0; ctr < surrogate.Length; ctr++) Console.Write($"U+{(ushort)surrogate[ctr]:X2} "); 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: Trueopen System let surrogate = "\uD800\uDC03" for i = 0 to surrogate.Length - 1 do printf $"U+{uint16 surrogate[i]:X2} " printfn $"\n Is Surrogate Pair: {Char.IsSurrogatePair(surrogate[0], surrogate[1])}" // The example displays the following output: // U+D800 U+DC03 // Is Surrogate Pair: TrueModule Example Public Sub Main() Dim surrogate As String = ChrW(&hD800) + ChrW(&hDC03) For ctr As Integer = 0 To surrogate.Length - 1 Console.Write("U+{0:X2} ", Convert.ToUInt16(surrogate(ctr))) Next Console.WriteLine() Console.WriteLine(" Is Surrogate Pair: {0}", Char.IsSurrogatePair(surrogate(0), surrogate(1))) End Sub End Module ' The example displays the following output: ' U+D800 U+DC03 ' Is Surrogate Pair: True
Zeichenfolgen und der Unicode-Standard
Zeichen in einer Zeichenfolge werden durch UTF-16-codierte Codeeinheiten dargestellt, die Werten entsprechen Char .
Jedes Zeichen in einer Zeichenfolge verfügt über eine zugeordnete Unicode-Zeichenkategorie, die in .NET durch die UnicodeCategory Enumeration dargestellt wird. Die Kategorie eines Zeichens oder eines Ersatzpaars kann durch Aufrufen der CharUnicodeInfo.GetUnicodeCategory -Methode bestimmt werden.
.NET verwaltet eine eigene Tabelle von Zeichen und entsprechenden Kategorien. Dadurch wird sichergestellt, dass eine bestimmte Version einer .NET-Implementierung, die auf unterschiedlichen Plattformen ausgeführt wird, identische Informationen zu Zeichenkategorien zurückgibt. In allen .NET-Versionen und auf allen Betriebssystemplattformen werden Zeichenkategorieninformationen von der Unicode-Zeichendatenbank bereitgestellt.
Die folgende Tabelle enthält die .NET-Versionen und die Versionen des Unicode-Standards, auf dem ihre Zeichenkategorien basieren.
Darüber hinaus unterstützt .NET den Vergleich und die Sortierung von Zeichenfolgen basierend auf dem Unicode-Standard. .NET Framework 4 und früheren Versionen verwalten eine eigene Tabelle mit Zeichenfolgendaten. Dies gilt auch für Versionen von .NET Framework ab .NET Framework 4.5, die unter Windows 7 ausgeführt werden. Ab .NET Framework 4.5 unter Windows 8 und höheren Versionen des Windows-Betriebssystems delegiert die Laufzeit Zeichenfolgenvergleichs- und Sortiervorgänge an das Betriebssystem. Unter .NET Core und .NET 5+ werden Zeichenfolgenvergleichs- und Sortierinformationen von Internationalen Komponenten für Unicode-Bibliotheken bereitgestellt (mit Ausnahme von Windows-Versionen vor Windows 10 Mai 2019 Update). In der folgenden Tabelle sind die Versionen von .NET und die Versionen des Unicode-Standards aufgeführt, auf denen der Zeichenvergleich und die Sortierung basieren.
| .NET-Version | Version des Unicode-Standards |
|---|---|
| .NET Framework 1.1 | The Unicode Standard, Version 4.0.0 (Der Unicode-Standard, Version 4.0.0) |
| .NET Framework 2.0 | The Unicode Standard, Version 5.0.0 (Der Unicode-Standard, Version 5.0.0) |
| .NET Framework 3.5 | The Unicode Standard, Version 5.0.0 (Der Unicode-Standard, Version 5.0.0) |
| .NET Framework 4 | The Unicode Standard, Version 5.0.0 (Der Unicode-Standard, Version 5.0.0) |
| .NET Framework 4.5 und höher unter Windows 7 | The Unicode Standard, Version 5.0.0 (Der Unicode-Standard, Version 5.0.0) |
| .NET Framework Version 4.5 und höher unter Windows 8 und höher unter Windows-Betriebssystemen | The Unicode Standard, Version 6.3.0 (Der Unicode-Standard, Version 6.3.0) |
| .NET Core und .NET 5 und höher | Hängt von der Version des Unicode-Standards ab, die vom zugrunde liegenden Betriebssystem unterstützt wird. |
Zeichenfolgen und eingebettete NULL-Zeichen
In .NET kann ein String Objekt eingebettete NULL-Zeichen enthalten, die als Teil der Länge der Zeichenfolge zählen. In einigen Sprachen wie C und C++ gibt ein NULL-Zeichen jedoch das Ende einer Zeichenfolge an. es wird nicht als Teil der Zeichenfolge betrachtet und nicht als Teil der Länge der Zeichenfolge gezählt. Dies bedeutet, dass die folgenden allgemeinen Annahmen, die C- und C++-Programmierer oder Bibliotheken, die in C oder C++ geschrieben sind, über Zeichenfolgen treffen können, nicht notwendigerweise gültig sind, wenn sie auf String Objekte angewendet werden:
Der von den
strlenFunktionen oderwcslenzurückgegebene Wert entspricht String.Lengthnicht unbedingt .Die von den
strcpy_sFunktionen oderwcscpy_serstellte Zeichenfolge ist nicht notwendigerweise mit der Zeichenfolge identisch, die von der String.Copy -Methode erstellt wurde.
Sie sollten sicherstellen, dass systemeigener C- und C++-Code, der Objekte instanziiert StringString , und Code, der objekte über den Plattformaufruf übergeben wird, nicht davon ausgehen, dass ein eingebettetes NULL-Zeichen das Ende der Zeichenfolge markiert.
Eingebettete NULL-Zeichen in einer Zeichenfolge werden auch unterschiedlich behandelt, wenn eine Zeichenfolge sortiert (oder verglichen wird) und wenn eine Zeichenfolge durchsucht wird. NULL-Zeichen werden ignoriert, wenn kultursensitive Vergleiche zwischen zwei Zeichenfolgen durchgeführt werden, einschließlich Vergleiche mit der invarianten Kultur. Sie werden nur für Ordnungs- oder Ordnungsvergleiche berücksichtigt, bei denen die Groß-/Kleinschreibung nicht beachtet wird. Andererseits werden eingebettete NULL-Zeichen immer berücksichtigt, wenn eine Zeichenfolge mit Methoden wie Contains, StartsWithund IndexOfgesucht wird.
Zeichenfolgen und Indizes
Ein Index ist die Position eines Char -Objekts (kein Unicode-Zeichen) in einem String. Ein Index ist eine nullbasierte, nichtegative Zahl, die von der ersten Position in der Zeichenfolge beginnt, die indexposition null ist. Eine Reihe von Suchmethoden, zIndexOf. B. und LastIndexOf, geben den Index eines Zeichens oder einer Teilzeichenfolge in der Zeichenfolge instance zurück.
Mit Chars[] der -Eigenschaft können Sie anhand ihrer Indexposition in der Zeichenfolge auf einzelne Char Objekte zugreifen. Da die Chars[] Eigenschaft die Standardeigenschaft (in Visual Basic) oder der Indexer (in C# und F#) ist, können Sie mithilfe von Code wie folgendem auf die einzelnen Char Objekte in einer Zeichenfolge zugreifen. Dieser Code sucht nach Leerzeichen oder Satzzeichen in einer Zeichenfolge, um zu bestimmen, wie viele Wörter die Zeichenfolge enthält.
using namespace System;
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.
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.
let s1 = "This string consists of a single short sentence."
let mutable nWords = 0
for i = 0 to s1.Length - 1 do
if Char.IsPunctuation s1[i] || Char.IsWhiteSpace s1[i] then
nWords <- nWords + 1
printfn $"The sentence\n {s1}\nhas {nWords} words."
// The example displays the following output:
// The sentence
// This string consists of a single short sentence.
// has 8 words.
Module Example
Public Sub Main()
Dim s1 As String = "This string consists of a single short sentence."
Dim nWords As Integer = 0
s1 = s1.Trim()
For ctr As Integer = 0 To s1.Length - 1
If Char.IsPunctuation(s1(ctr)) Or Char.IsWhiteSpace(s1(ctr))
nWords += 1
End If
Next
Console.WriteLine("The sentence{2} {0}{2}has {1} words.",
s1, nWords, vbCrLf)
End Sub
End Module
' The example displays the following output:
' The sentence
' This string consists of a single short sentence.
' has 8 words.
Da die String -Klasse die IEnumerable Schnittstelle implementiert, können Sie die Char Objekte in einer Zeichenfolge auch mithilfe eines foreach Konstrukts durchlaufen, wie das folgende Beispiel zeigt.
using namespace System;
void main()
{
String^ s1 = "This string consists of a single short sentence.";
int nWords = 0;
s1 = s1->Trim();
for each (Char ch in s1)
{
if (Char::IsPunctuation(ch) | Char::IsWhiteSpace(ch))
nWords++;
}
Console::WriteLine("The sentence\n {0}\nhas {1} words.",
s1, nWords);
Console::ReadLine();
}
// The example displays the following output:
// The sentence
// This string consists of a single short sentence.
// has 8 words.
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.
let s1 = "This string consists of a single short sentence."
let mutable nWords = 0
for ch in s1 do
if Char.IsPunctuation ch || Char.IsWhiteSpace ch then
nWords <- nWords + 1
printfn $"The sentence\n {s1}\nhas {nWords} words."
// The example displays the following output:
// The sentence
// This string consists of a single short sentence.
// has 8 words.
Module Example
Public Sub Main()
Dim s1 As String = "This string consists of a single short sentence."
Dim nWords As Integer = 0
s1 = s1.Trim()
For Each ch In s1
If Char.IsPunctuation(ch) Or Char.IsWhiteSpace(ch) Then
nWords += 1
End If
Next
Console.WriteLine("The sentence{2} {0}{2}has {1} words.",
s1, nWords, vbCrLf)
End Sub
End Module
' The example displays the following output:
' The sentence
' This string consists of a single short sentence.
' has 8 words.
Aufeinanderfolgende Indexwerte entsprechen möglicherweise nicht aufeinanderfolgenden Unicode-Zeichen, da ein Unicode-Zeichen möglicherweise als mehrere Char Objekte codiert ist. Insbesondere kann eine Zeichenfolge mehrstellige Texteinheiten enthalten, die von einem Basiszeichen gefolgt von einem oder mehreren kombinationsfähigen Zeichen oder von Ersatzpaaren gebildet werden. Um mit Unicode-Zeichen anstelle von Char -Objekten zu arbeiten, verwenden Sie die System.Globalization.StringInfo -Klasse und TextElementEnumerator oder die String.EnumerateRunes -Methode und die Rune -Struktur. Das folgende Beispiel veranschaulicht den Unterschied zwischen Code, der mit Char Objekten funktioniert, und Code, der mit Unicode-Zeichen arbeitet. Es vergleicht die Anzahl von Zeichen oder Textelementen in jedem Wort eines Satzes. Die Zeichenfolge enthält zwei Sequenzen eines Basiszeichens gefolgt von einem kombinierenden Zeichen.
using namespace System;
using namespace System::Collections::Generic;
using namespace System::Globalization;
void main()
{
// First sentence of The Mystery of the Yellow Room, by Leroux.
String^ opening = L"Ce n'est pas sans une certaine émotion que "+
L"je commence à raconter ici les aventures " +
L"extraordinaires de Joseph Rouletabille.";
// Character counters.
int nChars = 0;
// Objects to store word count.
List<int>^ chars = gcnew List<int>();
List<int>^ elements = gcnew List<int>();
for each (Char ch in opening) {
// Skip the ' character.
if (ch == '\x0027') 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 == "\x0027") 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]);
Console::ReadLine();
}
// 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
// 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++;
}
}
System.Globalization.TextElementEnumerator te =
System.Globalization.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
open System
open System.Globalization
// First sentence of The Mystery of the Yellow Room, by Leroux.
let opening = "Ce n'est pas sans une certaine émotion que je commence à raconter ici les aventures extraordinaires de Joseph Rouletabille."
// Character counters.
let mutable nChars = 0
// Objects to store word count.
let chars = ResizeArray<int>()
let elements = ResizeArray<int>()
for ch in opening do
// Skip the ' character.
if ch <> '\u0027' then
if Char.IsWhiteSpace ch || Char.IsPunctuation ch then
chars.Add nChars
nChars <- 0
else
nChars <- nChars + 1
let te = StringInfo.GetTextElementEnumerator opening
while te.MoveNext() do
let s = te.GetTextElement()
// Skip the ' character.
if s <> "\u0027" then
if String.IsNullOrEmpty(s.Trim()) || (s.Length = 1 && Char.IsPunctuation(Convert.ToChar s)) then
elements.Add nChars
nChars <- 0
else
nChars <- nChars + 1
// Display character counts.
printfn "%6s %20s %20s" "Word #" "Char Objects " "Characters"
for i = 0 to chars.Count - 1 do
printfn "%6d %20d %20d" i chars[i] elements[i]
// 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
Imports System.Collections.Generic
Imports System.Globalization
Module Example
Public Sub Main()
' First sentence of The Mystery of the Yellow Room, by Leroux.
Dim opening As String = "Ce n'est pas sans une certaine émotion que "+
"je commence à raconter ici les aventures " +
"extraordinaires de Joseph Rouletabille."
' Character counters.
Dim nChars As Integer = 0
' Objects to store word count.
Dim chars As New List(Of Integer)()
Dim elements As New List(Of Integer)()
For Each ch In opening
' Skip the ' character.
If ch = ChrW(&h0027) Then Continue For
If Char.IsWhiteSpace(ch) Or Char.IsPunctuation(ch) Then
chars.Add(nChars)
nChars = 0
Else
nChars += 1
End If
Next
Dim te As TextElementEnumerator = StringInfo.GetTextElementEnumerator(opening)
Do While te.MoveNext()
Dim s As String = te.GetTextElement()
' Skip the ' character.
If s = ChrW(&h0027) Then Continue Do
If String.IsNullOrEmpty(s.Trim()) Or (s.Length = 1 AndAlso Char.IsPunctuation(Convert.ToChar(s)))
elements.Add(nChars)
nChars = 0
Else
nChars += 1
End If
Loop
' Display character counts.
Console.WriteLine("{0,6} {1,20} {2,20}",
"Word #", "Char Objects", "Characters")
For ctr As Integer = 0 To chars.Count - 1
Console.WriteLine("{0,6} {1,20} {2,20}",
ctr, chars(ctr), elements(ctr))
Next
End Sub
End Module
' 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
In diesem Beispiel werden Textelemente mithilfe der StringInfo.GetTextElementEnumerator -Methode und der TextElementEnumerator -Klasse zum Aufzählen aller Textelemente in einer Zeichenfolge verwendet. Sie können auch ein Array abrufen, das den Startindex jedes Textelements enthält, indem Sie die StringInfo.ParseCombiningCharacters -Methode aufrufen.
Weitere Informationen zum Arbeiten mit Texteinheiten anstelle einzelner Char Werte finden Sie unter Einführung in die Zeichencodierung in .NET.
NULL-Zeichenfolgen und leere Zeichenfolgen
Eine Zeichenfolge, die deklariert, aber keinem Wert zugewiesen wurde, ist null. Beim Aufrufen von Methoden für diese Zeichenfolge wird ein NullReferenceExceptionausgelöst. Eine NULL-Zeichenfolge unterscheidet sich von einer leeren Zeichenfolge, bei der es sich um eine Zeichenfolge handelt, deren Wert "" oder String.Emptyist. In einigen Fällen löst das Übergeben einer NULL-Zeichenfolge oder einer leeren Zeichenfolge als Argument in einem Methodenaufruf eine Ausnahme aus. Wenn Sie beispielsweise eine NULL-Zeichenfolge an die Int32.Parse -Methode übergeben, wird ein ArgumentNullExceptionausgelöst, und das Übergeben einer leeren Zeichenfolge löst einen aus FormatException. In anderen Fällen kann ein Methodenargument entweder eine NULL-Zeichenfolge oder eine leere Zeichenfolge sein. Wenn Sie beispielsweise eine IFormattable Implementierung für eine Klasse bereitstellen, möchten Sie sowohl eine NULL-Zeichenfolge als auch eine leere Zeichenfolge mit dem allgemeinen Formatbezeichner ("G") gleichsetzen.
Die String -Klasse enthält die folgenden beiden Komfortmethoden, mit denen Sie testen können, ob eine Zeichenfolge leer ist null oder nicht:
IsNullOrEmpty, die angibt, ob eine Zeichenfolge gleich
nullString.Emptyoder ist. Durch diese Methode entfällt die Notwendigkeit, Code wie den folgenden zu verwenden:if (str == nullptr || str->Equals(String::Empty))if (str == null || str.Equals(String.Empty))if str = null || str.Equals String.Empty thenIf str Is Nothing OrElse str.Equals(String.Empty) ThenIsNullOrWhiteSpace, die angibt, ob eine Zeichenfolge ist
null, gleich String.Emptyoder ausschließlich aus Leerzeichen besteht. Durch diese Methode entfällt die Notwendigkeit, Code wie den folgenden zu verwenden:if (str == nullptr || str->Equals(String::Empty) || str->Trim()->Equals(String::Empty))if (str == null || str.Equals(String.Empty) || str.Trim().Equals(String.Empty))if str = null || str.Equals String.Empty || str.Trim().Equals String.Empty thenIf str Is Nothing OrElse str.Equals(String.Empty) OrElse str.Trim().Equals(String.Empty)
Im folgenden Beispiel wird die IsNullOrEmpty -Methode bei der IFormattable.ToString Implementierung einer benutzerdefinierten Temperature Klasse verwendet. Die -Methode unterstützt die Formatzeichenfolgen "G", "C", "F" und "K". Wenn eine leere Formatzeichenfolge oder eine Formatzeichenfolge, deren Wert an die -Methode übergeben wird null , wird ihr Wert in die Formatzeichenfolge "G" geändert.
public:
virtual String^ ToString(String^ format, IFormatProvider^ provider)
{
if (String::IsNullOrEmpty(format)) format = "G";
if (provider == nullptr) provider = CultureInfo::CurrentCulture;
switch (Convert::ToUInt16(format->ToUpperInvariant()))
{
// Return degrees in Celsius.
case 'G':
case 'C':
return temp.ToString("F2", provider) + L"�C";
// Return degrees in Fahrenheit.
case 'F':
return (temp * 9 / 5 + 32).ToString("F2", provider) + L"�F";
// Return degrees in Kelvin.
case 'K':
return (temp + 273.15).ToString();
default:
throw gcnew FormatException(
String::Format("The {0} format string is not supported.",
format));
}
}
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));
}
}
member _.ToString(format: string, provider: IFormatProvider) =
let format =
if String.IsNullOrEmpty format then "G" else format
let provider: IFormatProvider =
if provider = null then CultureInfo.CurrentCulture else provider
match format.ToUpperInvariant() with
// Return degrees in Celsius.
| "G"
| "C" ->
temp.ToString("F2", provider) + "°C"
// Return degrees in Fahrenheit.
| "F" ->
(temp * 9. / 5. + 32.).ToString("F2", provider) + "°F"
// Return degrees in Kelvin.
| "K" ->
(temp + 273.15).ToString()
| _ ->
raise (FormatException(String.Format("The {0} format string is not supported.",format)))
Public Overloads Function ToString(fmt As String, provider As IFormatProvider) As String _
Implements IFormattable.ToString
If String.IsNullOrEmpty(fmt) Then fmt = "G"
If provider Is Nothing Then provider = CultureInfo.CurrentCulture
Select Case fmt.ToUpperInvariant()
' Return degrees in Celsius.
Case "G", "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()
Case Else
Throw New FormatException(
String.Format("The {0} format string is not supported.",
fmt))
End Select
End Function
Unveränderlichkeit und die StringBuilder-Klasse
Ein String Objekt wird als unveränderlich (schreibgeschützt) bezeichnet, da sein Wert nach der Erstellung nicht mehr geändert werden kann. Methoden, die ein String Objekt zu ändern scheinen, geben tatsächlich ein neues String Objekt zurück, das die Änderung enthält.
Da Zeichenfolgen unveränderlich sind, können Zeichenfolgenbearbeitungsroutinen, die wiederholte Ergänzungen oder Löschungen einer scheinbar einzelnen Zeichenfolge ausführen, eine erhebliche Leistungseinbuße erzielen. Der folgende Code verwendet beispielsweise einen Zufallszahlengenerator, um eine Zeichenfolge mit 1.000 Zeichen im Bereich zu erstellen, der 0x0001 0x052F. Obwohl der Code anscheinend eine Zeichenfolgenverkettung verwendet, um ein neues Zeichen an die vorhandene Zeichenfolge mit dem Namen stranzufügen, erstellt er tatsächlich ein neues String Objekt für jeden Verkettungsvorgang.
using namespace System;
using namespace System::IO;
using namespace System::Text;
void main()
{
Random^ rnd = gcnew Random();
String^ str = String::Empty;
StreamWriter^ sw = gcnew 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();
}
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 += (char)rnd.Next(1, 0x0530);
if (str.Length % 60 == 0)
str += Environment.NewLine;
}
sw.Write(str);
sw.Close();
}
}
open System
open System.IO
open System.Text
do
let rnd = Random()
let mutable str = String.Empty
use sw = new StreamWriter(@".\StringFile.txt", false, Encoding.Unicode)
for _ = 0 to 1000 do
str <- str + (rnd.Next(1, 0x0530) |> char |> string)
if str.Length % 60 = 0 then
str <- str + Environment.NewLine
sw.Write str
Imports System.IO
Imports System.Text
Module Example
Public Sub Main()
Dim rnd As New Random()
Dim str As String = String.Empty
Dim sw As New StreamWriter(".\StringFile.txt",
False, Encoding.Unicode)
For ctr As Integer = 0 To 1000
str += ChrW(rnd.Next(1, &h0530))
If str.Length Mod 60 = 0 Then str += vbCrLf
Next
sw.Write(str)
sw.Close()
End Sub
End Module
Sie können die StringBuilder -Klasse anstelle der String -Klasse für Vorgänge verwenden, die mehrere Änderungen am Wert einer Zeichenfolge vornehmen. Im Gegensatz zu Instanzen der String -Klasse StringBuilder sind Objekte veränderlich. Wenn Sie Teilzeichenfolgen aus einer Zeichenfolge verketten, anfügen oder löschen, werden die Vorgänge für eine einzelne Zeichenfolge ausgeführt. Wenn Sie den Wert eines StringBuilder Objekts geändert haben, können Sie dessen StringBuilder.ToString Methode aufrufen, um es in eine Zeichenfolge zu konvertieren. Im folgenden Beispiel wird das String im vorherigen Beispiel zum Verketten von 1.000 zufälligen Zeichen im Bereich ersetzt, um 0x0001 mit einem StringBuilder Objekt zu 0x052F.
using namespace System;
using namespace System::IO;
using namespace System::Text;
void main()
{
Random^ rnd = gcnew Random();
StringBuilder^ sb = gcnew StringBuilder();
StreamWriter^ sw = gcnew 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();
}
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((char)rnd.Next(1, 0x0530));
if (sb.Length % 60 == 0)
sb.AppendLine();
}
sw.Write(sb.ToString());
sw.Close();
}
}
open System
open System.IO
open System.Text
do
let rnd = Random()
let sb = StringBuilder()
use sw = new StreamWriter(@".\StringFile.txt", false, Encoding.Unicode)
for _ = 0 to 1000 do
sb.Append(rnd.Next(1, 0x0530) |> char) |> ignore
if sb.Length % 60 = 0 then
sb.AppendLine() |> ignore
sw.Write(string sb)
Imports System.IO
Imports System.Text
Module Example
Public Sub Main()
Dim rnd As New Random()
Dim sb As New StringBuilder()
Dim sw As New StreamWriter(".\StringFile.txt",
False, Encoding.Unicode)
For ctr As Integer = 0 To 1000
sb.Append(ChrW(rnd.Next(1, &h0530)))
If sb.Length Mod 60 = 0 Then sb.AppendLine()
Next
sw.Write(sb.ToString())
sw.Close()
End Sub
End Module
Ordnungs- und kultursensible Vorgänge
Member der String -Klasse führen ordinale oder kultursensitive (linguistische) Vorgänge für ein Objekt aus String . Ein Ordnungsvorgang wirkt auf den numerischen Wert jedes Char Objekts. Ein kulturabhängiger Vorgang wirkt auf den Wert des String Objekts und berücksichtigt kulturspezifische Groß-, Sortier-, Formatierungs- und Analyseregeln. Kultursensible Vorgänge werden im Kontext einer explizit deklarierten Kultur oder der impliziten aktuellen Kultur ausgeführt. Die beiden Arten von Vorgängen können sehr unterschiedliche Ergebnisse erzeugen, wenn sie für dieselbe Zeichenfolge ausgeführt werden.
.NET unterstützt auch kulturunempfindliche linguistische Zeichenfolgenvorgänge, indem die invariante Kultur (CultureInfo.InvariantCulture) verwendet wird, die lose auf den Kultureinstellungen der englischen Sprache basiert, unabhängig von der Region. Im Gegensatz zu anderen System.Globalization.CultureInfo Einstellungen sind die Einstellungen der invarianten Kultur garantiert, dass sie auf einem einzelnen Computer konsistent bleiben, von System zu System und über .NET-Versionen hinweg. Die invariante Kultur kann als eine Art Blackbox gesehen werden, die stabilität von Zeichenfolgenvergleichen und -reihenfolgen über alle Kulturen hinweg gewährleistet.
Wichtig
Wenn Ihre Anwendung eine Sicherheitsentscheidung über einen symbolischen Bezeichner wie einen Dateinamen oder eine benannte Pipe oder über persistente Daten wie die textbasierten Daten in einer XML-Datei trifft, sollte der Vorgang einen Ordnungsvergleich anstelle eines kultursensiblen Vergleichs verwenden. Dies liegt daran, dass ein kultursensibler Vergleich abhängig von der tatsächlichen Kultur unterschiedliche Ergebnisse liefern kann, während ein Ordnungsvergleich ausschließlich vom Binärwert der verglichenen Zeichen abhängt.
Wichtig
Die meisten Methoden, die Zeichenfolgenvorgänge ausführen, umfassen eine Überladung mit einem Parameter vom Typ StringComparison, mit dem Sie angeben können, ob die Methode einen ordnungs- oder kultursensiblen Vorgang ausführt. Im Allgemeinen sollten Sie diese Überladung aufrufen, um die Absicht Ihres Methodenaufrufs zu löschen. Bewährte Methoden und Anleitungen für die Verwendung von ordnungs- und kultursensiblen Vorgängen für Zeichenfolgen finden Sie unter Bewährte Methoden für die Verwendung von Zeichenfolgen.
Vorgänge für Groß-und Kleinschreibung, Analyse und Formatierung, Vergleich und Sortierung sowie Tests auf Gleichheit können entweder ordinal oder kulturabhängig sein. In den folgenden Abschnitten werden die einzelnen Vorgangskategorien erläutert.
Tipp
Sie sollten immer eine Methodenüberladung aufrufen, die die Absicht Ihres Methodenaufrufs klar macht. Anstatt beispielsweise die Compare(String, String) -Methode aufzurufen, um einen kultursensitiven Vergleich von zwei Zeichenfolgen mithilfe der Konventionen der aktuellen Kultur durchzuführen, sollten Sie die -Methode mit dem Compare(String, String, StringComparison) Wert von StringComparison.CurrentCulture für das comparisonType Argument aufrufen. Weitere Informationen finden Sie unter Empfohlene Vorgehensweisen für die Verwendung von Zeichenfolgen in .NET Framework.
Sie können die Sortiergewichtungstabellen, eine Reihe von Textdateien, die Informationen zu den in Sortier- und Vergleichsvorgängen verwendeten Zeichenstärken enthalten, über die folgenden Links herunterladen:
- Windows (.NET Framework und .NET Core): Sortieren von Gewichtungstabellen
- Windows 10 Update vom Mai 2019 oder höher (.NET 5+) und Linux und macOS (.NET Core und .NET 5+): Standardtabelle für Unicode-Sortierungselemente
Schreibweise
Großschreibungsregeln bestimmen, wie die Groß-/Kleinschreibung eines Unicode-Zeichens geändert werden soll. beispielsweise von Kleinbuchstaben in Großbuchstaben. Häufig wird vor einem Zeichenfolgenvergleich ein Groß-/Kleinschreibungsvorgang ausgeführt. Beispielsweise kann eine Zeichenfolge in Großbuchstaben konvertiert werden, sodass sie mit einer anderen Großbuchstabenzeichenfolge verglichen werden kann. Sie können die Zeichen in einer Zeichenfolge in Kleinbuchstaben konvertieren, indem Sie die ToLower -Methode oder ToLowerInvariant aufrufen, und Sie können sie in Großbuchstaben konvertieren, indem Sie die ToUpper -Methode oder ToUpperInvariant aufrufen. Darüber hinaus können Sie die TextInfo.ToTitleCase -Methode verwenden, um eine Zeichenfolge in den Titelfall zu konvertieren.
Hinweis
.NET Core, die nur auf Linux- und macOS-Systemen ausgeführt wird: Beim Sortierungsverhalten für die Kulturen C und Posix wird immer die Groß-/Kleinschreibung beachtet, da diese Kulturen nicht die erwartete Unicode-Sortierungsreihenfolge verwenden. Bei der Durchführung kulturrelevanter Sortiervorgänge ohne Unterscheidung von Groß-/Kleinschreibung wird empfohlen, eine andere Kultur als C oder Posix zu verwenden.
Großschreibungsvorgänge können auf den Regeln der aktuellen Kultur, einer angegebenen Kultur oder der invarianten Kultur basieren. Da Groß- und Kleinschreibungszuordnungen je nach verwendeter Kultur variieren können, kann das Ergebnis von Groß- und Kleinschreibungsvorgängen je nach Kultur variieren. Die tatsächlichen Unterschiede in der Groß- und Kleinschreibung sind von drei Arten:
Unterschiede in der Fallzuordnung von LATIN CAPITAL LETTER I (U+0049), LATIN SMALL LETTER I (U+0069), LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130) und LATIN SMALL LETTER DOTLESS I (U+0131). In den Kulturen tr-TR (Türkisch (Türkei)) und az-Latn-AZ (Aserbaidschan, Lateinisch) sowie in den neutralen Kulturen tr, az und az-Latn ist das Kleinbuchstabenäquivalent von LATIN CAPITAL LETTER I LATIN SMALL LETTER DOTLESS I und das Großbuchstabenäquivalent von LATIN SMALL LETTER I ist LATIN CAPITAL LETTER I WITH DOT ABOVE. In allen anderen Kulturen, einschließlich der invarianten Kultur, sind LATIN SMALL LETTER I und LATIN CAPITAL LETTER I Klein- und Großbuchstaben Äquivalente.
Im folgenden Beispiel wird veranschaulicht, wie ein Zeichenfolgenvergleich, der zum Verhindern des Dateisystemzugriffs entwickelt wurde, fehlschlagen kann, wenn er auf einem kultursensiblen Groß- und Kleinschreibungsvergleich beruht. (Die Groß- und Kleinschreibungskonventionen der invarianten Kultur hätten verwendet werden müssen.)
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: Trueopen System open System.Globalization open System.Threading let disallowed = "file" let isAccessAllowed (resource: string) = let cultures = [| CultureInfo.CreateSpecificCulture "en-US" CultureInfo.CreateSpecificCulture "tr-TR" |] let index = resource.IndexOfAny [| '\\'; '/' |] let scheme = if index > 0 then resource.Substring(0, index - 1) else null // Change the current culture and perform the comparison. for culture in cultures do Thread.CurrentThread.CurrentCulture <- culture printfn $"Culture: {CultureInfo.CurrentCulture.DisplayName}" printfn $"{resource}" printfn $"Access allowed: {String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase) |> not}" printfn "" isAccessAllowed @"FILE:\\\c:\users\user001\documents\FinancialInfo.txt" // 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: TrueImports System.Globalization Imports System.Threading Module Example Const disallowed = "file" Public Sub Main() IsAccessAllowed("FILE:\\\c:\users\user001\documents\FinancialInfo.txt") End Sub Private Sub IsAccessAllowed(resource As String) Dim cultures() As CultureInfo = { CultureInfo.CreateSpecificCulture("en-US"), CultureInfo.CreateSpecificCulture("tr-TR") } Dim scheme As String = Nothing Dim index As Integer = resource.IndexOfAny( {"\"c, "/"c }) If index > 0 Then scheme = resource.Substring(0, index - 1) ' Change the current culture and perform the comparison. For Each culture In cultures Thread.CurrentThread.CurrentCulture = culture Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName) Console.WriteLine(resource) Console.WriteLine("Access allowed: {0}", Not String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase)) Console.WriteLine() Next End Sub End Module ' 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: TrueUnterschiede bei den Fallzuordnungen zwischen der invarianten Kultur und allen anderen Kulturen. In diesen Fällen gibt die Verwendung der Großbuchstabenregeln der invarianten Kultur zum Ändern eines Zeichens in Groß- oder Kleinbuchstaben dasselbe Zeichen zurück. Für alle anderen Kulturen gibt es ein anderes Zeichen zurück. Einige der betroffenen Zeichen sind in der folgenden Tabelle aufgeführt.
Zeichen Wenn geändert in Gibt zurück MICRON-ZEICHEN (U+00B5) Großbuchstaben GRIECHISCHER GROßBUCHSTABEN MU (U+-39C) LATEINISCHER GROßBUCHSTABEN I MIT PUNKT DARÜBER (U+0130) Kleinbuchstaben LATEINISCHER KLEINBUCHSTABEN I (U+0069) LATEINISCHER KLEINBUCHSTABEN PUNKTLOS I (U+0131) Großbuchstaben LATEINISCHER GROßBUCHSTABEN I (U+0049) LATEINISCHER KLEINBUCHSTABEN LONG S (U+017F) Großbuchstaben LATEINISCHER GROßBUCHSTABEN S (U+0053) LATEINISCHER GROßBUCHSTABEN D MIT KLEINBUCHSTABEN Z MIT CARON (U+01C5) Kleinbuchstaben LATEINISCHER KLEINBUCHSTABEN DZ MIT CARON (U+01C6) COMBINING GREEK YPOGEGRAMMENI (U+0345) Großbuchstaben GRIECHISCHER GROßBUCHSTABEN IOTA (U+0399) Unterschiede bei den Groß- und Kleinschreibungszuordnungen von Zweibuchstabenpaaren im ASCII-Zeichenbereich. In den meisten Kulturen ist ein Zwei-Buchstaben-Gemischtes Paar gleich dem entsprechenden Zweibuchstaben-Groß- oder Kleinbuchstabenpaar. Dies gilt nicht für die folgenden zwei Buchstabenpaare in den folgenden Kulturen, da sie jeweils mit einem Digraph verglichen werden:
"lJ" und "nJ" in der hr-HR -Kultur (Kroatisch (Kroatien)).
"cH" in den Kulturen cs-CZ (Tschechisch (Tschechische Republik)) und sk-SK (Slowakei)
"aA" in der da-DK (Dänische (Dänemark)-Kultur.
"cS", "dZ", "dZS", "nY", "sZ", "tY" und "zS" in der hu-HU -Kultur (Ungarn)
"cH" und "lL" in der es-ES_tradnl -Kultur (Spanisch (Spanien, Traditionelle Sortierung)).
"cH", "gI", "kH", "nG" "nH", "pH", "qU', "tH" und "tR" in der vi-VN -Kultur (Vietnam)
Es ist jedoch ungewöhnlich, eine Situation zu treffen, in der ein kultursensibler Vergleich dieser Paare Probleme verursacht, da diese Paare in festen Zeichenfolgen oder Bezeichnern ungewöhnlich sind.
Das folgende Beispiel veranschaulicht einige der Unterschiede bei den Großbuchstabenregeln zwischen Kulturen beim Konvertieren von Zeichenfolgen in Großbuchstaben.
using namespace System;
using namespace System::Globalization;
using namespace System::IO;
String^ ShowHexValue(String^ s);
void main()
{
StreamWriter^ sw = gcnew StreamWriter(".\\case.txt");
array<String^>^ words = gcnew array<String^> { L"file", L"sıfır", L"Dženana" };
array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture,
gcnew CultureInfo("en-US"),
gcnew CultureInfo("tr-TR") };
for each (String^ word in words) {
sw->WriteLine("{0}:", word);
for each (CultureInfo^ 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();
}
String^ ShowHexValue(String^ s)
{
String^ retval = nullptr;
for each (Char ch in s) {
array<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
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
open System
open System.Globalization
open System.IO
let showHexValue (s: string) =
let mutable retval = ""
for ch in s do
let bytes = BitConverter.GetBytes ch
retval <- retval + String.Format("{0:X2} {1:X2} ", bytes[1], bytes[0])
retval
do
use sw = new StreamWriter(@".\case.txt")
let words = [| "file"; "sıfır"; "Dženana" |]
let cultures =
[| CultureInfo.InvariantCulture
CultureInfo "en-US"
CultureInfo "tr-TR" |]
for word in words do
sw.WriteLine("{0}:", word)
for culture in cultures do
let name =
if String.IsNullOrEmpty culture.Name then "Invariant" else culture.Name
let upperWord = word.ToUpper culture
sw.WriteLine(" {0,10}: {1,7} {2, 38}", name, upperWord, showHexValue upperWord)
sw.WriteLine()
sw.Close()
// 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
Imports System.Globalization
Imports System.IO
Module Example
Public Sub Main()
Dim sw As New StreamWriter(".\case.txt")
Dim words As String() = { "file", "sıfır", "Dženana" }
Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture,
New CultureInfo("en-US"),
New CultureInfo("tr-TR") }
For Each word In words
sw.WriteLine("{0}:", word)
For Each culture In cultures
Dim name As String = If(String.IsNullOrEmpty(culture.Name),
"Invariant", culture.Name)
Dim upperWord As String = word.ToUpper(culture)
sw.WriteLine(" {0,10}: {1,7} {2, 38}", name,
upperWord, ShowHexValue(upperWord))
Next
sw.WriteLine()
Next
sw.Close()
End Sub
Private Function ShowHexValue(s As String) As String
Dim retval As String = Nothing
For Each ch In s
Dim bytes() As Byte = BitConverter.GetBytes(ch)
retval += String.Format("{0:X2} {1:X2} ", bytes(1), bytes(0))
Next
Return retval
End Function
End Module
' 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
Analyse und Formatierung
Formatierung und Analyse sind umgekehrte Vorgänge. Formatierungsregeln bestimmen, wie ein Wert, z. B. ein Datum und eine Uhrzeit oder eine Zahl, in seine Zeichenfolgendarstellung konvertiert werden soll, während Analyseregeln bestimmen, wie eine Zeichenfolgendarstellung in einen Wert wie Datum und Uhrzeit konvertiert werden soll. Sowohl Formatierungs- als auch Analyseregeln sind von kulturellen Konventionen abhängig. Das folgende Beispiel veranschaulicht die Mehrdeutigkeit, die beim Interpretieren einer kulturspezifischen Datumszeichenfolge entstehen kann. Ohne die Konventionen der Kultur zu kennen, die zum Erzeugen einer Datumszeichenfolge verwendet wurde, ist es nicht möglich, zu wissen, ob 03/01/2011, 3/1/2011 und 01/03/2011 den 3. Januar 2011 oder den 1. März 2011 darstellen.
using namespace System;
using namespace System::Globalization;
void main()
{
DateTime^ date = gcnew DateTime(2011, 3, 1);
array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture,
gcnew CultureInfo("en-US"),
gcnew CultureInfo("fr-FR") };
for each (CultureInfo^ 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
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
open System
open System.Globalization
let date = DateTime(2011, 3, 1)
let cultures =
[| CultureInfo.InvariantCulture
CultureInfo "en-US"
CultureInfo "fr-FR" |]
for culture in cultures do
printfn $"""{(if String.IsNullOrEmpty culture.Name then "Invariant" else culture.Name),-12} {date.ToString("d", culture)}"""
// The example displays the following output:
// Invariant 03/01/2011
// en-US 3/1/2011
// fr-FR 01/03/2011
Imports System.Globalization
Module Example
Public Sub Main()
Dim dat As Date = #3/1/2011#
Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture,
New CultureInfo("en-US"),
New CultureInfo("fr-FR") }
For Each culture In cultures
Console.WriteLine("{0,-12} {1}", If(String.IsNullOrEmpty(culture.Name),
"Invariant", culture.Name),
dat.ToString("d", culture))
Next
End Sub
End Module
' The example displays the following output:
' Invariant 03/01/2011
' en-US 3/1/2011
' fr-FR 01/03/2011
Ähnlich kann eine einzelne Zeichenfolge, wie das folgende Beispiel zeigt, je nach Kultur, deren Konventionen im Analysevorgang verwendet werden, unterschiedliche Datumsangaben erzeugen.
using namespace System;
using namespace System::Globalization;
void main()
{
String^ dateString = "07/10/2011";
array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { 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");
for each (CultureInfo^ 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
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
open System
open System.Globalization
let dateString = "07/10/2011"
let cultures =
[| CultureInfo.InvariantCulture
CultureInfo.CreateSpecificCulture "en-GB"
CultureInfo.CreateSpecificCulture "en-US" |]
printfn $"""{"Date String",-12} {"Culture",10} {"Month",8} {"Day",8}\n"""
for culture in cultures do
let date = DateTime.Parse(dateString, culture)
printfn $"""{dateString,-12} {(if String.IsNullOrEmpty culture.Name then "Invariant" else culture.Name),10} {date.Month,8} {date.Day,8}"""
// 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
Imports System.Globalization
Module Example
Public Sub Main()
Dim dateString As String = "07/10/2011"
Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture,
CultureInfo.CreateSpecificCulture("en-GB"),
CultureInfo.CreateSpecificCulture("en-US") }
Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", "Date String", "Culture",
"Month", "Day")
Console.WriteLine()
For Each culture In cultures
Dim dat As Date = DateTime.Parse(dateString, culture)
Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString,
If(String.IsNullOrEmpty(culture.Name),
"Invariant", culture.Name),
dat.Month, dat.Day)
Next
End Sub
End Module
' The example displays the following output:
' Date String Culture Month Day
'
' 07/10/2011 Invariant 7 10
' 07/10/2011 en-GB 10 7
' 07/10/2011 en-US 7 10
Zeichenfolgenvergleich und -sortierung
Konventionen zum Vergleichen und Sortieren von Zeichenfolgen variieren von Kultur zu Kultur. Die Sortierreihenfolge kann beispielsweise auf Phonetik oder auf der visuellen Darstellung von 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 kann bei Vergleichen die Groß-/Kleinschreibung beachtet oder die Groß-/Kleinschreibung nicht beachtet werden, und die Groß- und Kleinschreibungsregeln können sich je nach Kultur unterscheiden. Der Ordnungsvergleich verwendet hingegen die Unicode-Codepunkte einzelner Zeichen in einer Zeichenfolge beim Vergleichen und Sortieren von Zeichenfolgen.
Sortierregeln bestimmen die alphabetische Reihenfolge von Unicode-Zeichen und den Vergleich zweier Zeichenfolgen. Die Methode vergleicht beispielsweise String.Compare(String, String, StringComparison) zwei Zeichenfolgen basierend auf dem StringComparison Parameter. Wenn der Parameterwert ist StringComparison.CurrentCulture, führt die -Methode einen linguistischen Vergleich durch, der die Konventionen der aktuellen Kultur verwendet. Wenn der Parameterwert ist StringComparison.Ordinal, führt die -Methode einen Ordnungsvergleich durch. Wenn die aktuelle Kultur US-Englisch ist, betrachtet der erste Aufruf der -Methode (mithilfe eines String.Compare(String, String, StringComparison) kultursensitiven Vergleichs) wie im folgenden Beispiel gezeigt "a" kleiner als "A", aber beim zweiten Aufruf derselben Methode (mithilfe des Ordnungsvergleichs) wird "a" größer als "A" betrachtet.
using namespace System;
using namespace System::Globalization;
using namespace System::Threading;
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
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
open System
open System.Globalization
open System.Threading
Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-US"
printfn $"""{String.Compare("A", "a", StringComparison.CurrentCulture)}"""
printfn $"""{String.Compare("A", "a", StringComparison.Ordinal)}"""
// The example displays the following output:
// 1
// -32
Imports System.Globalization
Imports System.Threading
Module Example
Public Sub Main()
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture))
Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal))
End Sub
End Module
' The example displays the following output:
' 1
' -32
.NET unterstützt Wort-, Zeichenfolgen- und Ordnungssortierregeln:
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 kann dem Bindestrich (-) eine sehr geringe Gewichtung zugewiesen sein, sodass "coop" und "koop" nebeneinander in einer sortierten Liste angezeigt werden. Eine Liste der Methoden, mit denen String zwei Zeichenfolgen mithilfe von Wortsortierregeln verglichen werden, finden Sie im Abschnitt Zeichenfolgenvorgänge nach Kategorie .
Eine Zeichenfolgensortierung führt auch einen kulturabhängigen Vergleich durch. Es ähnelt einer Wortsortierung, mit dem Unterschied, dass es keine Sonderfälle gibt, und alle nichtalphanumerischen Symbole kommen vor allen alphanumerischen Unicode-Zeichen. Zwei Zeichenfolgen können mithilfe von Zeichenfolgensortierregeln verglichen werden, indem die CompareInfo.Compare Methodenüberladungen aufgerufen werden, die über einen
optionsParameter verfügen, der mit dem Wert von CompareOptions.StringSortangegeben wird. Beachten Sie, dass dies die einzige Methode ist, die .NET bereitstellt, um zwei Zeichenfolgen mithilfe von Zeichenfolgensortierregeln zu vergleichen.Eine Ordinalsortierung vergleicht Zeichenfolgen anhand des numerischen Werts jedes Char-Objekts in der Zeichenfolge. Bei einem Ordnungsvergleich wird automatisch die Groß-/Kleinschreibung beachtet, da die Klein- und Großbuchstaben eines Zeichens unterschiedliche Codepunkte aufweisen. Wenn der Fall jedoch nicht wichtig ist, können Sie einen Ordnungsvergleich angeben, der die Groß- und Kleinschreibung ignoriert. Dies entspricht dem Konvertieren der Zeichenfolge in Großbuchstaben mithilfe der invarianten Kultur und anschließendem Durchführen eines Ordnungsvergleichs für das Ergebnis. Eine Liste der Methoden, die String zwei Zeichenfolgen mithilfe von Ordnungsregeln vergleichen, finden Sie im Abschnitt Zeichenfolgenvorgänge nach Kategorie .
Ein kultursensibler Vergleich ist jeder Vergleich, der explizit oder implizit ein CultureInfo Objekt verwendet, einschließlich der invarianten Kultur, die von der CultureInfo.InvariantCulture -Eigenschaft angegeben wird. Die implizite Kultur ist die aktuelle Kultur, die durch die Thread.CurrentCulture Eigenschaften und CultureInfo.CurrentCulture angegeben wird. Die Sortierreihenfolge alphabetischer Zeichen (d. h. Zeichen, für die die Eigenschaft zurückgibttrue) gibt es zwischen den Char.IsLetter Kulturen erhebliche Unterschiede. Sie können einen kultursensitiven Vergleich angeben, der die Konventionen einer bestimmten Kultur verwendet, indem Sie ein CultureInfo Objekt für eine Zeichenfolgenvergleichsmethode wie Compare(String, String, CultureInfo, CompareOptions)bereitstellen. Sie können einen kultursensitiven Vergleich angeben, der die Konventionen der aktuellen Kultur verwendet, indem Sie , StringComparison.CurrentCultureIgnoreCaseoder ein anderes Element der CompareOptions Enumeration als CompareOptions.Ordinal oder CompareOptions.OrdinalIgnoreCase für eine geeignete Überladung der Compare -Methode angebenStringComparison.CurrentCulture. Ein kultursensibler Vergleich eignet sich in der Regel für die Sortierung, während ein Ordnungsvergleich dies nicht ist. Ein Ordnungsvergleich ist im Allgemeinen geeignet, um zu bestimmen, ob zwei Zeichenfolgen gleich sind (d. h. zum Bestimmen der Identität), während ein kultursensibler Vergleich dies nicht ist.
Das folgende Beispiel veranschaulicht den Unterschied zwischen kultursensiblem Und Ordnungsvergleich. Im Beispiel werden die drei Zeichenfolgen "Apple", "Æble" und "AEble" anhand des Ordnungsvergleichs und der Konventionen der Kulturen da-DK und en-US ausgewertet (die jeweils die Standardkultur zum Zeitpunkt des Aufrufs der Compare Methode sind). Da die dänische Sprache das Zeichen "Æ" als einzelnen Buchstaben behandelt und nach "Z" im Alphabet sortiert, ist die Zeichenfolge "Æble" größer als "Apple". "Æble" wird jedoch nicht als gleichwertig mit "AEble" betrachtet, daher ist "Æble" auch größer als "AEble". Die en-US-Kultur enthält nicht den Buchstaben "Æ", sondern behandelt ihn als gleichwertig mit "AE", was erklärt, warum "Æble" kleiner als "Apple" ist, aber gleich "AEble". Der Ordinalvergleich hingegen betrachtet "Apple" als kleiner als "Æble" und "Æble" als größer als "AEble".
using System;
using System.Globalization;
using System.Threading;
public class CompareStringSample
{
public static void Main()
{
string str1 = "Apple";
string str2 = "Æble";
string str3 = "AEble";
// Set the current culture to Danish in Denmark.
Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
Console.WriteLine("Current culture: {0}",
CultureInfo.CurrentCulture.Name);
Console.WriteLine("Comparison of {0} with {1}: {2}",
str1, str2, String.Compare(str1, str2));
Console.WriteLine("Comparison of {0} with {1}: {2}\n",
str2, str3, String.Compare(str2, str3));
// Set the current culture to English in the U.S.
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
Console.WriteLine("Current culture: {0}",
CultureInfo.CurrentCulture.Name);
Console.WriteLine("Comparison of {0} with {1}: {2}",
str1, str2, String.Compare(str1, str2));
Console.WriteLine("Comparison of {0} with {1}: {2}\n",
str2, str3, String.Compare(str2, str3));
// Perform an ordinal comparison.
Console.WriteLine("Ordinal comparison");
Console.WriteLine("Comparison of {0} with {1}: {2}",
str1, str2,
String.Compare(str1, str2, StringComparison.Ordinal));
Console.WriteLine("Comparison of {0} with {1}: {2}",
str2, str3,
String.Compare(str2, str3, StringComparison.Ordinal));
}
}
// The example displays the following output:
// Current culture: da-DK
// Comparison of Apple with Æble: -1
// Comparison of Æble with AEble: 1
//
// Current culture: en-US
// Comparison of Apple with Æble: 1
// Comparison of Æble with AEble: 0
//
// Ordinal comparison
// Comparison of Apple with Æble: -133
// Comparison of Æble with AEble: 133
open System
open System.Globalization
open System.Threading
let str1 = "Apple"
let str2 = "Æble"
let str3 = "AEble"
// Set the current culture to Danish in Denmark.
Thread.CurrentThread.CurrentCulture <- CultureInfo "da-DK"
printfn $"Current culture: {CultureInfo.CurrentCulture.Name}"
printfn $"Comparison of {str1} with {str2}: {String.Compare(str1, str2)}"
printfn $"Comparison of {str2} with {str3}: {String.Compare(str2, str3)}\n"
// Set the current culture to English in the U.S.
Thread.CurrentThread.CurrentCulture <- CultureInfo "en-US"
printfn $"Current culture: {CultureInfo.CurrentCulture.Name}"
printfn $"Comparison of {str1} with {str2}: {String.Compare(str1, str2)}"
printfn $"Comparison of {str2} with {str3}: {String.Compare(str2, str3)}\n"
// Perform an ordinal comparison.
printfn "Ordinal comparison"
printfn $"Comparison of {str1} with {str2}: {String.Compare(str1, str2, StringComparison.Ordinal)}"
printfn $"Comparison of {str2} with {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
Imports System.Globalization
Imports System.Threading
Public Module Example
Public Sub Main()
Dim str1 As String = "Apple"
Dim str2 As String = "Æble"
Dim str3 As String = "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}",
str2, str3, String.Compare(str2, str3))
Console.WriteLine()
' 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}",
str2, str3, String.Compare(str2, str3))
Console.WriteLine()
' 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))
End Sub
End Module
' 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 geeignete Sortier- oder Zeichenfolgenvergleichsmethode auszuwählen:
Wenn Die Zeichenfolgen basierend auf der Kultur des Benutzers sortiert werden sollen, sollten Sie sie basierend auf den Konventionen der aktuellen Kultur sortieren. Wenn sich die Kultur des Benutzers ändert, ändert sich auch die Reihenfolge der sortierten Zeichenfolgen entsprechend. Beispielsweise sollte eine Thesaurusanwendung Wörter immer basierend auf der Kultur des Benutzers sortieren.
Wenn Sie möchten, dass die Zeichenfolgen basierend auf den Konventionen einer bestimmten Kultur sortiert werden, sollten Sie sie sortieren, indem Sie ein CultureInfo -Objekt bereitstellen, das diese Kultur für eine Vergleichsmethode darstellt. In einer Anwendung zum Unterrichten einer bestimmten Sprache möchten Sie beispielsweise, dass Zeichenfolgen basierend auf den Konventionen einer der Kulturen, die diese Sprache spricht, sortiert werden.
Wenn die Reihenfolge der Zeichenfolgen kulturübergreifend unverändert bleiben soll, sollten Sie sie basierend auf den Konventionen der invarianten Kultur sortieren oder einen Ordnungsvergleich verwenden. Beispielsweise würden Sie eine Ordnungssortierung verwenden, um die Namen von Dateien, Prozessen, Mutexes oder Named Pipes zu organisieren.
Für einen Vergleich, der eine Sicherheitsentscheidung umfasst (z. B. ob ein Benutzername gültig ist), sollten Sie immer einen Ordnungstest auf Gleichheit durchführen, indem Sie eine Überladung der Equals Methode aufrufen.
Hinweis
Die kultursensiblen Sortier- und Großschreibungsregeln, die im Zeichenfolgenvergleich verwendet werden, hängen von der Version von .NET ab. Bei .NET Core hängt der Zeichenfolgenvergleich von der Vom zugrunde liegenden Betriebssystem unterstützten Version des Unicode-Standards ab. In .NET Framework Version 4.5 und höher, die unter Windows 8 oder höher ausgeführt werden, entsprechen Sortierung, Großschreibung, Normalisierung und Unicode-Zeicheninformationen dem Unicode 6.0-Standard. Auf anderen Windows-Betriebssystemen entsprechen sie dem Unicode 5.0-Standard.
Weitere Informationen zu Wort-, Zeichenfolgen- und Ordnungssortierregeln finden Sie im System.Globalization.CompareOptions Thema. Weitere Empfehlungen zur Verwendung der einzelnen Regeln finden Sie unter Bewährte Methoden für die Verwendung von Zeichenfolgen.
Normalerweise rufen Sie keine Zeichenfolgenvergleichsmethoden auf, z Compare . B. direkt, um die Sortierreihenfolge von Zeichenfolgen zu bestimmen. Stattdessen werden Vergleichsmethoden durch Sortiermethoden wie Array.Sort oder List<T>.Sortaufgerufen. Im folgenden Beispiel werden vier verschiedene Sortiervorgänge ausgeführt (Wortsortierung mithilfe der aktuellen Kultur, Wortsortierung mithilfe der invarianten Kultur, Ordnungssortierung und Zeichenfolgensortierung mithilfe der invarianten Kultur), ohne explizit eine Zeichenfolgenvergleichsmethode aufzurufen, obwohl sie den zu verwendenden Vergleichstyp angeben. Beachten Sie, dass jeder Sortiertyp eine eindeutige Reihenfolge von Zeichenfolgen in seinem Array erzeugt.
using namespace System;
using namespace System::Collections;
using namespace System::Collections::Generic;
using namespace System::Globalization;
// IComparer<String> implementation to perform string sort.
ref class SCompare : System::Collections::Generic::IComparer<String^>
{
public:
SCompare() {};
virtual int Compare(String^ x, String^ y)
{
return CultureInfo::CurrentCulture->CompareInfo->Compare(x, y, CompareOptions::StringSort);
}
};
void main()
{
array<String^>^ strings = gcnew array<String^> { "coop", "co-op", "cooperative",
L"co\x00ADoperative", L"c�ur", "coeur" };
// Perform a word sort using the current (en-US) culture.
array<String^>^ current = gcnew array<String^>(strings->Length);
strings->CopyTo(current, 0);
Array::Sort(current, StringComparer::CurrentCulture);
// Perform a word sort using the invariant culture.
array<String^>^ invariant = gcnew array<String^>(strings->Length);
strings->CopyTo(invariant, 0);
Array::Sort(invariant, StringComparer::InvariantCulture);
// Perform an ordinal sort.
array<String^>^ ordinal = gcnew array<String^>(strings->Length);
strings->CopyTo(ordinal, 0);
Array::Sort(ordinal, StringComparer::Ordinal);
// Perform a string sort using the current culture.
array<String^>^ stringSort = gcnew array<String^>(strings->Length);
strings->CopyTo(stringSort, 0);
Array::Sort(stringSort, gcnew 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] );
}
// 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
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
// cooperative co-op co-op cooperative coop
// cœur cooperative cooperative cooperative cooperative
// coeur cooperative cooperative cœur cooperative
open System
open System.Collections.Generic
open System.Globalization
// IComparer<String> implementation to perform string sort using an F# object expression.
let scompare =
{ new IComparer<String> with
member _.Compare(x, y) =
CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort) }
let strings = [| "coop"; "co-op"; "cooperative"; "co\u00ADoperative"; "cœur"; "coeur" |]
// Perform a word sort using the current (en-US) culture.
let current = Array.copy strings
Array.Sort(current, StringComparer.CurrentCulture)
// Perform a word sort using the invariant culture.
let invariant = Array.copy strings
Array.Sort(invariant, StringComparer.InvariantCulture)
// Perform an ordinal sort.
let ordinal = Array.copy strings
Array.Sort(ordinal, StringComparer.Ordinal)
// Perform a string sort using the current culture.
let stringSort = Array.copy strings
Array.Sort(stringSort, scompare)
// Display array values
printfn "%13s %13s %15s %13s %13s\n" "Original" "Word Sort" "Invariant Word" "Ordinal Sort" "String Sort"
for i = 0 to strings.Length - 1 do
printfn "%13s %13s %15s %13s %13s\n" strings[i] current[i] invariant[i] ordinal[i] stringSort[i]
// 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
// cooperative co-op co-op cooperative coop
// cœur cooperative cooperative cooperative cooperative
// coeur cooperative cooperative cœur cooperative
Imports System.Collections
Imports System.Collections.Generic
Imports System.Globalization
Module Example
Public Sub Main()
Dim strings() As String = { "coop", "co-op", "cooperative",
"co" + ChrW(&h00AD) + "operative",
"cœur", "coeur" }
' Perform a word sort using the current (en-US) culture.
Dim current(strings.Length - 1) As String
strings.CopyTo(current, 0)
Array.Sort(current, StringComparer.CurrentCulture)
' Perform a word sort using the invariant culture.
Dim invariant(strings.Length - 1) As String
strings.CopyTo(invariant, 0)
Array.Sort(invariant, StringComparer.InvariantCulture)
' Perform an ordinal sort.
Dim ordinal(strings.Length - 1) As String
strings.CopyTo(ordinal, 0)
Array.Sort(ordinal, StringComparer.Ordinal)
' Perform a string sort using the current culture.
Dim stringSort(strings.Length - 1) As String
strings.CopyTo(stringSort, 0)
Array.Sort(stringSort, new SCompare())
' Display array values
Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}",
"Original", "Word Sort", "Invariant Word",
"Ordinal Sort", "String Sort")
Console.WriteLine()
For ctr As Integer = 0 To strings.Length - 1
Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}",
strings(ctr), current(ctr), invariant(ctr),
ordinal(ctr), stringSort(ctr))
Next
End Sub
End Module
' IComparer<String> implementation to perform string sort.
Friend Class SCompare : Implements IComparer(Of String)
Public Function Compare(x As String, y As String) As Integer _
Implements IComparer(Of String).Compare
Return CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort)
End Function
End Class
' 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
' cooperative co-op co-op cooperative coop
' cœur cooperative cooperative cooperative cooperative
' coeur cooperative cooperative cœur cooperative
Tipp
Intern verwendet .NET Sortierschlüssel, um kultursensible Zeichenfolgenvergleiche 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, der durch die SortKey -Klasse dargestellt wird, stellt ein Repository mit diesen Gewichtungen für eine bestimmte Zeichenfolge bereit. Wenn Ihre App eine große Anzahl von Such- oder Sortiervorgängen für denselben Satz von Zeichenfolgen ausführt, können Sie die Leistung verbessern, indem Sie Sortierschlüssel für alle von ihr verwendeten Zeichenfolgen generieren und speichern. Wenn ein Sortier- oder Vergleichsvorgang erforderlich ist, verwenden Sie die Sortierschlüssel anstelle der Zeichenfolgen. Weitere Informationen finden Sie in den Ausführungen zur SortKey-Klasse.
Wenn Sie keine Zeichenfolgenvergleichskonvention angeben, führen Sortiermethoden wie Array.Sort(Array) z. B. eine kulturabhängige Sortierung für Zeichenfolgen durch, bei der die Groß-/Kleinschreibung beachtet wird. Das folgende Beispiel veranschaulicht, wie sich die Änderung der aktuellen Kultur auf die Reihenfolge der sortierten Zeichenfolgen in einem Array auswirkt. Es erstellt ein Array aus 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
open System
open System.Globalization
open System.Threading
let printIndexAndValues (myArray: string[]) =
for i = myArray.GetLowerBound 0 to myArray.GetUpperBound 0 do
printfn $"[{i}]: {myArray[i]}"
printfn ""
// Create and initialize a new array to store the strings.
let stringArray = [| "Apple"; "Æble"; "Zebra" |]
// Display the values of the array.
printfn "The original string array:"
printIndexAndValues stringArray
// Set the CurrentCulture to "en-US".
Thread.CurrentThread.CurrentCulture <- CultureInfo "en-US"
// Sort the values of the array.
Array.Sort stringArray
// Display the values of the array.
printfn "After sorting for the culture \"en-US\":"
printIndexAndValues stringArray
// Set the CurrentCulture to "da-DK".
Thread.CurrentThread.CurrentCulture <- CultureInfo "da-DK"
// Sort the values of the Array.
Array.Sort stringArray
// Display the values of the array.
printfn "After sorting for the culture \"da-DK\":"
printIndexAndValues stringArray
// 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
Imports System.Globalization
Imports System.IO
Imports System.Threading
Public Class TextToFile
Public Shared Sub Main()
' Creates and initializes a new array to store
' these date/time objects.
Dim stringArray() As String = { "Apple", "Æble", "Zebra"}
' Displays 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 ""en-US"" culture:")
PrintIndexAndValues(stringArray)
' Set the CurrentCulture to "da-DK".
Thread.CurrentThread.CurrentCulture = New CultureInfo("da-DK")
' Sort the values of the Array.
Array.Sort(stringArray)
' Displays the values of the Array.
Console.WriteLine("After sorting for the culture ""da-DK"":")
PrintIndexAndValues(stringArray)
End Sub
Public Shared Sub PrintIndexAndValues(myArray() As String)
For i As Integer = myArray.GetLowerBound(0) To myArray.GetUpperBound(0)
Console.WriteLine("[{0}]: {1}", i, myArray(i))
Next
Console.WriteLine()
End Sub
End Class
' 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
Warnung
Wenn Ihr Hauptzweck beim Vergleichen von Zeichenfolgen darin besteht, zu bestimmen, ob sie gleich sind, sollten Sie die String.Equals -Methode aufrufen. In der Regel sollten Equals Sie verwenden, um einen Ordnungsvergleich durchzuführen. Die String.Compare Methode dient in erster Linie zum Sortieren von Zeichenfolgen.
Zeichenfolgensuchmethoden wie String.StartsWith und String.IndexOfkönnen auch kulturbezogene oder ordnungsbezogene Zeichenfolgenvergleiche durchführen. Im folgenden Beispiel werden die Unterschiede zwischen ordinalen und kultursensiblen Vergleichen mithilfe der IndexOf -Methode veranschaulicht. Bei einer kultursensitiven Suche, bei der die aktuelle Kultur Englisch ist (USA), wird die Teilzeichenfolge "oe" als Übereinstimmung mit der Ligatur "œ" betrachtet. Da ein weicher Bindestrich (U+00AD) ein Zeichen der Breite null ist, behandelt die Suche den weichen Bindestrich als Äquivalent zu Empty und findet eine Übereinstimmung am Anfang der Zeichenfolge. Eine Ordinalsuche hingegen findet in beiden Fällen keine Übereinstimmung.
using namespace System;
void FindInString(String^ s, String^ substring, StringComparison options);
void main()
{
// Search for "oe" and "�u" in "�ufs" and "oeufs".
String^ s1 = L"�ufs";
String^ s2 = L"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 = L"co\x00ADoperative";
FindInString(s3, L"\x00AD", StringComparison::CurrentCulture);
FindInString(s3, L"\x00AD", StringComparison::Ordinal);
}
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 oufs at position 0
// 'oe' not found in oufs
// 'ou' found in oeufs at position 0
// 'ou' not found in oeufs
//
// '-' found in co-operative at position 0
// '-' found in co-operative at position 2
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 cooperative at position 0
// '' found in cooperative at position 2
open System
let findInString (s: string) (substring: string) (options: StringComparison) =
let result = s.IndexOf(substring, options)
if result <> -1 then
printfn $"'{substring}' found in {s} at position {result}"
else
printfn $"'{substring}' not found in {s}"
// Search for "oe" and "œu" in "œufs" and "oeufs".
let s1 = "œufs"
let s2 = "oeufs"
findInString s1 "oe" StringComparison.CurrentCulture
findInString s1 "oe" StringComparison.Ordinal
findInString s2 "œu" StringComparison.CurrentCulture
findInString s2 "œu" StringComparison.Ordinal
printfn ""
let s3 = "co\u00ADoperative"
findInString s3 "\u00AD" StringComparison.CurrentCulture
findInString s3 "\u00AD" StringComparison.Ordinal
// 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 cooperative at position 0
// '' found in cooperative at position 2
Module Example
Public Sub Main()
' Search for "oe" and "œu" in "œufs" and "oeufs".
Dim s1 As String = "œufs"
Dim s2 As String = "oeufs"
FindInString(s1, "oe", StringComparison.CurrentCulture)
FindInString(s1, "oe", StringComparison.Ordinal)
FindInString(s2, "œu", StringComparison.CurrentCulture)
FindInString(s2, "œu", StringComparison.Ordinal)
Console.WriteLine()
Dim softHyphen As String = ChrW(&h00AD)
Dim s3 As String = "co" + softHyphen + "operative"
FindInString(s3, softHyphen, StringComparison.CurrentCulture)
FindInString(s3, softHyphen, StringComparison.Ordinal)
End Sub
Private Sub FindInString(s As String, substring As String,
options As StringComparison)
Dim result As Integer = 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)
End If
End Sub
End Module
' 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 cooperative at position 0
' '' found in cooperative at position 2
Suchen in Zeichenfolgen
Zeichenfolgensuchmethoden wie String.StartsWith und String.IndexOfkönnen auch kulturabhängige oder ordinale Zeichenfolgenvergleiche durchführen, um zu bestimmen, ob ein Zeichen oder eine Teilzeichenfolge in einer angegebenen Zeichenfolge gefunden wird.
Die Suchmethoden in der String -Klasse, die nach einem einzelnen Zeichen suchen, z. B. die IndexOf -Methode, oder eines von einem Satz von Zeichen, z. B. die IndexOfAny -Methode, führen alle eine Ordnungssuche durch. Um eine kulturabhängige Suche nach einem Zeichen durchzuführen, müssen Sie eine CompareInfo Methode wie CompareInfo.IndexOf(String, Char) oder CompareInfo.LastIndexOf(String, Char)aufrufen. Beachten Sie, dass die Ergebnisse der Suche nach einem Zeichen unter Verwendung von Ordnungs- und kulturbezogenem Vergleich sehr unterschiedlich sein können. Beispielsweise kann eine Suche nach einem vorkompilierten Unicode-Zeichen wie der Ligatur "Æ" (U+00C6) je nach Kultur mit jedem Vorkommen seiner Komponenten in der richtigen Reihenfolge übereinstimmen, z. B. "AE" (U+041U+0045). Im folgenden Beispiel wird der Unterschied zwischen den Methoden und CompareInfo.IndexOf(String, Char) bei der String.IndexOf(Char) Suche nach einem einzelnen Zeichen veranschaulicht. Die Ligatur "æ" (U+00E6) befindet sich in der Zeichenfolge "aerial", wenn die Konventionen der en-US-Kultur verwendet werden, aber nicht, wenn die Konventionen der da-DK-Kultur verwendet werden oder wenn ein Ordinalvergleich durchgeführt wird.
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
open System.Globalization
let cultureNames = [| "da-DK"; "en-US" |]
let str = "aerial"
let ch = 'æ' // U+00E6
printf "Ordinal comparison -- "
printfn $"Position of '{ch}' in {str}: {str.IndexOf ch}"
for cultureName in cultureNames do
let ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo
printf $"{cultureName} cultural comparison -- "
printfn $"Position of '{ch}' in {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
Imports System.Globalization
Module Example
Public Sub Main()
Dim cultureNames() As String = { "da-DK", "en-US" }
Dim ci As CompareInfo
Dim str As String = "aerial"
Dim ch As Char = "æ"c ' U+00E6
Console.Write("Ordinal comparison -- ")
Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
str.IndexOf(ch))
For Each 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))
Next
End Sub
End Module
' 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
Auf der anderen Seite führen Klassenmethoden, String die nach einer Zeichenfolge anstelle eines Zeichens suchen, eine kulturabhängige Suche durch, wenn Suchoptionen nicht explizit durch einen Parameter vom Typ StringComparisonangegeben werden. Die einzige Ausnahme ist Contains, die eine Ordinalsuche ausführt.
Testen auf Gleichheit
Verwenden Sie die String.Compare -Methode, um die Beziehung von zwei Zeichenfolgen in der Sortierreihenfolge zu bestimmen. In der Regel handelt es sich dabei um einen kulturabhängigen Vorgang. Rufen Sie im Gegensatz dazu die String.Equals -Methode auf, um auf Gleichheit zu testen. Da der Gleichheitstest in der Regel benutzereingaben mit einer bekannten Zeichenfolge wie einem gültigen Benutzernamen, einem Kennwort oder einem Dateisystempfad vergleicht, handelt es sich in der Regel um einen Ordnungsvorgang.
Warnung
Es ist möglich, die Gleichheit zu testen, indem Sie die String.Compare -Methode aufrufen und bestimmen, ob der Rückgabewert 0 ist. Diese Vorgehensweise wird jedoch nicht empfohlen. Um zu bestimmen, ob zwei Zeichenfolgen gleich sind, sollten Sie eine der Überladungen der String.Equals -Methode aufrufen. Die bevorzugte Überladung, die aufgerufen werden soll, ist entweder die instance-Methode Equals(String, StringComparison) oder die statische Equals(String, String, StringComparison) Methode, da beide Methoden einen System.StringComparison Parameter enthalten, der den Typ des Vergleichs explizit angibt.
Das folgende Beispiel veranschaulicht die Gefahr, dass ein kulturabhängiger Vergleich auf Gleichheit durchgeführt wird, wenn stattdessen eine Ordnungszahl verwendet werden soll. In diesem Fall besteht die Absicht des Codes darin, den Dateisystemzugriff von URLs zu verbieten, die mit "FILE://" oder "file://" beginnen, indem ein Vergleich des Anfangs einer URL mit der Zeichenfolge "FILE://" ohne Beachtung der Groß-/Kleinschreibung durchgeführt wird. Wenn jedoch ein kulturabhängiger Vergleich mit der türkischen Kultur (Türkei) für eine URL durchgeführt wird, die mit "file://" beginnt, schlägt der Vergleich auf Gleichheit fehl, da das türkische Großbuchstabenäquivalent des Kleinbuchstabens "i" "İ" anstelle von "I" ist. Daher ist der Zugriff auf das Dateisystem versehentlich zulässig. Wenn dagegen ein Ordinalvergleich durchgeführt wird, ist der Vergleich auf Gleichheit erfolgreich, und der Dateisystemzugriff wird verweigert.
using namespace System;
using namespace System::Globalization;
using namespace System::Threading;
bool TestForEquality(String^ str, StringComparison cmp);
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);
}
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.
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.
open System
open System.Globalization
open System.Threading
let testForEquality (str: string) (cmp: StringComparison) =
let position = str.IndexOf "://"
if position < 0 then false
else
let substring = str.Substring(0, position)
substring.Equals("FILE", cmp)
Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "tr-TR"
let filePath = "file://c:/notes.txt"
printfn "Culture-sensitive test for equality:"
if not (testForEquality filePath StringComparison.CurrentCultureIgnoreCase) then
printfn $"Access to {filePath} is allowed."
else
printfn $"Access to {filePath} is not allowed."
printfn "\nOrdinal test for equality:"
if not (testForEquality filePath StringComparison.OrdinalIgnoreCase) then
printfn $"Access to {filePath} is allowed."
else
printfn $"Access to {filePath} is not allowed."
// 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.
Imports System.Globalization
Imports System.Threading
Module Example
Public Sub Main()
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR")
Dim filePath As String = "file://c:/notes.txt"
Console.WriteLine("Culture-sensitive test for equality:")
If Not TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase) Then
Console.WriteLine("Access to {0} is allowed.", filePath)
Else
Console.WriteLine("Access to {0} is not allowed.", filePath)
End If
Console.WriteLine()
Console.WriteLine("Ordinal test for equality:")
If Not TestForEquality(filePath, StringComparison.OrdinalIgnoreCase) Then
Console.WriteLine("Access to {0} is allowed.", filePath)
Else
Console.WriteLine("Access to {0} is not allowed.", filePath)
End If
End Sub
Private Function TestForEquality(str As String, cmp As StringComparison) As Boolean
Dim position As Integer = str.IndexOf("://")
If position < 0 Then Return False
Dim substring As String = str.Substring(0, position)
Return substring.Equals("FILE", cmp)
End Function
End Module
' The example displays the following output:
' Culture-sensitive test for equality:
' Access to file://c:/notes.txt is allowed.
'
' Ordinal test for equality:
' Access to file://c:/notes.txt is not allowed.
Normalisierung
Einige Unicode-Zeichen verfügen über mehrere Darstellungen. Beispielsweise kann jeder 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 das Suchen, Sortieren, Abgleichen und andere Zeichenfolgenvorgänge.
Der Unicode-Standard definiert einen Prozess namens Normalisierung, der eine binäre Darstellung eines Unicode-Zeichens für eine seiner äquivalenten binären Darstellungen zurückgibt. Bei der Normalisierung können mehrere Algorithmen verwendet werden, die als Normalisierungsformen bezeichnet werden und unterschiedlichen Regeln folgen. .NET unterstützt Unicode-Normalisierungsformen C, D, KC und KD. Wenn Zeichenfolgen in die gleiche Normalisierungsform normalisiert wurden, können sie mithilfe des Ordnungsvergleichs verglichen werden.
Ein Ordnungsvergleich ist ein binärer Vergleich des Unicode-Skalarswerts der entsprechenden Char Objekte in jeder Zeichenfolge. Die String -Klasse enthält eine Reihe von Methoden, die einen Ordinalvergleich durchführen können, einschließlich der folgenden:
Jede Überladung der CompareMethoden , Equals, StartsWith, EndsWith, IndexOfund LastIndexOf , die einen StringComparison Parameter enthält. Die -Methode führt einen Ordnungsvergleich durch, wenn Sie für diesen Parameter einen Wert von StringComparison.Ordinal oder OrdinalIgnoreCase angeben.
Die Überladungen der CompareOrdinal -Methode.
Methoden, die standardmäßig einen Ordnungsvergleich verwenden, z Contains. B. , Replaceund Split.
Methoden, die nach einem Char Wert oder nach den Elementen in einem Char Array in einer Zeichenfolge suchen, instance. Zu diesen Methoden gehören IndexOf(Char) und Split(Char[]).
Sie können bestimmen, ob eine Zeichenfolge mit normalisierter Form C normalisiert wird, indem Sie die -Methode aufrufen, oder Sie können die String.IsNormalized()String.IsNormalized(NormalizationForm) -Methode aufrufen, um zu bestimmen, ob eine Zeichenfolge auf eine angegebene Normalisierungsform normalisiert wird. Sie können auch die String.Normalize() -Methode aufrufen, um eine Zeichenfolge in Normalisierungsform C zu konvertieren, oder Sie können die String.Normalize(NormalizationForm) -Methode aufrufen, um eine Zeichenfolge in ein angegebenes Normalisierungsformular zu konvertieren. Ausführliche Informationen zum Normalisieren und Vergleichen von Zeichenfolgen finden Sie unter den Normalize() Methoden und Normalize(NormalizationForm) .
Im folgenden einfachen Beispiel wird die Zeichenfolgennormalisierung veranschaulicht. Es definiert den Buchstaben "ố" auf drei verschiedene Arten in drei verschiedenen Zeichenfolgen und verwendet einen Ordinalvergleich für Gleichheit, um zu bestimmen, ob sich jede Zeichenfolge von den anderen beiden Zeichenfolgen unterscheidet. Anschließend konvertiert er jede Zeichenfolge in die unterstützten Normalisierungsformulare und führt erneut einen Ordnungszahlvergleich jeder Zeichenfolge in einer angegebenen Normalisierungsform durch. In jedem Fall zeigt der zweite Gleichheitstest, dass die Zeichenfolgen gleich sind.
using namespace System;
using namespace System::Globalization;
using namespace System::IO;
using namespace System::Text;
public ref class Example
{
private:
StreamWriter^ sw;
void TestForEquality(... array<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));
}
String^ ShowBytes(String^ str)
{
String^ result = nullptr;
for each (Char ch in str)
result += String::Format("{0} ", Convert::ToUInt16(ch).ToString("X4"));
return result->Trim();
}
array<String^>^ NormalizeStrings(NormalizationForm nf, ... array<String^>^ words)
{
for (int ctr = 0; ctr < words->Length; ctr++)
if (! words[ctr]->IsNormalized(nf))
words[ctr] = words[ctr]->Normalize(nf);
return words;
}
public:
void Execute()
{
sw = gcnew StreamWriter(".\\TestNorm1.txt");
// Define three versions of the same word.
String^ s1 = L"sống"; // create word with U+1ED1
String^ s2 = L"s\x00F4\x0301ng";
String^ s3 = L"so\x0302\x0301ng";
TestForEquality(s1, s2, s3);
sw->WriteLine();
// Normalize and compare strings using each normalization form.
for each (String^ formName in Enum::GetNames(NormalizationForm::typeid))
{
sw->WriteLine("Normalization {0}:\n", formName);
NormalizationForm nf = (NormalizationForm) Enum::Parse(NormalizationForm::typeid, formName);
array<String^>^ sn = NormalizeStrings(nf, s1, s2, s3 );
TestForEquality(sn);
sw->WriteLine("\n");
}
sw->Close();
}
};
void main()
{
Example^ ex = gcnew Example();
ex->Execute();
}
// The example produces the following output:
// 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
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 += $"{(ushort)ch: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
open System
open System.IO
open System.Text
do
use sw = new StreamWriter(@".\TestNorm1.txt")
let showBytes (str: string) =
let mutable result = ""
for ch in str do
result <- result + $"{uint16 ch:X4} "
result.Trim()
let testForEquality (words: string[]) =
for ctr = 0 to words.Length - 2 do
for ctr2 = ctr + 1 to words.Length - 1 do
sw.WriteLine("{0} ({1}) = {2} ({3}): {4}",
words[ctr], showBytes(words[ctr]),
words[ctr2], showBytes(words[ctr2]),
words[ctr].Equals(words[ctr2], StringComparison.Ordinal))
let normalizeStrings nf (words: string[]) =
for i = 0 to words.Length - 1 do
if not (words[i].IsNormalized nf) then
words[i] <- words[i].Normalize nf
words
// Define three versions of the same word.
let s1 = "sống" // create word with U+1ED1
let s2 = "s\u00F4\u0301ng"
let s3 = "so\u0302\u0301ng"
testForEquality [| s1; s2; s3 |]
sw.WriteLine()
// Normalize and compare strings using each normalization form.
for formName in Enum.GetNames typeof<NormalizationForm> do
sw.WriteLine("Normalization {0}:\n", formName)
let nf = Enum.Parse(typeof<NormalizationForm>, formName) :?> NormalizationForm
let sn = normalizeStrings nf [| s1; s2; s3|]
testForEquality sn
sw.WriteLine "\n"
// 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
Imports System.Globalization
Imports System.IO
Imports System.Text
Module Example
Private sw As StreamWriter
Public Sub Main()
sw = New StreamWriter(".\TestNorm1.txt")
' Define three versions of the same word.
Dim s1 As String = "sống" ' create word with U+1ED1
Dim s2 AS String = "s" + ChrW(&h00F4) + ChrW(&h0301) + "ng"
Dim s3 As String = "so" + ChrW(&h0302) + ChrW(&h0301) + "ng"
TestForEquality(s1, s2, s3)
sw.WriteLine()
' Normalize and compare strings using each normalization form.
For Each formName In [Enum].GetNames(GetType(NormalizationForm))
sw.WriteLine("Normalization {0}:", formName)
Dim nf As NormalizationForm = CType([Enum].Parse(GetType(NormalizationForm), formName),
NormalizationForm)
Dim sn() As String = NormalizeStrings(nf, s1, s2, s3)
TestForEquality(sn)
sw.WriteLine(vbCrLf)
Next
sw.Close()
End Sub
Private Sub TestForEquality(ParamArray words As String())
For ctr As Integer = 0 To words.Length - 2
For ctr2 As Integer = ctr + 1 To words.Length - 1
sw.WriteLine("{0} ({1}) = {2} ({3}): {4}",
words(ctr), ShowBytes(words(ctr)),
words(ctr2), ShowBytes(words(ctr2)),
words(ctr).Equals(words(ctr2), StringComparison.Ordinal))
Next
Next
End Sub
Private Function ShowBytes(str As String) As String
Dim result As String = Nothing
For Each ch In str
result += String.Format("{0} ", Convert.ToUInt16(ch).ToString("X4"))
Next
Return result.Trim()
End Function
Private Function NormalizeStrings(nf As NormalizationForm, ParamArray words() As String) As String()
For ctr As Integer = 0 To words.Length - 1
If Not words(ctr).IsNormalized(nf) Then
words(ctr) = words(ctr).Normalize(nf)
End If
Next
Return words
End Function
End Module
' 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 zu Normalisierungs- und Normalisierungsformularen finden Sie unter System.Text.NormalizationForm, sowie Unicode Standard Annex #15: Unicode Normalization Forms und die häufig gestellten Fragen zur Normalisierung auf der website unicode.org.
Zeichenfolgenvorgänge nach Kategorie
Die String -Klasse stellt Member bereit, um Zeichenfolgen zu vergleichen, Zeichenfolgen auf Gleichheit zu testen, Zeichen oder Teilzeichenfolgen in einer Zeichenfolge zu finden, eine Zeichenfolge zu ändern, Teilzeichenfolgen aus einer Zeichenfolge zu extrahieren, Zeichenfolgen zu kombinieren, Werte zu formatieren, eine Zeichenfolge zu kopieren und eine Zeichenfolge zu normalisieren.
Vergleichen von Zeichenfolgen
Sie können Zeichenfolgen vergleichen, um ihre relative Position in der Sortierreihenfolge mit den folgenden String Methoden zu bestimmen:
Compare gibt eine ganze Zahl zurück, die die Beziehung zwischen einer Zeichenfolge und einer zweiten Zeichenfolge in der Sortierreihenfolge angibt.
CompareOrdinal gibt eine ganze Zahl zurück, die die Beziehung zwischen einer Zeichenfolge und einer zweiten Zeichenfolge basierend auf einem Vergleich ihrer Codepunkte angibt.
CompareTogibt eine ganze Zahl zurück, die die Beziehung der aktuellen Zeichenfolge instance zu einer zweiten Zeichenfolge in der Sortierreihenfolge angibt. Die CompareTo(String) -Methode stellt die IComparable Implementierungen und IComparable<T> für die String -Klasse bereit.
Testen von Zeichenfolgen auf Gleichheit
Sie rufen die Equals -Methode auf, um zu bestimmen, ob zwei Zeichenfolgen gleich sind. Mit den instance Equals(String, String, StringComparison) und den statischen Equals(String, StringComparison) Überladungen können Sie angeben, ob der Vergleich kulturabhängig oder ordnungsabhängig ist und ob Groß-/Kleinschreibung berücksichtigt oder ignoriert wird. Die meisten Gleichheitstests sind Ordnungswerte, und Vergleiche für Gleichheiten, die den Zugriff auf eine Systemressource (z. B. ein Dateisystemobjekt) bestimmen, sollten immer ordnungsal sein.
Suchen von Zeichen in einer Zeichenfolge
Die String -Klasse enthält zwei Arten von Suchmethoden:
Methoden, die einen Boolean Wert zurückgeben, um anzugeben, ob eine bestimmte Teilzeichenfolge in einer Zeichenfolge instance vorhanden ist. Dazu gehören die ContainsMethoden , EndsWithund StartsWith .
Methoden, die die Anfangsposition einer Teilzeichenfolge in einer Zeichenfolge instance angeben. Dazu gehören die IndexOfMethoden , IndexOfAny, LastIndexOfund LastIndexOfAny .
Warnung
Wenn Sie eine Zeichenfolge nach einem bestimmten Muster und nicht nach einer bestimmten Teilzeichenfolge durchsuchen möchten, sollten Sie reguläre Ausdrücke verwenden. Weitere Informationen finden Sie unter Reguläre .NET-Ausdrücke.
Ändern einer Zeichenfolge
Die String -Klasse enthält die folgenden Methoden, die den Wert einer Zeichenfolge zu ändern scheinen:
Insertfügt eine Zeichenfolge in die aktuelle String instance ein.
PadLeft fügt ein oder mehrere Vorkommen eines angegebenen Zeichens am Anfang einer Zeichenfolge ein.
PadRight fügt ein oder mehrere Vorkommen eines angegebenen Zeichens am Ende einer Zeichenfolge ein.
Removelöscht eine Teilzeichenfolge aus dem aktuellen String instance.
Replaceersetzt eine Teilzeichenfolge durch eine andere Teilzeichenfolge im aktuellen String instance.
ToLower und ToLowerInvariant konvertieren alle Zeichen in einer Zeichenfolge in Kleinbuchstaben.
ToUpper und ToUpperInvariant konvertieren alle Zeichen in einer Zeichenfolge in Großbuchstaben.
Trim entfernt alle Vorkommen eines Zeichens vom Anfang und Ende einer Zeichenfolge.
TrimEnd entfernt alle Vorkommen eines Zeichens am Ende einer Zeichenfolge.
TrimStart entfernt alle Vorkommen eines Zeichens vom Anfang einer Zeichenfolge.
Wichtig
Alle Zeichenfolgenänderungsmethoden geben ein neues String Objekt zurück. Der Wert des aktuellen instance wird nicht geändert.
Extrahieren von Teilzeichenfolgen aus einer Zeichenfolge
Die String.Split -Methode trennt eine einzelne Zeichenfolge in mehrere Zeichenfolgen. Überladungen der -Methode ermöglichen es Ihnen, mehrere Trennzeichen anzugeben, die Anzahl der Teilzeichenfolgen zu begrenzen, die die Methode extrahiert, Leerzeichen von Teilzeichenfolgen zu kürzen und anzugeben, ob leere Zeichenfolgen (die auftreten, wenn Trennzeichen nebeneinander liegen) unter den zurückgegebenen Zeichenfolgen enthalten sind.
Kombinieren von Zeichenfolgen
Die folgenden String Methoden können für die Zeichenfolgenverkettung verwendet werden:
Concat kombiniert eine oder mehrere Teilzeichenfolgen in einer einzelnen Zeichenfolge.
Join Verkettet eine oder mehrere Teilzeichenfolgen zu einem einzelnen Element und fügt zwischen jeder Teilzeichenfolge ein Trennzeichen hinzu.
Formatieren von Werten
Die String.Format -Methode verwendet die zusammengesetzte Formatierungsfunktion, um einen oder mehrere Platzhalter in einer Zeichenfolge durch die Zeichenfolgendarstellung eines Objekts oder Werts zu ersetzen. Die Format -Methode wird häufig für folgende Aktionen verwendet:
So betten Sie die Zeichenfolgendarstellung eines numerischen Werts in eine Zeichenfolge ein.
So betten Sie die Zeichenfolgendarstellung eines Datums- und Uhrzeitwerts in eine Zeichenfolge ein.
So betten Sie die Zeichenfolgendarstellung eines Enumerationswerts in eine Zeichenfolge ein.
So betten Sie die Zeichenfolgendarstellung eines Objekts ein, das die IFormattable Schnittstelle in einer Zeichenfolge unterstützt.
Um eine Teilzeichenfolge in einem Feld innerhalb einer größeren Zeichenfolge nach rechts oder links zu rechtfertigen.
Ausführliche Informationen zu Formatierungsvorgängen und Beispielen finden Sie in der Überladungszusammenfassung Format .
Kopieren einer Zeichenfolge
Sie können die folgenden String Methoden aufrufen, um eine Kopie einer Zeichenfolge zu erstellen:
Clone gibt einen Verweis auf ein vorhandenes String -Objekt zurück.
Copy erstellt eine Kopie einer vorhandenen Zeichenfolge.
CopyTo kopiert einen Teil einer Zeichenfolge in ein Zeichenarray.
Normalisieren einer Zeichenfolge
In Unicode kann ein einzelnes Zeichen mehrere Codepunkte aufweisen. Bei der Normalisierung werden diese äquivalenten Zeichen in dieselbe binäre Darstellung konvertiert. Die String.Normalize -Methode führt die Normalisierung durch, und die String.IsNormalized -Methode bestimmt, ob eine Zeichenfolge normalisiert wird.
Weitere Informationen und ein Beispiel finden Sie weiter oben in diesem Thema im Abschnitt Normalisierung .
Konstruktoren
| String(Char*) |
Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch einen angegebenen Zeiger auf ein Array von Unicode-Zeichen bestimmt wird. |
| String(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. |
| String(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. |
| String(Char[]) |
Initialisiert eine neue Instanz der String-Klasse mit den im angegebenen Zeichenarray genannten Unicode-Zeichen. |
| String(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. |
| String(ReadOnlySpan<Char>) |
Initialisiert eine neue Instanz der String-Klasse mit den im angegebenen schreibgeschützten Bereich genannten Unicode-Zeichen. |
| String(SByte*) |
Initialisiert eine neue Instanz der String-Klasse mit dem durch einen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen angegebenen Wert. |
| String(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. |
| String(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. |
Felder
| Empty |
Stellt die leere Zeichenfolge dar. Dieses Feld ist schreibgeschützt. |
Eigenschaften
| Chars[Int32] |
Ruft das Char-Objekt an einer angegebenen Zeichenposition innerhalb des aktuellen String-Objekts ab. |
| Length |
Ruft die Anzahl der Zeichen im aktuellen String-Objekt ab. |
Methoden
| Clone() |
Gibt einen Verweis auf diese Instanz von Stringzurück. |
| Compare(String, Int32, String, Int32, Int32) |
Vergleicht zwei angegebene String-Objekte und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt. |
| Compare(String, Int32, String, Int32, Int32, Boolean) |
Vergleicht Teilzeichenfolgen von zwei angegebenen String-Objekten, wobei ihre Groß- und Kleinschreibung entweder ignoriert oder berücksichtigt wird, und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt. |
| Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) |
Vergleicht Teilzeichenfolgen von zwei angegebenen String-Objekten, wobei ihre Groß- und Kleinschreibung entweder ignoriert oder berücksichtigt und der Vergleich durch kulturspezifische Informationen beeinflusst wird, und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt. |
| Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) |
Vergleicht Teilzeichenfolgen von zwei angegebenen String-Objekten mit den festgelegten Vergleichsoptionen und kulturspezifischen Informationen, die den Vergleich beeinflussen, und gibt eine ganze Zahl zurück, die die Beziehung der beiden Teilzeichenfolgen zueinander in der Sortierreihenfolge angibt. |
| Compare(String, Int32, String, Int32, Int32, StringComparison) |
Vergleicht Teilzeichenfolgen von zwei angegebenen String-Objekten gemäß den angegebenen Vergleichsregeln und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt. |
| Compare(String, String) |
Vergleicht zwei angegebene String-Objekte und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt. |
| Compare(String, String, Boolean) |
Vergleicht zwei angegebene String-Objekte, wobei ihre Groß- und Kleinschreibung entweder ignoriert oder berücksichtigt wird, und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt. |
| Compare(String, String, Boolean, CultureInfo) |
Vergleicht zwei angegebene String-Objekte, wobei ihre Groß- und Kleinschreibung entweder ignoriert oder berücksichtigt und der Vergleich durch kulturspezifische Informationen beeinflusst wird, und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt. |
| Compare(String, String, CultureInfo, CompareOptions) |
Vergleicht zwei angegebene String-Objekte mit den festgelegten Vergleichsoptionen und kulturspezifischen Informationen, die den Vergleich beeinflussen, und gibt eine ganze Zahl zurück, die die Beziehung der beiden Zeichenfolgen zueinander in der Sortierreihenfolge angibt. |
| Compare(String, String, StringComparison) |
Vergleicht zwei angegebene String-Objekte gemäß den angegebenen Vergleichsregeln und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt. |
| CompareOrdinal(String, Int32, String, Int32, Int32) |
Vergleicht Teilzeichenfolgen zweier angegebener String-Objekte, indem die numerischen Werte der entsprechenden Char-Objekte in den Teilzeichenfolgen ausgewertet werden. |
| CompareOrdinal(String, String) |
Vergleicht zwei String-Objekte, indem die numerischen Werte der entsprechenden Char-Objekte in den Zeichenfolgen ausgewertet werden. |
| CompareTo(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. |
| CompareTo(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. |
| Concat(IEnumerable<String>) |
Verkettet die Member einer erstellten IEnumerable<T>-Auflistung vom Typ String. |
| Concat(Object) |
Erstellt die Zeichenfolgendarstellung eines angegebenen -Objekts. |
| Concat(Object, Object) |
Verkettet die Zeichenfolgendarstellungen zweier angegebener Objekte. |
| Concat(Object, Object, Object) |
Verkettet die Zeichenfolgendarstellungen von drei angegebenen Objekten. |
| Concat(Object, Object, Object, Object) |
Verkettet die Zeichenfolgenentsprechungen von vier angegebenen Objekten sowie aller in einer optionalen Parameterliste variabler Länger angegebenen Objekte. |
| Concat(Object[]) |
Verkettet die Zeichenfolgendarstellungen der Elemente in einem angegebenen Object-Array. |
| Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>) |
Verkettet die Zeichenfolgendarstellung von zwei angegebenen schreibgeschützten Zeichenspannen. |
| Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) |
Verkettet die Zeichenfolgendarstellung von drei angegebenen schreibgeschützten Zeichenspannen. |
| Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) |
Verkettet die Zeichenfolgendarstellung von vier angegebenen schreibgeschützten Zeichenspannen. |
| Concat(String, String) |
Verkettet zwei angegebene Instanzen von String. |
| Concat(String, String, String) |
Verkettet zwei angegebene Instanzen von String. |
| Concat(String, String, String, String) |
Verkettet zwei angegebene Instanzen von String. |
| Concat(String[]) |
Verkettet die Elemente eines angegebenen String-Arrays. |
| Concat<T>(IEnumerable<T>) |
Verkettet die Member einer IEnumerable<T>-Implementierung. |
| Contains(Char) |
Gibt einen Wert zurück, der angibt, ob ein angegebenes Zeichen in dieser Zeichenfolge vorkommt. |
| Contains(Char, StringComparison) |
Gibt mithilfe der festgelegten Vergleichsregeln einen Wert zurück, der angibt, ob ein angegebenes Zeichen innerhalb der Zeichenfolge auftritt. |
| Contains(String) |
Gibt einen Wert zurück, der angibt, ob eine angegebene untergeordnete Zeichenfolge in dieser Zeichenfolge vorkommt. |
| Contains(String, StringComparison) |
Gibt mithilfe der festgelegten Vergleichsregeln einen Wert zurück, der angibt, ob eine angegebene Zeichenfolge innerhalb der Zeichenfolge auftritt. |
| Copy(String) |
Veraltet.
Erstellt eine neue Instanz von String mit demselben Wert wie eine angegebene Instanz von String. |
| CopyTo(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. |
| CopyTo(Span<Char>) |
Kopiert den Inhalt dieser Zeichenfolge in die Zielspanne. |
| Create(IFormatProvider, DefaultInterpolatedStringHandler) |
Erstellt eine neue Zeichenfolge mithilfe des angegebenen Anbieters, um die Formatierung der angegebenen interpolierten Zeichenfolge zu steuern. |
| Create(IFormatProvider, Span<Char>, DefaultInterpolatedStringHandler) |
Erstellt eine neue Zeichenfolge mithilfe des angegebenen Anbieters, um die Formatierung der angegebenen interpolierten Zeichenfolge zu steuern. |
| Create<TState>(Int32, TState, SpanAction<Char,TState>) |
Erstellt eine neue Zeichenfolge mit einer bestimmten Länge und initialisiert sie nach der Erstellung unter Verwendung des angegebenen Rückrufs. |
| EndsWith(Char) |
Bestimmt, ob das Ende dieser Zeichenfolgeninstanz mit dem angegebenen Zeichen übereinstimmt. |
| EndsWith(String) |
Bestimmt, ob das Ende dieser Zeichenfolgeninstanz mit der angegebenen Zeichenfolge übereinstimmt. |
| EndsWith(String, Boolean, CultureInfo) |
Bestimmt, ob das Ende dieser Zeichenfolgeninstanz bei einem Vergleich unter Verwendung der angegebenen Kultur mit der angegebenen Zeichenfolge übereinstimmt. |
| EndsWith(String, StringComparison) |
Bestimmt, ob das Ende dieser Zeichenfolgeninstanz bei einem Vergleich unter Verwendung der angegebenen Vergleichsoption mit der angegebenen Zeichenfolge übereinstimmt. |
| EnumerateRunes() |
Gibt eine Enumeration von Rune aus der Zeichenfolge zurück. |
| Equals(Object) |
Bestimmt, ob diese Instanz und ein angegebenes Objekt, das ebenfalls ein String-Objekt sein muss, denselben Wert haben. |
| Equals(String) |
Bestimmt, ob diese Instanz und ein anderes angegebenes String-Objekt denselben Wert haben. |
| Equals(String, String) |
Bestimmt, ob zwei angegebene String-Objekte denselben Wert haben. |
| Equals(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. |
| Equals(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. |
| Format(IFormatProvider, CompositeFormat, Object[]) |
Ersetzt das Formatelement(n) in einem CompositeFormat durch die Zeichenfolgendarstellung der entsprechenden Objekte im angegebenen Format. |
| Format(IFormatProvider, CompositeFormat, ReadOnlySpan<Object>) |
Ersetzt das Formatelement(n) in einem CompositeFormat durch die Zeichenfolgendarstellung der entsprechenden Objekte im angegebenen Format. |
| Format(IFormatProvider, String, Object) |
Ersetzt die Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung des angegebenen Objekts. Ein Parameter liefert kulturspezifische Formatierungsinformationen. |
| Format(IFormatProvider, String, Object, Object) |
Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von zwei angegebenen Objekten. Ein Parameter liefert kulturspezifische Formatierungsinformationen. |
| Format(IFormatProvider, String, Object, Object, Object) |
Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von drei angegebenen Objekten. Ein Parameter liefert kulturspezifische Formatierungsinformationen. |
| Format(IFormatProvider, String, Object[]) |
Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellungen entsprechender Objekte in einem angegebenen Array. Ein Parameter liefert kulturspezifische Formatierungsinformationen. |
| Format(String, Object) |
Ersetzt mindestens ein Formatelement in einer Zeichenfolge durch die Zeichenfolgendarstellung eines angegebenen Objekts. |
| Format(String, Object, Object) |
Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von zwei angegebenen Objekten. |
| Format(String, Object, Object, Object) |
Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von drei angegebenen Objekten. |
| Format(String, Object[]) |
Ersetzt das Formatelement in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung eines entsprechenden Objekts in einem angegebenen Array. |
| Format<TArg0,TArg1,TArg2>(IFormatProvider, CompositeFormat, TArg0, TArg1, TArg2) |
Ersetzt das Formatelement(n) in einem CompositeFormat durch die Zeichenfolgendarstellung der entsprechenden Objekte im angegebenen Format. |
| Format<TArg0,TArg1>(IFormatProvider, CompositeFormat, TArg0, TArg1) |
Ersetzt das Formatelement(n) in einem CompositeFormat durch die Zeichenfolgendarstellung der entsprechenden Objekte im angegebenen Format. |
| Format<TArg0>(IFormatProvider, CompositeFormat, TArg0) |
Ersetzt das Formatelement(n) in einem CompositeFormat durch die Zeichenfolgendarstellung der entsprechenden Objekte im angegebenen Format. |
| GetEnumerator() |
Ruft ein Objekt ab, das die einzelnen Zeichen dieser Zeichenfolge durchlaufen kann. |
| GetHashCode() |
Gibt den Hashcode für diese Zeichenfolge zurück. |
| GetHashCode(ReadOnlySpan<Char>) |
Gibt den Hashcode für die angegebene schreibgeschützte Zeichenspanne zurück. |
| GetHashCode(ReadOnlySpan<Char>, StringComparison) |
Gibt den Hashcode für die angegebene schreibgeschützte Zeichenspanne gemäß der festgelegten Regeln zurück. |
| GetHashCode(StringComparison) |
Gibt den Hashcode für diese Zeichenfolge gemäß der festgelegten Regeln zurück. |
| GetPinnableReference() |
Gibt einen Verweis auf das Element der Zeichenfolge zurück, das sich bei Index 0 befindet. Diese Methode dient zur Unterstützung von .NET-Compilern und ist nicht für den Aufruf durch Benutzercode vorgesehen. |
| GetType() |
Ruft den Type der aktuellen Instanz ab. (Geerbt von Object) |
| GetTypeCode() | |
| IndexOf(Char) |
Gibt den NULL-basierten Index des ersten Vorkommens des angegebenen Unicode-Zeichens in dieser Zeichenfolge an. |
| IndexOf(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. |
| IndexOf(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. |
| IndexOf(Char, StringComparison) |
Gibt den NULL-basierten Index des ersten Vorkommens des angegebenen Unicode-Zeichens in dieser Zeichenfolge an. Ein Parameter gibt den Typ der Suche für das angegebene Zeichen an. |
| IndexOf(String) |
Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge in dieser Instanz an. |
| IndexOf(String, Int32) |
Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition. |
| IndexOf(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. |
| IndexOf(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. |
| IndexOf(String, Int32, StringComparison) |
Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge im aktuellen String-Objekt an. Parameter geben die Anfangssuchposition in der aktuellen Zeichenfolge und den Typ der Suche an, die für die angegebene Zeichenfolge verwendet werden soll. |
| IndexOf(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. |
| IndexOfAny(Char[]) |
Gibt den NULL-basierten Index des ersten Vorkommens eines beliebigen Zeichens aus einem angegebenen Array von Unicode-Zeichen in dieser Instanz an. |
| IndexOfAny(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. |
| IndexOfAny(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. |
| Insert(Int32, String) |
Gibt eine neue Zeichenfolge zurück, in der eine angegebene Zeichenfolge an einer angegebenen Indexposition in dieser Instanz eingefügt wird. |
| Intern(String) |
Ruft den Verweis des Systems auf den angegebenen String ab. |
| IsInterned(String) |
Ruft einen Verweis auf einen angegebenen String ab. |
| IsNormalized() |
Gibt an, ob diese Zeichenfolge in der Unicode-Normalisierungsform C vorliegt. |
| IsNormalized(NormalizationForm) |
Gibt an, ob diese Zeichenfolge in der angegebenen Unicode-Normalisierungsform vorliegt. |
| IsNullOrEmpty(String) |
Gibt an, ob die angegebene Zeichenfolge |
| IsNullOrWhiteSpace(String) |
Gibt an, ob eine angegebene Zeichenfolge |
| Join(Char, Object[]) |
Verwendet die Zeichenfolgendarstellungen eines Objektarrays mithilfe der angegebenen Trennlinie zwischen den einzelnen Elementen. |
| Join(Char, String[]) |
Verkettet ein Zeichenfolgenarray mithilfe der angegebenen Trennlinie zwischen den einzelnen Elementen. |
| Join(Char, String[], Int32, Int32) |
Verkettet ein Zeichenfolgenarray mithilfe der angegebenen Trennlinie zwischen den einzelnen Elementen. Dabei beginnt das Array mit dem Element in |
| Join(String, IEnumerable<String>) |
Verkettet die Member einer erstellten IEnumerable<T>-Auflistung vom Typ String und verwendet das angegebene Trennzeichen zwischen den einzelnen Membern. |
| Join(String, Object[]) |
Verkettet die Elemente eines Objektarrays und verwendet das angegebene Trennzeichen zwischen den einzelnen Elementen. |
| Join(String, String[]) |
Verkettet alle Elemente eines Zeichenfolgenarrays und verwendet das angegebene Trennzeichen zwischen den einzelnen Elementen. |
| Join(String, String[], Int32, Int32) |
Verkettet die angegebenen Elemente eines Zeichenfolgenarrays und verwendet das angegebene Trennzeichen zwischen den einzelnen Elementen. |
| Join<T>(Char, IEnumerable<T>) |
Verkettet die Member einer Auflistung und verwendet das angegebene Trennzeichen zwischen den einzelnen Membern. |
| Join<T>(String, IEnumerable<T>) |
Verkettet die Member einer Auflistung und verwendet das angegebene Trennzeichen zwischen den einzelnen Membern. |
| LastIndexOf(Char) |
Gibt die NULL-basierte Indexposition des letzten Vorkommens eines angegebenen Unicode-Zeichens in dieser Instanz an. |
| LastIndexOf(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. |
| LastIndexOf(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. |
| LastIndexOf(String) |
Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an. |
| LastIndexOf(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. |
| LastIndexOf(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. |
| LastIndexOf(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. |
| LastIndexOf(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. |
| LastIndexOf(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. |
| LastIndexOfAny(Char[]) |
Gibt die NULL-basierte Indexposition des letzten Vorkommens eines oder mehrerer angegebener Zeichen eines Unicode-Arrays in dieser Instanz an. |
| LastIndexOfAny(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. |
| LastIndexOfAny(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. |
| MemberwiseClone() |
Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object) |
| Normalize() |
Gibt eine neue Zeichenfolge zurück, deren Textwert mit dieser Zeichenfolge übereinstimmt, deren binäre Darstellung jedoch in der Unicode-Normalisierungsform C vorliegt. |
| Normalize(NormalizationForm) |
Gibt eine neue Zeichenfolge zurück, deren Textwert mit dieser Zeichenfolge übereinstimmt, deren binäre Darstellung jedoch in der angegebenen Unicode-Normalisierungsform vorliegt. |
| PadLeft(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. |
| PadLeft(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. |
| PadRight(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. |
| PadRight(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. |
| Remove(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. |
| Remove(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. |
| Replace(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. |
| Replace(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. |
| Replace(String, String, Boolean, CultureInfo) |
Gibt mithilfe der angegebenen Kultur und der Angabe zur Groß-/Kleinschreibung eine neue Zeichenfolge zurück, in der alle Vorkommen einer angegebenen Zeichenfolge in der aktuellen Instanz durch eine andere angegebene Zeichenfolge ersetzt wurden. |
| Replace(String, String, StringComparison) |
Gibt mithilfe des bereitgestellten Vergleichstyps eine neue Zeichenfolge zurück, in der alle Vorkommen einer angegebenen Zeichenfolge in der aktuellen Instanz durch eine andere angegebene Zeichenfolge ersetzt wurden. |
| ReplaceLineEndings() |
Ersetzt alle Zeilenumbruchsequenzen in der aktuellen Zeichenfolge durch NewLine. |
| ReplaceLineEndings(String) |
Ersetzt alle Zeilenumbruchsequenzen in der aktuellen Zeichenfolge durch |
| Split(Char, Int32, StringSplitOptions) |
Hier wird eine Zeichenfolge anhand eines angegebenen Trennzeichens und optional von Optionen in die maximale Anzahl von Teilzeichenfolgen unterteilt. Hier wird eine Zeichenfolge in eine maximale Anzahl von Teilzeichenfolgen anhand des angegebenen Ersatztrennzeichens unterteilt, wobei optional leere Teilzeichenfolgen aus dem Ergebnis ausgelassen werden. |
| Split(Char, StringSplitOptions) |
Hier wird eine Zeichenfolge anhand eines angegebenen Trennzeichens und optional von Optionen in Teilzeichenfolgen unterteilt. |
| Split(Char[]) |
Hier wird eine Zeichenfolge anhand der angegebenen Trennzeichen in Teilzeichenfolgen unterteilt. |
| Split(Char[], Int32) |
Hier wird eine Zeichenfolge anhand der angegebenen Trennzeichen in eine maximale Anzahl von Teilzeichenfolgen unterteilt. |
| Split(Char[], Int32, StringSplitOptions) |
Hier wird eine Zeichenfolge anhand von angegebenen Trennzeichen und optional von Optionen in die maximale Anzahl von Teilzeichenfolgen unterteilt. |
| Split(Char[], StringSplitOptions) |
Hier wird eine Zeichenfolge anhand der angegebenen Trennzeichen und der Optionen in Teilzeichenfolgen unterteilt. |
| Split(String, Int32, StringSplitOptions) |
Hier wird eine Zeichenfolge anhand einer angegebenen Trennzeichenfolge und optional von Optionen in die maximale Anzahl von Teilzeichenfolgen unterteilt. |
| Split(String, StringSplitOptions) |
Unterteilt eine Zeichenfolge anhand der angegebenen Zeichenfolgentrennlinie in Teilzeichenfolgen. |
| Split(String[], Int32, StringSplitOptions) |
Hier wird eine Zeichenfolge anhand von angegebenen Trennzeichenfolgen und optional von Optionen in die maximale Anzahl von Teilzeichenfolgen unterteilt. |
| Split(String[], StringSplitOptions) |
Hier wird eine Zeichenfolge anhand einer angegebenen Trennzeichenfolge und optional von Optionen in Teilzeichenfolgen unterteilt. |
| StartsWith(Char) |
Bestimmt, ob diese Zeichenfolgeninstanz mit dem angegebenen Zeichen beginnt. |
| StartsWith(String) |
Bestimmt, ob der Anfang dieser Zeichenfolgeninstanz mit der angegebenen Zeichenfolge übereinstimmt. |
| StartsWith(String, Boolean, CultureInfo) |
Bestimmt, ob der Anfang dieser Zeichenfolgeninstanz bei einem Vergleich unter Verwendung der angegebenen Kultur mit der angegebenen Zeichenfolge übereinstimmt. |
| StartsWith(String, StringComparison) |
Bestimmt, ob der Anfang dieser Zeichenfolgeninstanz bei einem Vergleich unter Verwendung der angegebenen Vergleichsoption mit der angegebenen Zeichenfolge übereinstimmt. |
| Substring(Int32) |
Ruft eine Teilzeichenfolge dieser Instanz ab. Die untergeordnete Zeichenfolge beginnt in einer angegebenen Zeichenposition und wird an das Ende der Zeichenfolge fortgesetzt. |
| Substring(Int32, Int32) |
Ruft eine Teilzeichenfolge dieser Instanz ab. Die Teilzeichenfolge beginnt an einer angegebenen Zeichenposition und hat eine angegebene Länge. |
| ToCharArray() |
Kopiert die Zeichen dieser Instanz in ein Array von Unicode-Zeichen. |
| ToCharArray(Int32, Int32) |
Kopiert die Zeichen einer angegebenen Teilzeichenfolge dieser Instanz in ein Array von Unicode-Zeichen. |
| ToLower() |
Gibt eine in Kleinbuchstaben konvertierte Kopie dieser Zeichenfolge zurück. |
| ToLower(CultureInfo) |
Gibt eine in Kleinbuchstaben konvertierte Kopie dieser Zeichenfolge zurück, wobei die Regeln der Groß- und Kleinschreibung der angegebenen Kultur verwendet werden. |
| ToLowerInvariant() |
Gibt eine in Kleinbuchstaben konvertierte Kopie dieses String -Objekts zurück, wobei die Regeln der Groß- und Kleinschreibung der invarianten Kultur verwendet werden. |
| ToString() |
Gibt diese Instanz von String zurück. Es wird keine wirkliche Konvertierung durchgeführt. |
| ToString(IFormatProvider) |
Gibt diese Instanz von String zurück. Es wird keine wirkliche Konvertierung durchgeführt. |
| ToUpper() |
Gibt eine in Großbuchstaben konvertierte Kopie dieser Zeichenfolge zurück. |
| ToUpper(CultureInfo) |
Gibt eine in Großbuchstaben konvertierte Kopie dieser Zeichenfolge zurück, wobei die Regeln der Groß- und Kleinschreibung der angegebenen Kultur verwendet werden. |
| ToUpperInvariant() |
Gibt eine in Großbuchstaben konvertierte Kopie dieses String -Objekts zurück, wobei die Regeln der Groß- und Kleinschreibung der invarianten Kultur verwendet werden. |
| Trim() |
Entfernt alle führenden und nachgestellten Leerraumzeichen aus der aktuellen Zeichenfolge. |
| Trim(Char) |
Entfernt alle führenden und nachgestellten Instanzen eines Zeichens aus der aktuellen Zeichenfolge. |
| Trim(Char[]) |
Entfernt alle führenden und nachgestellten Vorkommen der Zeichen im angegebenen Array aus der aktuellen Zeichenfolge. |
| TrimEnd() |
Entfernt alle nachgestellten Leerraumzeichen aus der aktuellen Zeichenfolge. |
| TrimEnd(Char) |
Entfernt alle nachgestellten Vorkommen eines Zeichens aus der aktuellen Zeichenfolge. |
| TrimEnd(Char[]) |
Entfernt alle nachgestellten Vorkommen der Zeichen im angegebenen Array aus der aktuellen Zeichenfolge. |
| TrimStart() |
Entfernt alle führenden Leerraumzeichen aus der aktuellen Zeichenfolge. |
| TrimStart(Char) |
Entfernt alle führenden Vorkommen eines bestimmten Zeichens aus der aktuellen Zeichenfolge. |
| TrimStart(Char[]) |
Entfernt alle führenden Vorkommen der Zeichen im angegebenen Array aus der aktuellen Zeichenfolge. |
| TryCopyTo(Span<Char>) |
Kopiert den Inhalt dieser Zeichenfolge in die Zielspanne. |
Operatoren
| Equality(String, String) |
Bestimmt, ob zwei angegebene Zeichenfolgen denselben Wert haben. |
| Implicit(String to ReadOnlySpan<Char>) |
Definiert eine implizite Konvertierung einer angegebenen Zeichenfolge in einen schreibgeschützten Zeichenbereich. |
| Inequality(String, String) |
Bestimmt, ob zwei angegebene Zeichenfolgen verschiedene Werte haben. |
Explizite Schnittstellenimplementierungen
| IComparable.CompareTo(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. |
| IConvertible.GetTypeCode() | |
| IConvertible.ToBoolean(IFormatProvider) |
Eine Beschreibung dieses Elements finden Sie unter ToBoolean(IFormatProvider). |
| IConvertible.ToByte(IFormatProvider) |
Eine Beschreibung dieses Elements finden Sie unter ToByte(IFormatProvider). |
| IConvertible.ToChar(IFormatProvider) |
Eine Beschreibung dieses Elements finden Sie unter ToChar(IFormatProvider). |
| IConvertible.ToDateTime(IFormatProvider) |
Eine Beschreibung dieses Elements finden Sie unter ToDateTime(IFormatProvider). |
| IConvertible.ToDecimal(IFormatProvider) |
Eine Beschreibung dieses Elements finden Sie unter ToDecimal(IFormatProvider). |
| IConvertible.ToDouble(IFormatProvider) |
Eine Beschreibung dieses Elements finden Sie unter ToDouble(IFormatProvider). |
| IConvertible.ToInt16(IFormatProvider) |
Eine Beschreibung dieses Elements finden Sie unter ToInt16(IFormatProvider). |
| IConvertible.ToInt32(IFormatProvider) |
Eine Beschreibung dieses Elements finden Sie unter ToInt32(IFormatProvider). |
| IConvertible.ToInt64(IFormatProvider) |
Eine Beschreibung dieses Elements finden Sie unter ToInt64(IFormatProvider). |
| IConvertible.ToSByte(IFormatProvider) |
Eine Beschreibung dieses Elements finden Sie unter ToSByte(IFormatProvider). |
| IConvertible.ToSingle(IFormatProvider) |
Eine Beschreibung dieses Elements finden Sie unter ToSingle(IFormatProvider). |
| IConvertible.ToString(IFormatProvider) |
Eine Beschreibung dieses Elements finden Sie unter ToString(IFormatProvider). |
| IConvertible.ToType(Type, IFormatProvider) |
Eine Beschreibung dieses Elements finden Sie unter ToType(Type, IFormatProvider). |
| IConvertible.ToUInt16(IFormatProvider) |
Eine Beschreibung dieses Elements finden Sie unter ToUInt16(IFormatProvider). |
| IConvertible.ToUInt32(IFormatProvider) |
Eine Beschreibung dieses Elements finden Sie unter ToUInt32(IFormatProvider). |
| IConvertible.ToUInt64(IFormatProvider) |
Eine Beschreibung dieses Elements finden Sie unter ToUInt64(IFormatProvider). |
| IEnumerable.GetEnumerator() |
Gibt einen Enumerator zurück, der das aktuelle String-Objekt durchläuft. |
| IEnumerable<Char>.GetEnumerator() |
Gibt einen Enumerator zurück, der das aktuelle String-Objekt durchläuft. |
| IParsable<String>.Parse(String, IFormatProvider) |
Analysiert eine Zeichenfolge in einen Wert. |
| IParsable<String>.TryParse(String, IFormatProvider, String) |
Stellt Text als Sequenz von UTF-16-Codeeinheiten dar. |
| ISpanParsable<String>.Parse(ReadOnlySpan<Char>, IFormatProvider) |
Analysiert eine Spanne von Zeichen in einen Wert. |
| ISpanParsable<String>.TryParse(ReadOnlySpan<Char>, IFormatProvider, String) |
Stellt Text als Sequenz von UTF-16-Codeeinheiten dar. |
Erweiterungsmethoden
| ToFrozenDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Erstellt eine FrozenDictionary<TKey,TValue> aus einer IEnumerable<T> entsprechend der angegebenen Schlüsselauswahlfunktion. |
| ToFrozenDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) |
Erstellt ein FrozenDictionary<TKey,TValue> aus einem IEnumerable<T> entsprechend der angegebenen Schlüsselauswahlfunktion und Elementauswahlfunktion |
| ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>) |
Erstellt eine FrozenSet<T> mit den angegebenen Werten. |
| ToImmutableArray<TSource>(IEnumerable<TSource>) |
Erstellt ein unveränderliches Array aus der angegebenen Auflistung. |
| ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Erstellt ein unveränderliches Wörterbuch aus einer bestehenden Kollektion von Elementen, mit der Anwendung einer Transformationsfunktion zum Quellschlüssel. |
| ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Erstellt ein unveränderliches Wörterbuch basierend auf einer Sequenztransformation. |
| ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) |
Listet eine Sequenz auf und transformiert sie; und erzeugt ein unveränderliches Wörterbuch ihrer Inhalte. |
| ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>) |
Listet eine Sequenz auf und transformiert sie; und erzeugt mithilfe des angegebenen Schlüsselvergleichs ein unveränderliches Wörterbuch ihrer Inhalte. |
| ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>) |
Listet eine Sequenz auf und transformiert sie; und erzeugt mithilfe des angegebenen Schlüssel- und Wertevergleichs ein unveränderliches Wörterbuch ihrer Inhalte. |
| ToImmutableHashSet<TSource>(IEnumerable<TSource>) |
Listet eine Sequenz auf und erzeugt ein unveränderliches Hashset ihrer Inhalte. |
| ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) |
Listet eine Sequenz auf, erzeugt ein unveränderliches Hashset ihres Inhalts und verwendet den angegebenen Gleichheitsvergleich für den Settyp. |
| ToImmutableList<TSource>(IEnumerable<TSource>) |
Listet eine Sequenz auf und erzeugt eine unveränderliche Liste ihrer Inhalte. |
| ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) |
Listet eine Sequenz auf, transformiert sie und erzeugt ein unveränderliches sortiertes Wörterbuch ihrer Inhalte. |
| ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>) |
Listet eine Sequenz auf, transformiert sie und erzeugt mithilfe des angegebenen Schlüsselvergleichs ein unveränderliches sortiertes Wörterbuch ihrer Inhalte. |
| ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>) |
Listet eine Sequenz auf, transformiert sie und erzeugt mithilfe des angegebenen Schlüssel- und Wertevergleichs ein unveränderliches sortiertes Wörterbuch ihrer Inhalte. |
| ToImmutableSortedSet<TSource>(IEnumerable<TSource>) |
Listet eine Sequenz auf und erzeugt ein unveränderlich sortierte Gruppe ihrer Inhalte. |
| ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>) |
Listet eine Sequenz auf, erzeugt ein unveränderlich sortierte Gruppe ihrer Inhalte und verwendet den angegeben Vergleich. |
| CopyToDataTable<T>(IEnumerable<T>) |
Gibt eine DataTable zurück, die Kopien der DataRow-Objekte enthält, wenn ein IEnumerable<T>-Eingabeobjekt vorhanden ist, bei dem der generische Parameter |
| CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) |
Kopiert DataRow-Objekte in die angegebene DataTable, bei einem IEnumerable<T>-Eingabeobjekt, bei dem der generische Parameter |
| CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) |
Kopiert DataRow-Objekte in die angegebene DataTable, bei einem IEnumerable<T>-Eingabeobjekt, bei dem der generische Parameter |
| Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>) |
Wendet eine Akkumulatorfunktion auf eine Sequenz an |
| Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>) |
Wendet eine Akkumulatorfunktion auf eine Sequenz an Der angegebene Startwert wird als erster Akkumulatorwert verwendet. |
| Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>) |
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. |
| All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Bestimmt, ob alle Elemente einer Sequenz eine Bedingung erfüllen. |
| Any<TSource>(IEnumerable<TSource>) |
Bestimmt, ob eine Sequenz Elemente enthält. |
| Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Bestimmt, ob ein Element einer Sequenz eine Bedingung erfüllt. |
| Append<TSource>(IEnumerable<TSource>, TSource) |
Fügt einen Wert an das Ende der Sequenz an. |
| AsEnumerable<TSource>(IEnumerable<TSource>) |
Gibt die Eingabe als IEnumerable<T> typisiert zurück |
| Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) |
Berechnet den Durchschnitt einer Sequenz von Decimal-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden |
| Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>) |
Berechnet den Durchschnitt einer Sequenz von Double-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden |
| Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) |
Berechnet den Durchschnitt einer Sequenz von Int32-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden |
| Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) |
Berechnet den Durchschnitt einer Sequenz von Int64-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden |
| Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) |
Berechnet den Durchschnitt einer Sequenz von Decimal-Werten, die NULL zulassen, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden |
| Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) |
Berechnet den Durchschnitt einer Sequenz von Double-Werten, die NULL zulassen, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden |
| Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) |
Berechnet den Durchschnitt einer Sequenz von Int32-Werten, die NULL zulassen, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden |
| Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) |
Berechnet den Durchschnitt einer Sequenz von Int64-Werten, die NULL zulassen, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden |
| Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) |
Berechnet den Durchschnitt einer Sequenz von Single-Werten, die NULL zulassen, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden |
| Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>) |
Berechnet den Durchschnitt einer Sequenz von Single-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden |
| Cast<TResult>(IEnumerable) |
Wandelt die Elemente eines IEnumerable in den angegebenen Typ um |
| Chunk<TSource>(IEnumerable<TSource>, Int32) |
Teilt die Elemente einer Sequenz höchstens |
| Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Verkettet zwei Sequenzen |
| Contains<TSource>(IEnumerable<TSource>, TSource) |
Bestimmt mithilfe des Standardgleichheitsvergleichs, ob eine Sequenz ein angegebenes Element enthält |
| Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>) |
Bestimmt mithilfe eines angegebenen IEqualityComparer<T>, ob eine Sequenz ein angegebenes Element enthält |
| Count<TSource>(IEnumerable<TSource>) |
Gibt die Anzahl der Elemente in einer Sequenz zurück |
| Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Gibt eine Zahl zurück, die die Anzahl der Elemente in der angegebenen Sequenz angibt, die eine Bedingung erfüllen |
| DefaultIfEmpty<TSource>(IEnumerable<TSource>) |
Gibt die Elemente der angegebenen Sequenz oder den Standardwert des Typparameters in einer Singletonauflistung zurück, wenn die Sequenz leer ist |
| DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource) |
Gibt die Elemente der angegebenen Sequenz oder den angegebenen Wert in einer Singletonauflistung zurück, wenn die Sequenz leer ist. |
| Distinct<TSource>(IEnumerable<TSource>) |
Gibt mithilfe des Standardgleichheitsvergleichs zum Vergleichen von Werten unterschiedliche Elemente aus einer Sequenz zurück |
| Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) |
Gibt mithilfe eines angegebenen IEqualityComparer<T> zum Vergleichen von Werten unterschiedliche Elemente aus einer Sequenz zurück |
| DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Gibt unterschiedliche Elemente aus einer Sequenz gemäß einer angegebenen Schlüsselauswahlfunktion zurück. |
| DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Gibt verschiedene Elemente aus einer Sequenz gemäß einer angegebenen Schlüsselauswahlfunktion und mithilfe eines angegebenen Vergleichs zum Vergleichen von Schlüsseln zurück. |
| ElementAt<TSource>(IEnumerable<TSource>, Index) |
Gibt das Element an einem angegebenen Index in einer Sequenz zurück |
| ElementAt<TSource>(IEnumerable<TSource>, Int32) |
Gibt das Element an einem angegebenen Index in einer Sequenz zurück |
| ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index) |
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. |
| ElementAtOrDefault<TSource>(IEnumerable<TSource>, 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. |
| Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Erzeugt die Differenzmenge zweier Sequenzen mithilfe des Standardgleichheitsvergleichs zum Vergleichen von Werten |
| Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) |
Erzeugt mithilfe des angegebenen IEqualityComparer<T> die Differenzmenge zweier Sequenzen zum Vergleichen von Werten |
| ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>) |
Erzeugt die Mengendifferenz von zwei Sequenzen gemäß einer angegebenen Schlüsselauswahlfunktion. |
| ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Erzeugt die Mengendifferenz von zwei Sequenzen gemäß einer angegebenen Schlüsselauswahlfunktion. |
| First<TSource>(IEnumerable<TSource>) |
Gibt das erste Element einer Sequenz zurück |
| First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Gibt das erste Element in einer Sequenz zurück, das eine angegebene Bedingung erfüllt. |
| FirstOrDefault<TSource>(IEnumerable<TSource>) |
Gibt das erste Element einer Sequenz oder einen Standardwert zurück, wenn die Sequenz keine Elemente enthält. |
| FirstOrDefault<TSource>(IEnumerable<TSource>, TSource) |
Gibt das erste Element einer Sequenz oder einen angegebenen Standardwert zurück, wenn die Sequenz keine Elemente enthält. |
| FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Gibt das erste Element der Sequenz zurück, das eine Bedingung erfüllt, oder einen Standardwert, wenn ein solches Element nicht gefunden wird. |
| FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource) |
Gibt das erste Element der Sequenz zurück, das eine Bedingung erfüllt, oder einen angegebenen Standardwert, wenn kein solches Element gefunden wird. |
| GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion |
| GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und vergleicht die Schlüssel mithilfe eines angegebenen Vergleichs |
| GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) |
Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und projiziert die Elemente für jede Gruppe mithilfe einer angegebenen Funktion |
| GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) |
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. |
| GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>) |
Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und erstellt aus jeder Gruppe und ihrem Schlüssel einen Ergebniswert. |
| GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>) |
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. |
| GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>) |
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. |
| GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>) |
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. |
| GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>) |
Korreliert die Elemente von zwei Sequenzen anhand der Gleichheit der Schlüssel und gruppiert die Ergebnisse Schlüssel werden mithilfe des Standardgleichheitsvergleichs verglichen. |
| GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>) |
Korreliert die Elemente von zwei Sequenzen anhand der Gleichheit der Schlüssel und gruppiert die Ergebnisse Schlüssel werden mithilfe eines angegebenen IEqualityComparer<T> verglichen. |
| Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Erzeugt die Schnittmenge zweier Sequenzen mithilfe des Standardgleichheitsvergleichs zum Vergleichen von Werten |
| Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) |
Erzeugt mithilfe des angegebenen IEqualityComparer<T> zum Vergleichen von Werten die Schnittmenge von zwei Sequenzen |
| IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>) |
Erzeugt den Satzschnitt von zwei Sequenzen gemäß einer angegebenen Schlüsselauswahlfunktion. |
| IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Erzeugt den Satzschnitt von zwei Sequenzen gemäß einer angegebenen Schlüsselauswahlfunktion. |
| Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>) |
Korreliert die Elemente von zwei Sequenzen auf der Grundlage von übereinstimmenden Schlüsseln Schlüssel werden mithilfe des Standardgleichheitsvergleichs verglichen. |
| Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>) |
Korreliert die Elemente von zwei Sequenzen auf der Grundlage von übereinstimmenden Schlüsseln Schlüssel werden mithilfe eines angegebenen IEqualityComparer<T> verglichen. |
| Last<TSource>(IEnumerable<TSource>) |
Gibt das letzte Element einer Sequenz zurück |
| Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Gibt das letzte Element einer Sequenz zurück, das eine angegebene Bedingung erfüllt. |
| LastOrDefault<TSource>(IEnumerable<TSource>) |
Gibt das letzte Element einer Sequenz oder einen Standardwert zurück, wenn die Sequenz keine Elemente enthält. |
| LastOrDefault<TSource>(IEnumerable<TSource>, TSource) |
Gibt das letzte Element einer Sequenz oder einen angegebenen Standardwert zurück, wenn die Sequenz keine Elemente enthält. |
| LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Gibt das letzte Element einer Sequenz, das eine Bedingung erfüllt, oder einen Standardwert zurück, wenn ein solches Element nicht gefunden wird. |
| LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource) |
Gibt das letzte Element einer Sequenz zurück, das eine Bedingung erfüllt, oder einen angegebenen Standardwert, wenn kein solches Element gefunden wird. |
| LongCount<TSource>(IEnumerable<TSource>) |
Gibt ein Int64 zurück, das die Gesamtanzahl der Elemente in einer Sequenz darstellt |
| LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Gibt ein Int64 zurück, das die Anzahl der Elemente in einer Sequenz darstellt, die eine Bedingung erfüllen |
| Max<TSource>(IEnumerable<TSource>) |
Gibt den Höchstwert in einer generischen Sequenz zurück |
| Max<TSource>(IEnumerable<TSource>, IComparer<TSource>) |
Gibt den Höchstwert in einer generischen Sequenz zurück |
| Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) |
Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Decimal-Wert zurück |
| Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>) |
Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Double-Wert zurück |
| Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) |
Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Int32-Wert zurück |
| Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) |
Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Int64-Wert zurück |
| Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) |
Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Decimal-Wert zurück, der NULL-Werte zulässt |
| Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) |
Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Double-Wert zurück, der NULL-Werte zulässt |
| Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) |
Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Int32-Wert zurück, der NULL-Werte zulässt |
| Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) |
Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Int64-Wert zurück, der NULL-Werte zulässt |
| Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) |
Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Single-Wert zurück, der NULL-Werte zulässt |
| Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>) |
Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Single-Wert zurück |
| Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) |
Ruft für jedes Element einer generischen Sequenz eine Transformationsfunktion auf, und gibt den höchsten Ergebniswert zurück |
| MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Gibt den Maximalwert in einer generischen Sequenz gemäß einer angegebenen Schlüsselauswahlfunktion zurück. |
| MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) |
Gibt den Maximalwert in einer generischen Sequenz gemäß einer angegebenen Schlüsselauswahlfunktion und einem angegebenen Schlüsselvergleich zurück. |
| Min<TSource>(IEnumerable<TSource>) |
Gibt den Mindestwert in einer generischen Sequenz zurück |
| Min<TSource>(IEnumerable<TSource>, IComparer<TSource>) |
Gibt den Mindestwert in einer generischen Sequenz zurück |
| Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) |
Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Decimal-Wert zurück |
| Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>) |
Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Double-Wert zurück |
| Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) |
Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Int32-Wert zurück |
| Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) |
Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Int64-Wert zurück |
| Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) |
Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Decimal-Wert zurück, der NULL-Werte zulässt |
| Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) |
Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Double-Wert zurück, der NULL-Werte zulässt |
| Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) |
Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Int32-Wert zurück, der NULL-Werte zulässt |
| Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) |
Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Int64-Wert zurück, der NULL-Werte zulässt |
| Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) |
Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Single-Wert zurück, der NULL-Werte zulässt |
| Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>) |
Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Single-Wert zurück |
| Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) |
Ruft für jedes Element einer generischen Sequenz eine Transformationsfunktion auf, und gibt den niedrigsten Ergebniswert zurück |
| MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Gibt den Mindestwert in einer generischen Sequenz gemäß einer angegebenen Schlüsselauswahlfunktion zurück. |
| MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) |
Gibt den Mindestwert in einer generischen Sequenz gemäß einer angegebenen Schlüsselauswahlfunktion und einem angegebenen Schlüsselvergleich zurück. |
| OfType<TResult>(IEnumerable) |
Filtert die Elemente eines IEnumerable anhand eines angegebenen Typs |
| Order<T>(IEnumerable<T>) |
Sortiert die Elemente einer Sequenz in aufsteigender Reihenfolge |
| Order<T>(IEnumerable<T>, IComparer<T>) |
Sortiert die Elemente einer Sequenz in aufsteigender Reihenfolge |
| OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Sortiert die Elemente einer Sequenz in aufsteigender Reihenfolge nach einem Schlüssel |
| OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) |
Sortiert die Elemente einer Sequenz mithilfe eines angegebenen Vergleichs in aufsteigender Reihenfolge |
| OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Sortiert die Elemente einer Sequenz in absteigender Reihenfolge nach einem Schlüssel |
| OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) |
Sortiert die Elemente einer Sequenz mithilfe eines angegebenen Vergleichs in absteigender Reihenfolge. |
| OrderDescending<T>(IEnumerable<T>) |
Sortiert die Elemente einer Sequenz in absteigender Reihenfolge. |
| OrderDescending<T>(IEnumerable<T>, IComparer<T>) |
Sortiert die Elemente einer Sequenz in absteigender Reihenfolge. |
| Prepend<TSource>(IEnumerable<TSource>, TSource) |
Fügt einen Wert am Anfang der Sequenz ein. |
| Reverse<TSource>(IEnumerable<TSource>) |
Kehrt die Reihenfolge der Elemente in einer Sequenz um |
| Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) |
Projiziert jedes Element einer Sequenz in ein neues Format. |
| Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>) |
Projiziert jedes Element einer Sequenz in ein neues Format, indem der Index des Elements integriert wird |
| SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) |
Projiziert jedes Element einer Sequenz in ein IEnumerable<T>, und fasst die resultierenden Sequenzen in einer einzigen Sequenz zusammen |
| SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) |
Projiziert jedes Element einer Sequenz in ein IEnumerable<T>, und fasst die resultierenden Sequenzen zu einer einzigen Sequenz zusammen Der Index jedes Quellelements wird im projizierten Format des jeweiligen Elements verwendet. |
| SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) |
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. |
| SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) |
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. |
| SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Bestimmt, ob zwei Sequenzen gleich sind, indem die Elemente mithilfe des Standardgleichheitsvergleichs für ihren Typ verglichen werden |
| SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) |
Bestimmt, ob zwei Sequenzen gleich sind, indem ihre Elemente mithilfe eines angegebenen IEqualityComparer<T> verglichen werden |
| Single<TSource>(IEnumerable<TSource>) |
Gibt das einzige Element einer Sequenz zurück und löst eine Ausnahme aus, wenn nicht genau ein Element in der Sequenz vorhanden ist. |
| Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
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. |
| SingleOrDefault<TSource>(IEnumerable<TSource>) |
Gibt das einzige Element einer Sequenz oder einen Standardwert zurück, wenn die Sequenz leer ist. Diese Methode löst eine Ausnahme aus, wenn mehrere Elemente in der Sequenz vorhanden sind. |
| SingleOrDefault<TSource>(IEnumerable<TSource>, TSource) |
Gibt das einzige Element einer Sequenz oder einen angegebenen 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. |
| SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
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. |
| SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource) |
Gibt das einzige Element einer Sequenz zurück, das eine angegebene Bedingung erfüllt, oder einen angegebenen Standardwert, wenn kein solches Element vorhanden ist. Diese Methode löst eine Ausnahme aus, wenn mehr als ein Element die Bedingung erfüllt. |
| Skip<TSource>(IEnumerable<TSource>, Int32) |
Umgeht eine festgelegte Anzahl von Elementen in einer Sequenz und gibt dann die übrigen Elemente zurück |
| SkipLast<TSource>(IEnumerable<TSource>, Int32) |
Gibt eine neue aufzählbare Auflistung zurück, die die Elemente aus |
| SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Umgeht Elemente in einer Sequenz, solange eine angegebene Bedingung true ist, und gibt dann die übrigen Elemente zurück |
| SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) |
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. |
| Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) |
Berechnet die Summe einer Sequenz von Decimal-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden |
| Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) |
Berechnet die Summe einer Sequenz von Double-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden |
| Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) |
Berechnet die Summe einer Sequenz von Int32-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden |
| Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) |
Berechnet die Summe einer Sequenz von Int64-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden |
| Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) |
Berechnet die Summe einer Sequenz von Decimal-Werten, die NULL zulassen, und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden |
| Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) |
Berechnet die Summe einer Sequenz von Double-Werten, die NULL zulassen, und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden |
| Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) |
Berechnet die Summe einer Sequenz von Int32-Werten, die NULL zulassen, und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden |
| Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) |
Berechnet die Summe einer Sequenz von Int64-Werten, die NULL zulassen, und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden |
| Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) |
Berechnet die Summe einer Sequenz von Single-Werten, die NULL zulassen, und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden |
| Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>) |
Berechnet die Summe einer Sequenz von Single-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden |
| Take<TSource>(IEnumerable<TSource>, Int32) |
Gibt eine angegebene Anzahl von zusammenhängenden Elementen ab dem Anfang einer Sequenz zurück |
| Take<TSource>(IEnumerable<TSource>, Range) |
Gibt einen angegebenen Bereich von zusammenhängenden Elementen aus einer Sequenz zurück. |
| TakeLast<TSource>(IEnumerable<TSource>, Int32) |
Gibt eine neue aufzählbare Auflistung zurück, die die letzten |
| TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Gibt Elemente aus einer Sequenz zurück, solange eine angegebene Bedingung TRUE ist |
| TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) |
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. |
| ToArray<TSource>(IEnumerable<TSource>) |
Erstellt ein Array aus einem IEnumerable<T>. |
| ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Erstellt ein Dictionary<TKey,TValue> aus einem IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion |
| ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Erstellt ein Dictionary<TKey,TValue> aus einem IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion und eines angegebenen Schlüsselvergleichs |
| ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) |
Erstellt ein Dictionary<TKey,TValue> aus einem IEnumerable<T> entsprechend der angegebenen Schlüsselauswahlfunktion und Elementauswahlfunktion |
| ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) |
Erstellt ein Dictionary<TKey,TValue> aus einem IEnumerable<T> entsprechend einer angegebenen Schlüsselauswahlfunktion, einem Vergleich und einer Elementauswahlfunktion |
| ToHashSet<TSource>(IEnumerable<TSource>) |
Erstellt ein HashSet<T> aus einem IEnumerable<T>. |
| ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) |
Erstellt ein HashSet<T>-Element aus einem IEnumerable<T>-Element mithilfe des |
| ToList<TSource>(IEnumerable<TSource>) |
Erstellt ein List<T> aus einem IEnumerable<T>. |
| ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Erstellt ein Lookup<TKey,TElement> aus einem IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion |
| ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Erstellt ein Lookup<TKey,TElement> aus einem IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion und eines angegebenen Schlüsselvergleichs |
| ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) |
Erstellt ein Lookup<TKey,TElement> aus einem IEnumerable<T> entsprechend der angegebenen Schlüsselauswahlfunktion und Elementauswahlfunktion |
| ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) |
Erstellt ein Lookup<TKey,TElement> aus einem IEnumerable<T> entsprechend einer angegebenen Schlüsselauswahlfunktion, einem Vergleich und einer Elementauswahlfunktion |
| TryGetNonEnumeratedCount<TSource>(IEnumerable<TSource>, Int32) |
Diese Methode versucht, die Anzahl der Elemente in einer Sequenz zu bestimmen, ohne eine Enumeration zu erzwingen. |
| Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Erzeugt die Vereinigungsmenge von zwei Sequenzen mithilfe des Standardgleichheitsvergleichs |
| Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) |
Erzeugt mithilfe eines angegebenen IEqualityComparer<T> die Vereinigungsmenge von zwei Sequenzen |
| UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>) |
Erzeugt die Mengenunion von zwei Sequenzen gemäß einer angegebenen Schlüsselauswahlfunktion. |
| UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Erzeugt die Mengenunion von zwei Sequenzen gemäß einer angegebenen Schlüsselauswahlfunktion. |
| Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Filtert eine Sequenz von Werten basierend auf einem Prädikat. |
| Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) |
Filtert eine Sequenz von Werten basierend auf einem Prädikat. In der Logik der Prädikatfunktion wird der Index der einzelnen Elemente verwendet. |
| Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>) |
Erzeugt eine Tupelsequenz mit Elementen aus den beiden angegebenen Sequenzen. |
| Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>) |
Erzeugt eine Sequenz von Tupeln mit Elementen aus den drei angegebenen Sequenzen. |
| Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>) |
Wendet eine Funktion auf die entsprechenden Elemente von zwei Sequenzen an, und erzeugt eine Sequenz der Ergebnisse |
| AsParallel(IEnumerable) |
Ermöglicht die Parallelisierung einer Abfrage. |
| AsParallel<TSource>(IEnumerable<TSource>) |
Ermöglicht die Parallelisierung einer Abfrage. |
| AsQueryable(IEnumerable) |
Konvertiert einen IEnumerable in einen IQueryable. |
| AsQueryable<TElement>(IEnumerable<TElement>) |
Konvertiert ein generisches IEnumerable<T> in ein generisches IQueryable<T>. |
| AsMemory(String) |
Erstellt ein neues |
| AsMemory(String, Index) |
Erstellt ein neues |
| AsMemory(String, Int32) |
Erstellt ein neues |
| AsMemory(String, Int32, Int32) |
Erstellt ein neues |
| AsMemory(String, Range) |
Erstellt ein neues |
| AsSpan(String) |
Erstellt eine neue schreibgeschützte Spanne über eine Zeichenfolge. |
| AsSpan(String, Index) |
Erstellt eine neue ReadOnlySpan<T> über einen Teil der Zielzeichenfolge von einer angegebenen Position bis zum Ende der Zeichenfolge. |
| AsSpan(String, Int32) |
Erstellt eine neue schreibgeschützte Spanne über einen Abschnitt der Zielzeichenfolge von einer angegebenen Position aus bis zum Ende der Zeichenfolge. |
| AsSpan(String, Int32, Int32) |
Erstellt eine neue schreibgeschützte Spanne über einen Abschnitt der Zielzeichenfolge von einer angegebenen Position aus für eine angegebene Anzahl von Zeichen. |
| AsSpan(String, Range) |
Erstellt ein neues ReadOnlySpan<T> über einen Teil einer Zielzeichenfolge unter Verwendung der Anfangs- und Endindizes des Bereichs. |
| IsNormalized(String) |
Gibt an, ob diese angegebene Zeichenfolge in der Unicode-Normalisierungsform C vorliegt. |
| IsNormalized(String, NormalizationForm) |
Gibt an, ob eine Zeichenfolge in einer angegebenen Unicode-Normalisierungsform vorliegt. |
| Normalize(String) |
Normalisiert eine Zeichenfolge in eine Unicode-Normalisierungsform C. |
| Normalize(String, NormalizationForm) |
Normalisiert eine Zeichenfolge in die angegebene Unicode-Normalisierungsform. |
| Ancestors<T>(IEnumerable<T>) |
Gibt eine Auflistung von Elementen zurück, die die übergeordneten Elemente der einzelnen Knoten in der Quellauflistung enthält. |
| Ancestors<T>(IEnumerable<T>, XName) |
Gibt eine gefilterte Auflistung von Elementen zurück, die die übergeordneten Elemente der einzelnen Knoten in der Quellauflistung enthält. Nur Elemente, die über einen übereinstimmenden XName verfügen, sind in der Auflistung enthalten. |
| DescendantNodes<T>(IEnumerable<T>) |
Gibt eine Auflistung der Nachfolgerknoten jedes Dokuments und Elements in der Quellauflistung zurück. |
| Descendants<T>(IEnumerable<T>) |
Gibt eine Auflistung von Elementen zurück, die die Nachfolgerelemente jedes Elements und Dokuments in der Quellauflistung enthält. |
| Descendants<T>(IEnumerable<T>, XName) |
Gibt eine gefilterte Auflistung von Elementen zurück, die die Nachfolgerelemente jedes Elements und Dokuments in der Quellauflistung enthält. Nur Elemente, die über einen übereinstimmenden XName verfügen, sind in der Auflistung enthalten. |
| Elements<T>(IEnumerable<T>) |
Gibt eine Auflistung der untergeordneten Elemente jedes Elements und Dokuments in der Quellauflistung zurück. |
| Elements<T>(IEnumerable<T>, XName) |
Gibt eine gefilterte Auflistung der untergeordneten Elemente jedes Elements und Dokuments in der Quellauflistung zurück. Nur Elemente, die über einen übereinstimmenden XName verfügen, sind in der Auflistung enthalten. |
| InDocumentOrder<T>(IEnumerable<T>) |
Gibt eine in Dokumentreihenfolge sortierte Auflistung von Knoten zurück, die alle Knoten in der Quellauflistung enthält. |
| Nodes<T>(IEnumerable<T>) |
Gibt eine Auflistung der untergeordneten Knoten jedes Dokuments und Elements in der Quellauflistung zurück. |
| Remove<T>(IEnumerable<T>) |
Entfernt jeden Knoten in der Quellauflistung aus seinem übergeordneten Knoten. |
Gilt für:
Threadsicherheit
Dieser Typ ist threadsicher.
Weitere Informationen
- IComparable
- ICloneable
- IConvertible
- IEnumerable
- StringBuilder
- CultureInfo
- Sortieren von Gewichtungstabellen für Windows (nur .NET Framework und .NET Core)
- Standardmäßige Unicode-Sortierungselementtabellen
- Formatieren von Typen in .NET
- Empfohlene Vorgehensweisen für die Verwendung von Zeichenfolgen in .NET