Freigeben über

Erstellen neuer Zeichenfolgen in .NET

.NET ermöglicht das Erstellen von Zeichenfolgen mithilfe einfacher Zuweisung und überladen auch einen Klassenkonstruktor, um die Zeichenfolgenerstellung mithilfe einer Reihe verschiedener Parameter zu unterstützen. .NET stellt außerdem mehrere Methoden in der System.String Klasse bereit, die neue Zeichenfolgenobjekte erstellen, indem mehrere Zeichenfolgen, Arrays von Zeichenfolgen oder Objekten kombiniert werden.

Erstellen von Zeichenfolgen mithilfe von Zuweisung

Die einfachste Möglichkeit, ein neues String-Objekt zu erstellen, besteht darin, einem String-Objekt ein Literal einer Zeichenfolge einfach zuzuweisen.

Erstellen von Zeichenfolgen mithilfe eines Klassenkonstruktors

Sie können Überladungen des String Klassenkonstruktors verwenden, um Zeichenfolgen aus Zeichenarrays zu erstellen. Sie können auch eine neue Zeichenfolge erstellen, indem Sie ein bestimmtes Zeichen mit einer bestimmten Anzahl von Malen duplizieren. Die String(ReadOnlySpan<Char>) Konstruktorüberladung akzeptiert eine ReadOnlySpan<T> oder ein stapelzugewiesenes Span<T> von Zeichen und verhindert das Zuweisen eines Zwischenzeichenfelds auf dem verwalteten Heap, wenn Sie eine kleine Zeichenfolge einer bekannten Größe erstellen, obwohl die resultierende Zeichenfolgeninstanz weiterhin auf dem verwalteten Heap zugeordnet ist.

Methoden, die Zeichenfolgen zurückgeben

In der folgenden Tabelle sind mehrere nützliche Methoden aufgeführt, die neue Zeichenfolgenobjekte zurückgeben.

Methodenname Verwendung
String.Format Erstellt eine formatierte Zeichenfolge aus einer Reihe von Eingabeobjekten.
String.Concat Erstellt Zeichenfolgen aus mindestens zwei Zeichenfolgen.
String.Join Erstellt eine neue Zeichenfolge durch Kombinieren eines Arrays von Zeichenfolgen.
String.Insert Erstellt eine neue Zeichenfolge, indem eine Zeichenfolge in den angegebenen Index einer vorhandenen Zeichenfolge eingefügt wird.
String.CopyTo Kopiert angegebene Zeichen in einer Zeichenfolge an eine angegebene Position in einem Array von Zeichen.
String.Create Erstellt eine neue Zeichenfolge einer angegebenen Länge, füllt die Zeichen mittels eines Rückrufs, der ein beschreibbares Span<T> und ein vom Aufrufer bereitgestelltes Zustandsobjekt empfängt.

String.Format

Mit der String.Format Methode können Sie formatierte Zeichenfolgen erstellen und Zeichenfolgen verketten, die mehrere Objekte darstellen. Diese Methode konvertiert automatisch alle übergebenen Objekte in eine Zeichenfolge. Wenn Ihre Anwendung beispielsweise einen Int32 Wert und einen DateTime Wert für den Benutzer anzeigen muss, können Sie ganz einfach eine Zeichenfolge erstellen, um diese Werte mithilfe der Format Methode darzustellen. Informationen zu formatierungskonventionen, die mit dieser Methode verwendet werden, finden Sie im Abschnitt " Zusammengesetzte Formatierung".

Im folgenden Beispiel wird die Format Methode verwendet, um eine Zeichenfolge zu erstellen, die eine ganzzahlige Variable verwendet.

int numberOfFleas = 12;
string miscInfo = String.Format("Your dog has {0} fleas. " +
                                "It is time to get a flea collar. " +
                                "The current universal date is: {1:u}.",
                                numberOfFleas, DateTime.Now);
Console.WriteLine(miscInfo);
// The example displays the following output:
//       Your dog has 12 fleas. It is time to get a flea collar.
//       The current universal date is: 2008-03-28 13:31:40Z.

Dim numberOfFleas As Integer = 12
Dim miscInfo As String = String.Format("Your dog has {0} fleas. " & _
                                       "It is time to get a flea collar. " & _
                                       "The current universal date is: {1:u}.", _
                                       numberOfFleas, Date.Now)
Console.WriteLine(miscInfo)
' The example displays the following output:
'       Your dog has 12 fleas. It is time to get a flea collar. 
'       The current universal date is: 2008-03-28 13:31:40Z.

In diesem Beispiel werden das aktuelle Datum und die aktuelle Uhrzeit in einer Weise angezeigt, die durch die Kultur angegeben wird, DateTime.Now die dem aktuellen Thread zugeordnet ist.

String.Concat

Die String.Concat Methode kann verwendet werden, um problemlos ein neues Zeichenfolgenobjekt aus zwei oder mehr vorhandenen Objekten zu erstellen. Sie bietet eine sprachunabhängige Methode zum Verketten von Zeichenfolgen. Diese Methode akzeptiert jede Klasse, die von System.Object abgeleitet ist. Im folgenden Beispiel wird eine Zeichenfolge aus zwei vorhandenen Zeichenfolgenobjekten und einem getrennten Zeichen erstellt.

string helloString1 = "Hello";
string helloString2 = "World!";
Console.WriteLine(String.Concat(helloString1, ' ', helloString2));
// The example displays the following output:
//      Hello World!

Dim helloString1 As String = "Hello"
Dim helloString2 As String = "World!"
Console.WriteLine(String.Concat(helloString1, " "c, helloString2))
' The example displays the following output:
'      Hello World!

String.Join

Die String.Join-Methode erstellt eine neue Zeichenfolge aus einem Array von Zeichenfolgen und einem Trennzeichen. Diese Methode ist nützlich, wenn Sie mehrere Zeichenfolgen miteinander verketten möchten, wodurch eine Liste möglicherweise durch ein Komma getrennt wird.

Das folgende Beispiel verwendet ein Leerzeichen, um ein Zeichenfolgenarray zu binden.

string[] words = {"Hello", "and", "welcome", "to", "my" , "world!"};
Console.WriteLine(String.Join(" ", words));
// The example displays the following output:
//      Hello and welcome to my world!

Dim words() As String = {"Hello", "and", "welcome", "to", "my", "world!"}
Console.WriteLine(String.Join(" ", words))
' The example displays the following output:
'      Hello and welcome to my world!

String.Insert

Die String.Insert Methode erstellt eine neue Zeichenfolge, indem sie eine Zeichenfolge an eine angegebene Position in einer anderen Zeichenfolge einfügt. Diese Methode verwendet einen nullbasierten Index. Im folgenden Beispiel wird eine Zeichenfolge an der fünften Indexposition von MyString eingefügt und mit diesem Wert eine neue Zeichenfolge erstellt.

string sentence = "Once a time.";
 Console.WriteLine(sentence.Insert(4, " upon"));
 // The example displays the following output:
 //      Once upon a time.

Dim sentence As String = "Once a time."
Console.WriteLine(sentence.Insert(4, " upon"))
' The example displays the following output:
'      Once upon a time.

String.CopyTo

Die String.CopyTo Methode kopiert Teile einer Zeichenfolge in ein Array von Zeichen. Sie können sowohl den Anfangsindex der Zeichenfolge als auch die Anzahl der zu kopierenden Zeichen angeben. Diese Methode verwendet den Quellindex, ein Array von Zeichen, den Zielindex und die Anzahl der zu kopierenden Zeichen. Alle Indizes sind nullbasiert.

Im folgenden Beispiel wird die CopyTo Methode verwendet, um die Zeichen des Worts "Hello" aus einem Zeichenfolgenobjekt in die erste Indexposition eines Arrays von Zeichen zu kopieren.

string greeting = "Hello World!";
char[] charArray = {'W','h','e','r','e'};
Console.WriteLine($"The original character array: {new string(charArray)}");
greeting.CopyTo(0, charArray,0 ,5);
Console.WriteLine($"The new character array: {new string(charArray)}");
// The example displays the following output:
//       The original character array: Where
//       The new character array: Hello

Dim greeting As String = "Hello World!"
Dim charArray() As Char = {"W"c, "h"c, "e"c, "r"c, "e"c}
Console.WriteLine("The original character array: {0}", New String(charArray))
greeting.CopyTo(0, charArray, 0, 5)
Console.WriteLine("The new character array: {0}", New String(charArray))
' The example displays the following output:
'       The original character array: Where
'       The new character array: Hello

String.Create

Mit der String.Create Methode können Sie die Zeichen einer neuen Zeichenfolge programmgesteuert mithilfe eines Rückrufs ausfüllen. Der Rückruf empfängt ein beschreibbares Span<T> von Zeichen und ein vom Aufrufer bereitgestelltes Statusobjekt, sodass Sie den Inhalt der Zeichenfolge erstellen können, ohne Zwischenpuffer für Zeichen zuzuordnen. Der Rückruf selbst kann weiterhin Speicher allokieren, z. B. wenn er lokale Variablen erfasst oder andere speicheraufwendige APIs aufruft.

Im folgenden Beispiel wird String.Create verwendet, um eine Zeichenfolge aus fünf aufeinanderfolgenden Alphabetzeichen zu erstellen.

string result = string.Create(5, 'a', (span, firstChar) =>
{
    for (int i = 0; i < span.Length; i++)
    {
        span[i] = (char)(firstChar + i);
    }
});

Console.WriteLine(result); // abcde

Module Program
    Sub Main()
        Dim result As String = String.Create(5, "a"c, Sub(span, firstChar)
                                                           For i As Integer = 0 To span.Length - 1
                                                               span(i) = ChrW(AscW(firstChar) + i)
                                                           Next
                                                       End Sub)

        Console.WriteLine(result) ' abcde
    End Sub
End Module

String.Create ist für leistungskritische Szenarien konzipiert, in denen Sie die endgültige Zeichenfolgenlänge im Voraus kennen und vermeiden möchten, Zwischenpuffer zuzuweisen. Die Laufzeitumgebung weist eine neue Zeichenfolge zu, übergibt den Backing Buffer direkt als an den Rückruf und gibt die unveränderliche Zeichenfolge zurück, sobald der Rückruf beendet ist. Nach Abschluss des Callback erfolgt keine Kopie der Daten.

String.Create Vs. new String(Span<char>)

Eine weitere Möglichkeit zum effizienten Erstellen von Zeichenfolgen besteht darin, einen Zeichenpuffer zuzuweisen stackalloc, ihn auszufüllen und an den String(ReadOnlySpan<char>) Konstruktor zu übergeben:

static string CreateStringFromSpan()
{
    Span<char> span = stackalloc char[5];
    for (int i = 0; i < 5; i++)
    {
        span[i] = (char)('a' + i);
    }
    return new string(span);
}

Console.WriteLine(CreateStringFromSpan()); // abcde

Beide Ansätze ordnen die letztendliche Zeichenfolge genau einmal zu. Hauptunterschiede:

  • stackalloc + new string(span) platziert den Arbeitspuffer auf dem Stapel. Dies ist am schnellsten für kleine, festgelegte Puffer, aber der Stapel ist eine endliche Ressource; große oder tief geschachtelte Allokationen können zu einer StackOverflowException. Dieses Beispiel zeigt das C# stackalloc-Muster; Visual Basic unterstützt stackalloc nicht, kann aber trotzdem den String(ReadOnlySpan<char>)-Konstruktor aufrufen, wenn Sie ein ReadOnlySpan<char> haben.
  • String.Create weist den Arbeitspuffer für den Heap als Teil des Zeichenfolgenobjekts selbst zu, sodass kein Stapeldruck vorhanden ist. Sie akzeptiert auch einen typisierten Zustandsparameter, den die Runtime ohne Boxing an Ihren Rückruf übergibt, wodurch Boxing-Allokationen vermieden werden, wenn der Zustand ein Verweistyp oder eine nicht erfasster Strukturtyp ist. Im Allgemeinen bevorzugen Sie stackalloc + new String(span) kleine Zeichenfolgen (in der Regel weniger als ein paar hundert Zeichen) mit einer bekannten, begrenzten Größe. Verwenden Sie String.Create , wenn die Größe möglicherweise groß ist, wenn Sie Stapeldruck vermeiden möchten, oder wenn Sie den Zustand ohne Boxen in den Rückruf übergeben.

Siehe auch

  • Last updated on