Dr. GUI .NET Nr. 5 - Zeichenfolgen in .NET Framework

Veröffentlicht: 06. Aug 2002 | Aktualisiert: 22. Jun 2004

Strings nehmen einen wichtigen Platz in der Programmierung ein. Wie das .NET Framework sie verwaltet, wie Sie sie über die Sprachen Visual Basic .NET und C# verändern, zeigt dieser Artikel.

Auf dieser Seite

Kommentare - Use the Source, Luke! Kommentare - Use the Source, Luke!
Übersicht und Ausblick Übersicht und Ausblick
Zeichenfolgen Zeichenfolgen
Die "System.String"-Klasse Die "System.String"-Klasse
Zeichenfolgen in C# Zeichenfolgen in C#
Zeichenfolgen in Visual Basic .NET Zeichenfolgen in Visual Basic .NET
Zeichenfolgen mit den Standard-APIs von .NET Framework Zeichenfolgen mit den Standard-APIs von .NET Framework
StringBuilder StringBuilder
Codierung und Decodierung von "System.Text" Codierung und Decodierung von "System.Text"
Reguläre Ausdrücke Reguläre Ausdrücke
Versuchen Sie es einfach mal! Versuchen Sie es einfach mal!
Die nächsten Schritte Die nächsten Schritte

Kommentare - Use the Source, Luke!

Dieser Artikel enthält Links zu englischsprachigen Seiten. Wenn Sie uns und anderen Ihre Meinung zu diesem Artikel mitteilen möchten, können Sie dies im Dr. GUI .NET Nachrichtenforum tun.

Übersicht und Ausblick

In unserem letzten Artikel haben wir die Mutter aller .NET-Klassen vorgestellt: System.Object. Ferner wurden die Speicherreservierung und Garbage Collection erläutert und die Funktionsweise dynamischer Typen in .NET Framework angesprochen.

In diesem Artikel beschäftigen wir uns nun mit Zeichenfolgen in der .NET-Laufzeit.

Zeichenfolgen

String (genauer: System.String) bezeichnet die Art von Zeichenfolgen, einschließlich Zeichenfolgenliterale, in .NET Framework. In .NET Framework besteht eine Zeichenfolge aus null oder mehr 16-Bit-Unicodezeichen (zwei Byte).

Unveränderliche Zeichenfolgen
In .NET Framework ist zu beachten, dass String-Objekte unveränderlich sind, d.h., ihre Werte können nach der Erstellung der Zeichenfolgen nicht mehr geändert werden. Sie haben jedoch die Möglichkeit, den Zeichenfolgenverweis so zu ändern, dass er auf eine andere Zeichenfolge verweist. Somit wird die erste Zeichenfolge zur Garbage Collection freigegeben, wenn keine andere Referenz dorthin verweist.

Die Methoden von String, mit denen sich eine Zeichenfolge scheinbar ändern lässt, ändern nicht die aktuelle Zeichenfolge, sondern erzeugen stattdessen eine neue Zeichenfolge und geben sie zurück. Selbst wenn nur ein einzelnes Zeichen geändert, eingefügt oder gelöscht wird, wird eine neue Zeichenfolge generiert und die alte verworfen.
Das wiederholte Erzeugen und Verwerfen von Zeichenfolgen kann einige Zeit in Anspruch nehmen. Mit unveränderlichen Zeichenfolgen ist jedoch auch eine Vielzahl von Vorteilen verbunden, da sich Aspekte wie Eigentum, Aliasing und Threading bei unveränderlichen Objekten weitaus einfacher gestalten. Zeichenfolgen ermöglichen z.B. immer eine sichere Multithread-Programmierung. Bei Threads besteht nicht die Gefahr von Konflikten aufgrund einer Zeichenfolgenänderung, da Zeichenfolgen nicht geändert werden können.

StringBuilder
StringBuilder ist eine .NET-Klasse. Bei einem StringBuilder-Objekt handelt es sich zwar nicht um eine Zeichenfolge, es wird jedoch zur Bearbeitung von Zeichenfolgen mit 16-Bit-Unicode-Zeichen verwendet. Es enthält einen Puffer, der im Allgemeinen mit einer Zeichenfolge initialisiert wird. Der Puffer ist jedoch in der Regel größer als diese Zeichenfolge.

Die Zeichen im Puffer lassen sich an Ort und Stelle bearbeiten, ohne dass dabei ein neuer Puffer erstellt wird - Sie können Zeichen einfügen, anhängen, entfernen und ersetzen. Ein neuer Puffer wird erzeugt, wenn Sie so viele Zeichen eingeben, dass die Größe des Originalpuffers nicht mehr ausreicht.

Nach abgeschlossener Zeichenbearbeitung extrahieren Sie mit der ToString-Methode von StringBuilder die Zeichenfolge aus StringBuilder. In den meisten Fällen erfordert StringBuilder.ToString keinen Kopiervorgang und ist daher sehr effizient.

Indizieren von Zeichenfolgen und "StringBuilder"
Da Zeichenfolgen und StringBuilderChar-Unicodezeichen enthalten, unterstützen sie einen Indexer namens Chars, der die einzelnen Char-Zeichen an den von Ihnen angegebenen Indexstellen zurückgibt. Wenn Sie mit C# arbeiten, können Sie diesen Indexer wie ein Arraysubskript aufrufen.

Da String unveränderlich ist, ist sein Indexer schreibgeschützt. Für den Indexer von StringBuilder hingegen besteht Lese- und Schreibzugriff, die Zeichen können also angezeigt und auch geändert werden.

Die "System.String"-Klasse

System.String ist eine versiegelte Klasse, d.h, sie ist nicht vererbbar (was auch bedeutet, dass das System bestimmte Optimierungen vornehmen kann, um die Verarbeitung von Zeichenfolgen zu beschleunigen).

Die meisten .NET-Sprachen verfügen über eine integrierte Unterstützung von Zeichenfolgen. Beispielsweise unterstützen sie in der Regel Zeichenfolgenliterale und Operationen wie Verkettungen. Die Syntax richtet sich jedoch nach der jeweiligen Sprache.

Zeichenfolgen in C#

Zeichenfolgenliterale in C#
C# unterstützt zwei Arten von Zeichenfolgenliteralen: "reguläre" Zeichenfolgenliterale und "wörtliche" Zeichenfolgenliterale.

Reguläre Zeichenfolgenliterale sind vergleichbar mit Zeichenfolgenliteralen in C und C++: sie sind durch Anführungszeichen abgegrenzt und enthalten Escape-Zeichenfolgen zur Darstellung verschiedener Steuerzeichen und beliebiger Unicodezeichen. Sie dürfen zwar nicht länger als eine Zeile sein, können aber zur Kompilierungszeit mit dem +-Operator mit benachbarten Zeichenfolgenliteralen verkettet werden. Sämtliche Escape-Zeichenfolgen werden durch einen umgekehrten Schrägstrich ("\") eingeleitet. Eine Übersicht über diese Zeichenfolgen finden Sie in der nachfolgenden Tabelle.

Tabelle 1. Escape-Zeichenfolgen in Zeichenfolgenliteralen in C#

Escape-Zeichenfolge

Beschreibung

\t

Tabulator (Unicode 0x0009)

\r

Wagenrücklauf (0x000d)

\n

Neue Zeile (Zeilenvorschub) (0x000a)

\v

Vertikaler Tabulator (0x000b)

\a

Signalton (0x0007)

\b

Rücktaste (0x0008)

\f

Seitenvorschub (0x000c)

\0

Null (0x0000)

\\

Umgekehrter Schrägstrich (0x005c)

\'

Einfaches Hochkomma (0x0027)

\"

Anführungszeichen (0x0022)

\xD

Hexadezimalzeichencode mit variabler Anzahl von Ziffern

\uABCD

Unicodezeichen 0xABCD (die Verwendung von u oder U ist zulässig, wenn A, B, C und D gültige Hexadezimalziffern 0-9, a-f, A-F sind)

Alle diese Escape-Zeichenfolgen können Sie in jedem beliebigen regulären Zeichenfolgenliteral oder Zeichenliteral (z.B. '\t') verwenden. Zudem lassen sich die Unicode-Escape-Zeichenfolgen auch in Bezeichnern einsetzen, so dass if (a\U0066b = true) gleich if (afb = true) ist (da Unicode 0x0066 "f" ist). Somit sind Sie in der Lage, Bezeichner mit jedem gültigen Unicodezeichen zu schreiben, selbst wenn das Zeichen nicht auf Ihrer Tastatur vorhanden ist oder nicht in der verwendeten Editor-Schriftart angezeigt werden kann.

Wörtliche Zeichenfolgenliterale werden durch das Zeichen @" eingeleitet und enden mit dem entsprechenden Anführungszeichen. Sie enthalten keine Escape-Zeichenfolgen, so dass

@"\\machine\share\path1\path2\file.ext"

der Zeichenfolge

"\\\\machine\\share\\path1\\path2\\file.ext"

entspricht, jedoch weitaus einfacher und weniger fehleranfällig ist. Wörtliche Zeichenfolgenliterale können sich zudem über mehrere Zeilen erstrecken. In diesem Fall steht ein beliebiges so genanntes Leerstellenzeichen zwischen den Anführungszeichen:

@"First \t line
   tabbed second line"
// ist gleich "First \\t line\r\n\ttabbed second line"

Anmerkung: Je nach verwendetem Editor müssen Sie das "\r" in der zweiten Zeichenfolge eingeben. Microsoft® Visual Studio® .NET verwendet an jedem Zeilenende einen Wagenrücklauf und Zeilenvorschub. Sie benötigen also beides, wenn Sie eine Datei mit dem Editor von Visual Studio .NET erstellen. (Andere Editoren beenden Zeilen u.U. lediglich mit den Zeichen für eine neue Zeile (ASCII-Code 10 oder Zeilenvorschub).

Die einzige Ausnahme der Regel "Keine Escape-Zeichenfolge" bei wörtlichen Zeichenfolgenliteralen ist, dass Sie ein doppeltes Anführungszeichen in eine wörtliche Zeichenfolge einfügen können:

@"This is a ""quote"" from me."
// ist gleich "This is a \"quote\" from me."

Zeichenfolgenoperationen in C#
C# unterstützt die folgenden Zeichenfolgenoperationen in der Sprache:

  • Indizieren einer Zeichenfolge zum Lesen (nicht Schreiben) der einzelnen Zeichen, z.B. in s[i].

  • Verketten von zwei Zeichenfolgen mit dem +-Operator, z.B. in s + t. Bei einem s oder t kann es sich um einen anderen Typ als eine Zeichenfolge handeln - ist dies bei einem der beiden der Fall, wird es durch Aufrufen von ToString in eine Zeichenfolge konvertiert.
    Der +-Operator wird als Teil der C#-Sprache implementiert, nicht als Member der String-Klasse. Ist einer der Operanden Null (im Gegensatz zu einer leeren Zeichenfolge ""), wird er in eine leere Zeichenfolge konvertiert. Wenn sich die Operation zur Kompilierungszeit ausführen lässt, wird sie auch ausgeführt.

  • Gleichheit und Ungleichheit, wie in s == t und s != t. Diese Operatoren sind Teil der String-Klasse und können nicht nur von jeder Sprache verwendet werden, die überladene Operatoren unterstützt, sondern auch von Sprachen, die keine überladenen Operatoren unterstützen, z.B. Microsoft® Visual Basic® .NET. Im letzteren Fall werden die Membernamen op_Equality und op_Inequality anstelle der Operatorensyntax verwendet. Diese Operatoren rufen String.Equals auf, die einen binären und keinen länderspezifischen Vergleich der Zeichen in den beiden Zeichenfolgen vornimmt.

Die Verkettung wird, wenn möglich, zur Kompilierungszeit ausgeführt. Sie können auch jedes beliebige Objekt mit einer Zeichenfolge verketten. Dadurch wird der Rückgabewert von der ToString-Methode des Objekts verkettet. Beispielsweise gilt Folgendes:

string s0 = " Hello ";
string s1 = s0 + 5;   // " Hello 5"
string s2 = 6.3 + s1;   // "6.3 Hello 5"
string ret = String.Format("s0: {0}\ns1: {1}\ns2: {2}", s0, s1, s2);

Da Zeichenfolgen unveränderlich sind, führen der Compiler und die Laufzeit doppelte Zeichenfolgenliterale zusammen, so dass jeweils nur eine Kopie der Literale in Ihrem Programm vorhanden ist.

Zeichenfolgen in Visual Basic .NET

Zeichenfolgenliterale in Visual Basic .NET
Zeichenfolgenliterale in Visual Basic .NET sind einfach strukturiert. Sie beginnen mit einem doppelten Anführungszeichen gefolgt von Unicodezeichen, denen wiederum ein doppeltes Anführungszeichen folgt. Wenn Sie in eine Zeichenfolge ein doppeltes Anführungszeichen einfügen möchten, geben Sie zwei doppelte Anführungszeichen ein. Beispiel:

"This prints ""Hello, world!"" on the screen"

Mit Ausnahme der doppelten Anführungszeichen gibt es keinen Escape-Zeichenfolgenmechanismus für Zeichenfolgen oder Zeichenliterale in Visual Basic .NET. Dies ist vergleichbar mit den wörtlichen Zeichenfolgenliteralen in C#, allerdings können. Zeichenfolgenliterale in Visual Basic .NET keine Zeilenendezeichen beinhalten - sie dürfen nicht länger als eine Zeile sein.

Wenn Sie Zeichen angeben müssen, die Sie in einem Visual-Basic-.NET-Programm nicht darstellen können, z.B. ein Zeilenvorschubzeichen, müssen Sie das Zeichen mit der Chr- oder ChrW-Funktion im Code erstellen und anschließend mit der Zeichenfolge verketten.

Bei Verwendung eines Wagenrücklaufs (Chr(13)) werden die beiden Zeilen auf dem Bildschirm überschrieben, da ein Wagenrücklauf nicht automatisch in eine neue Zeile springt. Verwenden Sie die Environment.NewLine-Eigenschaft, wenn Sie einen Wagenrücklauf (Carriage Return, CF) und einen Zeilenvorschub (Line Feed, LF) angeben möchten:

"First line" & Chr(10) & "Second line" ' Nur LF
"First line" & Environment.NewLine & "Second line" ' CR/LF

Zeichenfolgenoperationen in Visual Basic .NET
Visual Basic .NET unterstützt neben allen Zeichenfolgenoperatoren von C# auch noch einige Operatoren, die nicht von C# unterstützt werden. Zu den von Visual Basic .NET unterstützen Operatoren gehören:

  • Ein String kann mit dem +-Operator mit einem String verkettet werden, z.B. in s + t. Dieser Operator kann Zeichenfolgen nur dann verketten, wenn es sich bei beiden Operanden um Zeichenfolgen handelt. Ist einer der Operanden keine Zeichenfolge, versucht Visual Basic .NET, die Zeichenfolge in Double zu konvertieren und eine numerische Addition auszuführen. Verwenden Sie daher für Verkettungen vorzugsweise den &-Operator (siehe nachfolgende Beschreibung).

  • Zwei beliebige Objekte können mit dem &-Operator verkettet werden, z.B. in s & "There". Handelt es sich bei den Operanden des &-Operators nicht um Zeichenfolgen, werden sie in solche konvertiert. Sie können also sogar die Zeichenfolgendarstellungen von zwei Zahlen, z.B. x und y, mit einer Syntax wie x & y verketten. Dieser Operator wird bevorzugt bei Verkettungen eingesetzt, da er eindeutig ist und die Verkettung immer ausführt.

  • Ein vollständiger Satz an Vergleichen: =, <>, >, <, >=, <=. Diese führen je nach Kompilierungsoption und Option Compare-Anweisung, falls vorhanden, einen binären oder einen (von den Ländereinstellungen abhängigen) Textvergleich durch. StrComp führt ebenfalls Zeichenfolgenvergleiche durch. Dabei wird entweder mit Option Compare die Art des Vergleichs festgelegt, oder es wird ein Parameter übergeben, der die zu verwendende Vergleichsmethode anzeigt.

  • Mit dem Like-Operator können Sie festlegen, ob eine Zeichenfolge einem Muster entspricht, das von einer vereinfachten regulären Sprache beschrieben wird. Da die von System.Text.RegularExpressions.RegEx unterstützte Sprache über eine größere Funktionalität verfügt, sollten Sie bevorzugt diese API verwenden.

  • Visual Basic .NET besitzt keinen Indexer, mit dem Sie unter Verwendung von Arraysubskripts auf einzelne Zeichen von Zeichenfolgen zugreifen können. Mit der Chars-Eigenschaft können Sie jedoch einzelne Zeichen von Zeichenfolgen abrufen sowie einzelne Zeichen von StringBuilder abrufen/festlegen.

Eigene Zeichenfolgefunktionen und Anweisungen in Visual Basic .NET
Neben den Operatoren der Visual-Basic-.NET-Sprache steht Ihnen eine Vielzahl weiterer Funktionen und Anweisungen zum Bearbeiten von Zeichenfolgen zur Verfügung. Diese stehen ausnahmslos nur in Visual Basic .NET zur Verfügung und sind in der Standardbibliothek von .NET Framework nicht enthalten.

Wenn Sie in Visual Basic .NET programmieren, steht es Ihnen frei, reine Visual-Basic-Versionen oder die Standardversionen von .NET Framework zu verwenden. In einigen Bereichen stehen Ihnen bei Visual Basic jedoch mehr Funktionen als bei .NET Framework zur Verfügung.

Dr. GUI rät Ihnen, wann immer möglich die Standard-APIs des .NET Framework zu verwenden, um Ihre Fähigkeiten so weiter zu entwickeln, dass sie Ihnen später auch bei anderen Sprachen von Nutzen sind.

Andererseits können reine Visual-Basic-Versionen bei der Portierung von älterem Visual-Basic-Code zu Visual Basic .NET höchst praktisch sein, da Syntax und Verhalten der reinen Visual Basic-Versionen mit denen älterer Visual Basic-Versionen vergleichbar sind.

Untergeordnete Zeichenfolgen
Falls Sie jemals in BASIC programmiert haben sollten, erinnern Sie sich sicher an die Funktionen Left, Right und Mid, mit denen Zeichen links, rechts oder aus der Mitte einer Zeichenfolge extrahiert wurden. Vielleicht wissen Sie auch noch, dass Mid links von einem Operator eingesetzt werden kann, um Zeichen in der Mitte der Zeichenfolge zu ändern!

Diese Funktionen stehen Ihnen auch in Visual Basic .NET zur Verfügung. Beachten Sie jedoch, dass der in Mid verwendete Index für das Anfangszeichen 1-basiert und nicht - wie ansonsten in .NET üblich - 0-basiert ist. Der Grund hierfür ist, dass die Mid-Funktion seit ihren Anfängen in BASIC als MID$ 1-basiert ist.

Zur Vermeidung von Komplikationen empfiehlt Ihnen Dr. GUI daher, die Mid-Funktion niemals in einem neuen Code zu verwenden. Setzen Sie sie bevorzugt beim Portieren von bereits bestehendem Code ein - der dauernde Wechsel zwischen der 1-basierten und der 0-basierten Zählung beim Debuggen zehrt genug an den Nerven!

Die String.SubString-Methode ermöglicht Überladungen, die ein großartiger Ersatz für die Funktionen Left und Mid sind. Verwenden Sie statt Left ganz einfach str.Substring(0, len), und anstelle von Mid verwenden Sie str.SubString(start, len), wobei Sie daran denken müssen, den Anfangspunkt um eine Stelle anzupassen, da Substring den Anfangspunkt auf Null setzt und Mid auf Eins.

Die Right-Methode ist etwas komplizierter, da Sie hier die Anfangsposition berechnen müssen. Beispiel:

Dim s As String = "Hello, world!"
Dim t1 As String = s.Substring(s.Length - subLen)
      ' entspricht dem Folgenden
Dim t2 As String = Right(s, subLen)
Dim ret As String = String.Format("s0: {0}\nt1: {1}\nt2: {2}", s, t1, t2)
ret = ret.Replace("\n", Environment.NewLine)

Beachten Sie den kleinen Trick, den Dr. GUI hier angewendet hat: Obwohl Visual Basic .NET über keine Escape-Zeichenfolge für das Zeilenumbruchzeichen verfügt, wurde die Escape-Zeichenfolge ("\n") dennoch angegeben. Anschließend wurden alle Escape-Zeichenfolgen durch die Zwei-Zeichen-Zeichenfolge Environment.NewLine ("\r\n") ausgetauscht, bevor die Zeichenfolge zurückgegeben wurde. Wenn die Ausgabezeichenfolge exakt derjenigen in der C#-Version entsprechen soll, müssen Sie "\n" nicht durch Environment.NewLine, sondern durch Chr(10) austauschen.
Die Mid-Anweisung, mit der Zeichen in einer Zeichenfolge ersetzt werden, ist etwas schwieriger auszutauschen. Sie können mit String.Remove die zu ersetzenden Zeichen entfernen und mit String.Insert die neuen Zeichen einfügen, dazu müssen jedoch zwei neue Zeichenfolgen erstellt werden. Praktischer ist stattdessen die Erstellung eines StringBuilder von der ersten untergeordneten Zeichenfolge, die geändert werden soll. Daran wird die Ersetzung angehängt, an die wiederum das Ende der ursprünglichen Zeichenfolge angehängt wird. Beispiel:

Dim s As String = "123456xxx0"
' Untergeordnete Zeichenfolge ist NULL-BASIERT
Dim sb As StringBuilder = New StringBuilder(s.Substring(0, 6))
sb.Append("789")
sb.Append(s.Substring(9, 1)) ' 0-basiert, 10. Zeichen
s = sb.ToString()
' entspricht Mid(s, 7, 3) = "789" ' 1-basiert
Dim t As String = "123456xxx0"
Mid(t, 7, 3) = "789"
Dim ret As String = String.Format("s: {0}\nt: {1}", s, t)
ret = ret.Replace("\n", Environment.NewLine)

Eine äußerst eigenartige Funktion
Visual Basic .NET verfügt über eine recht eigenartige Funktion namens StrConv. Sie konvertiert eine Zeichenfolge in eine andere Zeichenfolge und verwendet dabei eine Vielzahl von Konvertierungen, die durch eine Reihe von Bits festgelegt sind. Konvertiert wird unter Verwendung der Dateisystemregeln oder landesspezifischen Regeln in Groß- oder Kleinbuchstaben (wobei in letzterem Fall der Anfangsbuchstabe jedes Wortes groß geschrieben wird), sowie mittels verschiedener Konvertierungen, die nur sinnvoll sind (und auch nur dann funktionieren), wenn Sie eine entsprechende ostasiatische Sprache (wie Japanisch, Chinesisch oder Koreanisch) verwenden.

In diesem Fall wird in Symbolzeichen sowie von Katakana in Hiragana und umgekehrt konvertiert (nur Japanisch). Angeblich ist eine Konvertierung aus und in vereinfachte und traditionelle chinesische Zeichen möglich, allerdings wurde Dr. GUI mitgeteilt, dass dies nicht besonders zuverlässig funktioniert. Aus diesem Grund sollten Sie auf eine entsprechende Verwendung verzichten.

In der API von .NET Framework stehen für die meisten dieser Konvertierungen keine Entsprechungen zur Verfügung. Konvertiert wird jedoch mit der LCMapString-API von Windows. Wenn Sie also unbedingt aus einer anderen .NET-Sprache als Visual Basic konvertieren möchten, nutzen Sie die Interoperabilität der Plattform-API, um LCMapString aufzurufen (so wie dies in Visual Basic offensichtlich der Fall ist).

Funktionen, die der .NET Framework-Funktionalität entsprechen
Es gibt eine Vielzahl von Visual-Basic-.NET-Zeichenfolgefunktionen, die der Funktionalität von .NET Framework sehr nahe kommen. In der nachfolgenden Tabelle werden die jeweiligen Visual-Basic-.NET-Funktionen und ihre Entsprechung in .NET Framework aufgeführt.

In einigen Fällen wird der Funktionalität jedoch nicht genau entsprochen. Zudem verfügen die .NET-Framework-Versionen oftmals über zusätzliche Überladungen, die weitere Funktionen ermöglichen. Weitere Informationen finden Sie in der Dokumentation. Die geeignete Methode können Sie der folgenden Tabelle entnehmen.

Tabelle 2. Visual Basic-spezifische Zeichenfolgefunktionen und ihre ähnlichsten .NET Framework-Standardentsprechungen

Visual Basic .NET-Funktion

Semantik

Ähnlichste .NET Framework-Entsprechung

StrReverse

Umkehren der Zeichenfolge

Keine - Verwenden Sie StringBuilder, und bilden Sie eine Schleife zur Umkehrung, indem Sie die Zeichen an Ort und Stelle umkehren

InStr, InStrRev

Suchen nach erstem/letztem Index der untergeordneten Zeichenfolge

IndexOf, LastIndexOf

LCase, UCase

Konvertieren in Groß-/Kleinbuchstaben

ToLower, ToUpper

Format, FormatCurrency, FormatNumber, FormatPercent

Formatieren von Werten in Zeichenfolgen entsprechend den jeweiligen Ländereinstellungen

Obj.ToString oder String.Format

Str, Val

Konvertieren von Zahlen in/aus eine(r) Zeichenfolge, unabhängig von den Ländereinstellungen

Eine der o.g. Entsprechungen mit angegebener CultureInfo.Invariant

Trim, LTrim, RTrim (nur Leerzeichen)

Abschneiden von Leerzeichen in Zeichenfolgenenden

String.Trim, String.TrimStart, String.TrimEnd (Zeichen und Leerzeichen)

Len

Ermitteln der Zeichenfolgelänge

String.Length

Space, StrDup

Erstellen einer Zeichenfolge mit mehrfachen Leerzeichen oder anderen Zeichen

String-Konstruktor, der Zeichen und Anzahl aufnimmt

Replace

Ersetzen einer untergeordneten Zeichenfolge in einer Zeichenfolge

Replace in String oder StringBuilder

Split, Join

Erstellen eines Zeichenfolgenarrays durch Unterbrechen einer Zeichenfolge an einem angegebenen Trennzeichen oder Erstellen einer getrennten Zeichenfolge aus einem Zeichenfolgenarray

String.Split, String.Join

Filter

Erstellen eines Zeichenfolgenarrays aus einem anderen Array, das eine untergeordnete Zeichenfolge enthält

Keine Entsprechung - Schreiben Sie eine "for-each"-Schleife, und stellen Sie die Zeichenfolgen u.U. in eine dynamisch erweiterbare ArrayList

AscW, ChrW

Konvertieren einer Unicodeganzzahl in/aus eine(r) Einzelzeichen-Zeichenfolge

Wandeln Sie char in einen Ganzzahltyp oder umgekehrt um

Asc, Chr

Konvertieren einer Codepage-Ganzzahl in/aus eine(r) Einzelzeichen-Zeichenfolge

Führen Sie eine Codierung aus (wird später beschrieben)

CStr

Konvertieren in eine Zeichenfolge

Obj.ToString

Zeichenfolgen mit den Standard-APIs von .NET Framework

Erstellen von "String"-Objekten
In beiden Sprachen können Sie mit der new/New-Anweisung ein String-Objekt erzeugen. Die meisten der CLI-kompatiblen String-Konstruktoren nehmen entweder nichts, ein Zeichen und eine Ganzzahl oder ein Zeichenarray auf. Falls Sie also nicht gerade über ein Zeichenarray verfügen, sollten Sie Ihre Zeichenfolgen mit einer anderen Methode erstellen.

Es gibt keinen Konstruktor, der eine Zeichenfolge aufnimmt. Es existiert allerdings ein Konstruktor, der ein Char und eine Ganzzahlanzahl aufnimmt. In der daraus resultierenden Zeichenfolge wird das Zeichen entsprechend der angegebenen Anzahl wiederholt.

Die am häufigsten verwendeten Methoden initialisieren mit einem Zeichenfolgenliteral und weisen einen Wert von einer anderen Zeichenfolge zu:

[C#]
string s = "Hello, world!";
string t = s;   // keine Kopie; s und t verweisen auf dieselbe Zeichenfolge
string ret = String.Format("s and t refer to same: {0}",
   Object.ReferenceEquals(s, t));

[Visual Basic .NET]
Dim s as string = "Hello, world"
Dim t as string = s ' keine Kopie; s und t verweisen auf dieselbe Zeichenfolge
Dim ret as string = String.Format("s and t refer to same: {0}", s Is t)

Wann ist ein Klon kein Klon?
Was geschieht, wenn Sie zwei separate Zeichenfolgen mit jeweils demselben Wert haben möchten? Nun, für gewöhnlich kommt dies nicht vor. Warum unnötig Speicher verschwenden? Da Zeichenfolgen zudem unveränderlich sind, macht es nicht viel Sinn, zwei einzelne Zeichenfolgen mit demselben Wert zu haben.

Obwohl IClonable von String implementiert wird, gibt String.Clone lediglich einen Verweis auf dieselbe Zeichenfolge zurück, ohne sie zu klonen.

Eine Möglichkeit gibt es aber doch: Wenn Sie unbedingt auf eine zweite Kopie der Zeichenfolge bestehen, können Sie die statische Copy-Methode verwenden. Wir überprüfen die Verweisgleichheit auf zwei Arten: zum einen durch Aufrufen von Object.ReferenceEquals, zum anderen durch Umwandeln der Verweise in object, bevor die Gleichheit in C# getestet wird, und durch Verwenden des Is-Operators in Visual Basic.

[C#]
string s = "Hello";
string t = (string)s.Clone();   // keine Kopie; s und t verweisen auf dieselbe Zeichenfolge
string u = String.Copy(s); // erstellt Kopie; s und u verweisen auf versch. Objekte
string ret = String.Format("s same as t: {0}, s same as u: {1}",
   Object.ReferenceEquals(s, t), (object)s == (object)u);

[Visual Basic .NET]
Dim s as string = "Hello"
Dim t as string = CStr(s.Clone()) ' keine Kopie; s und t verweisen auf dieselbe Zeichenfolge
Dim u as string = String.Copy(s)  ' erstellt Kopie; s und u verweisen auf 2 Objekte
Dim ret as string = String.Format("s same as t: {0}, s same as u: {1}", _
       Object.ReferenceEquals(s, t), s Is u)

Sie können auch Teile der Zeichenfolge oder die gesamte Zeichenfolge mit der String.CopyTo-Methode in ein Zeichenarray kopieren. Verwenden Sie einen Zeichenfolgenkonstruktor, der ein Zeichenarray als Parameter aufnimmt, um eine Zeichenfolge aus einem Zeichenarray oder Teilen daraus zu erstellen.

Andere Schnittstellen plus Eigenschaften und ein Feld
Wie wir bereits gesehen haben, wird ICloneable von String implementiert - wenn auch auf eine etwas eigenartige (aber sinnvolle) Art und Weise. String implementiert zudem auch IComparable. Sie können also zwei Zeichenfolgen mit der CompareTo-Methode (wird später beschrieben) von IComparable vergleichen. Obwohl IConvertable von String implementiert wird, sollten Sie die Methoden in der Convert-Klasse verwenden, um eine Zeichenfolge mit den To.-Methoden in alle integrierten Wertetypen zu konvertieren.

String besitzt außerdem einige interessante Eigenschaften. Sie können die Länge (in Zeichen, nicht in Byte) einer beliebigen Zeichenfolge ermitteln, indem Sie deren schreibgeschützte Length-Eigenschaft aufrufen. Außerdem können Sie nacheinander die einzelnen Zeichen der Zeichenfolge über die Chars-Indexereigenschaft aufrufen, die dem C#-Indexer zugeordnet und ebenfalls schreibgeschützt ist:

[C#]
string s = "Hello, world!";
StringBuilder sb = new StringBuilder(String.Format(
"Length of \"Hello, world!\" is {0}\n", s.Length)); // 13
for (int i = 0; i < s.Length; i++)
   sb.AppendFormat("{0} ", s[i]);

[Visual Basic .NET]
Dim s as string = "Hello, world!"
Dim sb as StringBuilder = new StringBuilder( _
String.Format("Length of ""Hello, world!"" is {0}", s.Length)) ' 13
sb.Append(Environment.NewLine)
Dim i as Integer
For i = 0 to s.Length - 1
   sb.AppendFormat("{0} ", s.Chars(i))
Next

Da Zeichenfolgezeichen auch in Visual Basic .NET ab Null indiziert werden, muss die Schleife entsprechend sorgfältig geschrieben werden (in C# entspricht dies der Verwendung des <-Operators anstelle von <=).

Zudem gibt es ein interessantes statisches Feld namens Empty, das die leere Zeichenfolge enthält. Auf diese Weise können Sie eine leere Zeichenfolge ("") sprachenunabhängig darstellen.

Zeichenfolgengleichheit/Vergleichsmethoden
Zwei Zeichenfolgen können auf vielfältige Art und Weise miteinander verglichen werden. Hinsichtlich Gleichheit und Ungleichheit von Zeichenfolgen ist natürlich einer der Hauptunterschiede, ob der Vergleich nach Verweis (die zwei Zeichenfolgen verweisen auf dasselbe Objekt) oder nach Wert (sie enthalten dieselben Zeichen) durchgeführt wird.

Ein weiterer wesentlicher Unterschied in Bezug auf Gleichheit und relationale Vergleiche besteht darin, dass entschieden werden muss, ob die aktuelle landesspezifische Sortierreihenfolge oder die reinen Ordinalwerte für jedes Zeichen in der Zeichenfolge verwendet werden. (Weniger wichtig ist, ob beim Vergleichen die Groß-/Kleinschreibung beachtet wird.) Gemäß dem Standard verwenden Vergleiche die aktuelle Ländereinstellung des Threads, auf dem sie ausgeführt werden. Außerdem wird die Groß-/Kleinschreibung berücksichtigt. Dies entspricht in der Regel Ihren Anforderungen.
Der ==-Operator generiert einen Aufruf von String.Equals, die einen Vergleich ausführt, der die Ländereinstellungen sowie die Groß-/Kleinschreibung berücksichtigt. Wenn Sie einen Verweisvergleich in C# vornehmen möchten, wandeln Sie beide Zeichenfolgenverweise in Object um, oder verwenden Sie Object.ReferenceEquals. Verwenden Sie in Visual Basic .NET den Is-Operator (in Visual Basic) wie nachfolgend gezeigt, oder verwenden Sie Object.ReferenceEquals. Sie können Object.ReferenceEquals übrigens in beiden Sprachen verwenden.

[C#]
      string s = "Hello", t = "there";
      bool valueComp = (s == t); // Wertevergleich
      bool refComp1 = ((Object)s == (Object)t); // Verweisvergleich
      bool refComp2 = Object.ReferenceEquals(s, t); // Verweisvergleich
      string ret = String.Format("s == t: {0}, " +
         "(object)s == (object)t: {1}, ObjectRefEq(s, t): {2}",
         valueComp, refComp1, refComp2);

[Visual Basic .NET]
Dim s as string = "Hello"
Dim t as string = "there"
Dim valueComp as Boolean = s = t ' Wertevergleich
Dim refComp1 as Boolean = s Is t ' Verweisvergleich
Dim refComp2 as Boolean  = Object.ReferenceEquals(s, t) ' Verw.vergleich
Dim ret as string = _
String.Format("s = t: {0}, s Is t: {1}, ObRefEq(s, t): {2}", _
   valueComp, refComp1, refComp2)

Die Gleichheit-, Ungleichheit- und Vergleichsoperatoren von Visual Basic .NET (=, <>, >, <, >=, <=) führen je nach Compileroptionen und Option-Compare-Anweisung entweder Ordinalvergleiche oder den Ländereinstellungen entsprechende Vergleiche durch. Wenn Sie einen Verweisvergleich durchführen möchten, müssen Sie den Is-Operator verwenden. Visual Basic .NET verfügt zudem über einen Like-Operator für Zeichenfolgenvergleiche, bei denen einfache Mustervergleiche vorgenommen werden.

Von der Equals-Methode stehen verschiedene Typen zur Verfügung. Es gibt zwei Instanzenmethoden: Eine nimmt einen String als Parameter und die andere ein Objekt auf (das auf einen String verweisen muss). Außerdem existiert auch eine statische Version von Equals, der zwei Zeichenfolgen mitgegeben werden können. Die Version, die ein Objekt aufnimmt, wird überschrieben (ursprünglich definiert in Objekt). Die Version, die ein String aufnimmt, ist schneller, da keine Konvertierung erforderlich ist. An die statische Version kann null/Nothing übergeben werden, ohne eine Ausnahme zu verursachen.

Es gibt drei Vergleichsmethoden: Compare, CompareOrdinal und CompareTo. Sie alle geben eine negative Zahl zurück, wenn die erste Zeichenfolge kleiner ist als die zweite, Null, wenn beide denselben Wert haben, und eine positive Zahl, wenn die erste Zeichenfolge größer ist als die zweite.

Bei Compare handelt es sich um eine Reihe überladener, statischer Methoden, die Vergleiche durchführen, bei denen die jeweiligen Ländereinstellungen sowie die Groß-/Kleinschreibung berücksichtigt werden. Alle Überladungen vergleichen mindestens zwei Zeichenfolgen. Einige Überladungen verarbeiten zudem einen booleschen Wert, der die Berücksichtigung der Groß-/Kleinschreibung angibt, sowie Int32 zur Angabe der zu vergleichenden Indizes und Länge von untergeordneten Zeichenfolgen (statt die gesamte Zeichenfolge zu vergleichen).

CompareOrdinal besteht aus zwei überladenen statischen Methoden, die Ordinalvergleiche von zwei Zeichenfolgen oder untergeordneten Zeichenfolgen in den beiden Zeichenfolgen vornehmen.

CompareTo ist eine Instanzenmethode, die IComparable implementiert. Sie vergleicht die aktuelle Zeichenfolge unter Berücksichtigung der jeweiligen Ländereinstellungen und der Groß-/Kleinschreibung mit der Zeichenfolge oder dem Objekt, das als Parameter übermittelt wurde.

Durchsuchen einer Zeichenfolge: EndsWith/StartsWith/IndexOf/LastIndexOf/Substring
Zum Durchsuchen einer Zeichenfolge steht Ihnen eine Vielzahl von Methoden zur Verfügung. EndsWith und StartsWith geben den Wert TRUE zurück, wenn die aktuelle Zeichenfolge mit der angegebenen Zeichenfolge endet/beginnt. Ist dies nicht der Fall, wird FALSE zurückgegeben.

IndexOf und LastIndexOf verfügen beide über viele Überladungen. Jede Methode gibt die erste/letzte Position in der aktuellen Zeichenfolge (oder einer ihrer untergeordneten Zeichenfolgen) zurück, an der die Zeichenfolge (oder das Zeichenarray) vorkommt.

Substring ist vergleichbar mit der alten MID$-Funktion von GW-BASIC und der Mid-Funktion von Visual Basic .NET. Allerdings ist der Index in der Zeichenfolge 0-basiert und nicht, wie in Mid/MID$, 1-basiert. Es gibt zwei Überladungen: Eine erzeugt und gibt eine neue Zeichenfolge zurück, die die untergeordnete Zeichenfolge vom angegebenen Index bis zum Ende der Zeichenfolge enthält. Die andere erzeugt und gibt eine neue Zeichenfolge zurück, die die untergeordnete Zeichenfolge der angegebenen Länge ab dem angegebenen Index enthält.

Formatieren
Die String-Klasse besitzt eine Reihe von statischen Überladungen der Methode Format. Sie verfügen über dieselben Formatierungsmöglichkeiten wie die, die wir in unseren Aufrufen von Console.WriteLine verwendet haben. Sie erstellen und geben eine neue Zeichenfolge zurück, in der der Formatbezeichner durch die Zeichenfolgendarstellung der verbleibenden Parameter ersetzt wird. Sie können z.B. Folgendes verwenden:

[C#]
string ret = String.Format("The value is {0}", 5);
// "Der Wert ist 5" (ohne Anführungszeichen)

[Visual Basic .NET]
Dim ret as string = String.Format("The value is {0}", 5)
' "Der Wert ist 5" (ohne Anführungszeichen)

Es gibt natürlich noch andere Methoden zum Formatieren von Daten sowie weitere Aspekte hinsichtlich der Berücksichtigung von Ländereinstellungen. Aus Zeitgründen können wir jedoch in diesem Artikel leider nicht näher darauf eingehen.

Beachten Sie, dass .NET Framework beim Konvertieren und Formatieren generell die jeweiligen Ländereinstellungen berücksichtigt, solange Sie der Formatierungsmethode nicht CultureInfo.InvariantCulture übergeben.

Achtung: die integrierten Methoden von Visual Basic .NET verwenden standardmäßig oftmals invariante Ländereinstellungen!

Analysieren
Sie können eine Zeichenfolge unter Verwendung der Parse-Methode der Klasse, in die Sie konvertieren möchten, in viele verschiedene Typen konvertieren. Wenn Sie z.B. eine Ganzzahl konvertieren möchten, verwenden Sie die Int32.Parse-Methode. Beachten Sie, dass Konvertierungen auch auf andere Art und Weise ausgeführt werden können, z.B. mit den Methoden in der Convert-Klasse. In einigen Fällen können Sie auch das Objekt (in C#) umwandeln oder die Visual Basic-Funktionen CType oder CStr verwenden.

Auffüllen und Kürzen
Zum Auffüllen des rechten oder linken Bereichs einer Zeichenfolge mit Leerzeichen (oder anderen gewünschten Zeichen) stehen Ihnen die Methoden PadLeft und PadRight zur Verfügung. Ferner existieren verschiedene Methoden zum Abschneiden der Leerzeichen oder anderen angegebenen Zeichen am Anfang und/oder Ende einer Zeichenfolge (TrimStart, TrimEnd und Trim). Sie alle erzeugen eine neue Zeichenfolgen und geben sie zurück.

Insert/Remove/Replace/Concat
Diese Methoden ähneln denen in StringBuilder, obwohl sie in String weniger Überladungen als in StringBuilder enthalten. Weitere Informationen finden Sie im nachfolgenden Abschnitt "StringBuilder".

Insert erzeugt eine neue Zeichenfolge, bei der die angegebene Zeichenfolge an der angegebenen Position eingefügt wird. Remove erstellt eine neue Zeichenfolge, bei der die angegebene Anzahl von Zeichen an der angegebenen Position entfernt wird. Replace erstellt und gibt eine neue Zeichenfolge zurück, bei der alle Vorkommen eines angegebenen Zeichens oder einer angegebenen Zeichenfolge durch ein anderes Zeichen bzw. eine andere Zeichenfolge ersetzt werden. Die verschiedenen Überladungen der statischen Concat-Methode erstellen und geben neue Zeichenfolgen zurück, indem sie die Zeichenfolgen und/oder Objekte verketten, die die Methode übermittelt hat.

Split/Join
Split und Join sind leistungsstarke Methoden: Die statische Join-Methode gibt eine Zeichenfolge zurück, die durch Verketten von Teilen der Zeichenfolgen oder der gesamten Zeichenfolgen in dem Zeichenfolgenarray entsteht, das sie übermittelt hat. Dabei wird eine angegebene Zeichenfolge als Trennzeichen verwendet. Split trennt eine Zeichenfolge in ein neu angelegtes und zurückgegebenes Zeichenfolgenarray, wobei der angegebene Trennzeichensatz verwendet wird.

Konvertierungen
String enthält keine direkt verfügbaren Konvertierungsmethoden. Die Convert-Klasse verfügt jedoch über eine Vielzahl von static/Shared-Konvertierungsmethoden, die zum größten Teil in einen integrierten Typ konvertieren und die Form To. haben. Die Liste zur Konvertierung in integrierte Typen und Zeichenfolgen umfasst ToBoolean, ToByte, ToChar, ToDecimal, ToDouble, ToInt16, ToInt32, ToInt64, ToSByte, ToSingle, ToString, ToUInt16, ToUInt32 und ToUInt64.

Es existieren auch eine Methode zum Konvertieren in ein DateTime-Objekt - ToDateTime - sowie Methoden (FromBase64String und ToBase64String) zur Konvertierung zwischen Bytearrays und Base-64-codierten Zeichenfolgen (nützlich beim Übertragen von Binärdaten über Textprotokolle).

String enthält eine ToCharArray-Methode zur Konvertierung in ein Zeichenarray. Außerdem stehen Ihnen noch Methoden zum Konvertieren der Zeichenfolge in Groß- oder Kleinbuchstaben zur Verfügung: ToUpper und ToLower.

Intern/IsInterned
Die .NET-Laufzeit verwaltet in der Anwendungsdomäne einen Pool mit Literalzeichenfolgen (in etwa vergleichbar mit einem Prozess). Wenn eine Assembly, z.B. Ihr Programm, in eine Anwendungsdomäne geladen wird, werden die Zeichenfolgenliterale der Assembly im Zeichenfolgenliteral-Pool der Anwendungsdomäne zusammengeführt.

Dadurch können keine doppelten Zeichenfolgenliterale entstehen. Da Zeichenfolgen unveränderlich sind, müssen die Ergebnisse Ihres Programms auch nicht geändert werden. Da alle Zeichenfolgenliterale interniert sind, können Sie zudem korrekte Verweisvergleiche von Zeichenfolgenliteralen ausführen, da von jedem Zeichenfolgenliteral nur eine Kopie existiert.

Wenn Sie jedoch selbst eine Zeichenfolge anlegen - z.B. mit einer der String-Methoden zum Erzeugen neuer Zeichenfolgen oder mit einem StringBuilder - unterscheidet sie sich von der Zeichenfolge mit demselben Wert im Literalpool (falls vorhanden).

Verweisvergleiche schlagen also fehl. Dies könnte von Bedeutung sein, denn Verweisvergleiche sind weitaus schneller als Wertevergleiche, da lediglich die Adresse verglichen werden muss.

Wenn Ihr Code also wirklich schnell ausgeführt werden soll, sollten Sie Verweisvergleiche verwenden, falls diese tatsächlich funktionieren!

Wenn Sie Ihre Zeichenfolgen dem Literalpool hinzufügen möchten, können Sie hierzu die statische Intern-Methode verwenden, die die Zeichenfolge dem Literalpool hinzufügt (falls dort nicht bereits vorhanden) und einen Verweis auf die Zeichenfolge im Literalpool zurückgibt. Beispiel:

[C#]
string s2 = new StringBuilder().Append("Foo").Append("Bar").ToString();
string s3 =String.Intern(s2);   // Verweis an Literalpool zurückgeben
string s = "FooBar";            // befand sich im Literalpool
StringBuilder sb = new StringBuilder();
sb.Append(Object.ReferenceEquals(s2, s));   // false: verschieden
sb.Append(", ");
sb.Append(Object.ReferenceEquals(s3, s));   // true: gleich
[Visual Basic .NET]
Dim s2 as string = New _
     StringBuilder().Append("Foo").Append("Bar").ToString()
Dim s3 as string = String.Intern(s2) ' Verweis an Literalpool zurückgeben
Dim s as string = "FooBar"  ' befand sich im Literalpool
Dim sb as new StringBuilder()
sb.Append(s2 Is s) ' false: verschieden
sb.Append(", ")
sb.Append(s3 Is s) ' true: gleich

Außerdem können Sie mit der statischen IsInterned-Methode prüfen, ob eine Zeichenfolge bereits im Pool vorhanden ist. Sie gibt den Wert TRUE zurück, wenn dies der Fall ist.

GetHashCode
Vielleicht erinnern Sie sich noch, dass wir im letzten Artikel darauf hingewiesen haben, dass Sie, wenn Sie Equals überschreiben, auch GetHashCode überschreiben sollten. In String werden Equals und GetHashCode überschrieben, wodurch ein gutes Hashing und eine hohe Leistung erzielt werden.

StringBuilder

Wahrscheinlich haben Sie bemerkt, dass viele der Methoden in String neue Zeichenfolgen anlegen und zurückgeben. Und wie Sie sicher ahnen, kann dies teuer werden, wenn Sie eine große Anzahl von Zeichenfolgen zuweisen und verwerfen.
Halten Sie sich an folgende Regel: Wenn Sie nur eine Zeichenfolgenoperation für eine bestimmte Zeichenfolge ausführen, bei der eine neue Zeichenfolge angelegt wird, verwenden Sie dazu die geeignete Methode in String (oder die entsprechende Visual-Basic-.NET-Funktion).

Wenn Sie jedoch mehrere Operationen ausführen und die Operationen, die Sie benötigen, in System.Text.Stringbuilder verfügbar sind, sollten Sie einen StringBuilder aus Ihrer Zeichenfolge erzeugen, die erforderlichen Operationen im StringBuilder ausführen und anschließend ToString für den StringBuilder aufrufen, damit die Ergebniszeichenfolge zurückgegeben wird. Im nachfolgenden Beispiel geschieht dies alles in einer einzigen Zeile!
Im Allgemeinen erzeugt man eine Zeichenfolge in einem StringBuilder, bearbeitet sie und konvertiert sie in eine Zeichenfolge. ToString kopiert allerdings die Zeichenfolge erst dann, wenn Sie dasselbe StringBuilder-Objekt zu einem späteren Zeitpunkt ändern, ein recht effizienter Vorgang - der Overhead zur Verwendung von StringBuilder umfasst in der Regel einen Kopiervorgang, nicht zwei. Aus diesem Grund verwenden wir die "Eine-Operation-Regel". Bei zwei oder mehr Operationen können Sie ebenso gut einen StringBuilder verwenden.

Außerdem können Sie einen StringBuilder einsetzen, wenn die verfügbaren Überladungen merklich einfacher zu verwenden sind als die eingeschränkteren Überladungen in String.

Bei der Verwendung von StringBuilder müssen Sie System.Text; (Imports System.Text in Visual Basic) am Anfang Ihrer Programmdatei angeben.

StringBuilder besitzt mehrere Konstruktoren, die das Objekt aus einer Zeichenfolge initialisieren sowie seine Kapazität und maximale Kapazität festlegen können. Die standardmäßige maximale Kapazität umfasst ca. zwei Milliarden Zeichen. Es ist also von Vorteil, hier einen geringeren Wert anzugeben, obwohl der hohe Wert keine Leistungseinbußen verursacht. Die Kapazität des Objekts wird nach oben hin nach Bedarf angepasst, solange Sie die maximale Kapazität nicht überschreiten. Eine Anpassung der maximalen Kapazität ist nach dem Konstruieren von StringBuilder nicht mehr möglich.

Es gibt vier Eigenschaften: Capacity (mit Lese- oder Schreibzugriff), MaxCapacity (schreibgeschützt), Length (die aktuelle Länge der Zeichenfolge, die länger oder kürzer eingestellt werden kann) und Chars (ein Indexer, mit dem Sie einzelne Zeichen lesen und schreiben können). Mit der EnsureCapacity-Methode können Sie die Kapazität erhöhen, falls sie nicht bereits ausreichend hoch ist.

Mit der Append-Methode hängen Sie eine Zeichenfolge oder einen beliebigen Typ (es stehen viele Überladungen zur Verfügung) an das Ende von StringBuilder. Wenn Sie einen anderen Typ übermitteln, wird dessen ToString-Methode aufgerufen und das Ergebnis an StringBuilder angehängt.

Mit der AppendFormat-Methode formatieren Sie die Zeichenfolge, die Sie an StringBuilder anhängen. Die Formatierung ist dieselbe wie mit String.Format und Console.WriteLine.

Die vielen Überladungen von Insert ermöglichen es Ihnen, eine Zeichenfolge (unter Umständen vom Aufruf der ToString-Methode Ihres Parameters berechnet) an einer beliebigen Stelle in StringBuilder einzufügen.

Mit Remove entfernen Sie eine beliebige Anzahl von Zeichen aus beliebigen Positionen.
Replace ermöglicht den Austausch einzelner Zeichen oder, wie bereits erwähnt, untergeordneter Zeichenfolgen.
Die Überladungen von ToString erzeugen schließlich ein neues String-Objekt aus dem StringBuilder (oder dessen angegebener untergeordneter Zeichenfolge) und geben es zurück.

Codierung und Decodierung von "System.Text"

Wie Sie bemerkt haben, werden alle Zeichenfolgen in einem .NET Framework-Programm als 16-Bit-Unicode gespeichert. Und wie Sie vielleicht ebenfalls bemerkt haben, verwendet nicht jeder Benutzer Unicode - daher müssen Sie gelegentlich aus einer anderen Zeichencodierung in Unicode oder umgekehrt konvertieren.

Das .NET Framework verfügt über mehrere Klassen zur Codierung (Konvertieren von Unicodezeichen in einen Byteblock einer anderen Codierung) und Decodierung (Konvertieren eines Byteblock in eine Codierung mit Unicodezeichen).

Für jede unterstützte Codierung existiert eine Klasse: ASCIIEncoding, CodePageEncoding, UnicodeEncoding (nützlich beim Konvertieren von Big Endian in Little Endian), UTF7Encoding und UTF8Encoding.

Jede dieser Klassen verfügt über Codierungsmethoden (z.B. GetBytes) und Decodierungsmethoden (z.B. GetChars) zum gleichzeitigen Codieren und Decodieren eines einzelnen Arrays. Daneben unterstützen alle Klassen GetEncoder und GetDecoder, die Codierer und Decodierer zur Verwaltung des Umschaltstatus zurückgeben, weshalb sie für Streams und Blöcke verwendet werden können.

Reguläre Ausdrücke

Wie Sie vielleicht bemerkt haben, unterstützt Visual Basic .NET den eingeschränkten Vergleich regulärer Ausdrücke über die Like-Anweisung. Zusätzlich unterstützt das .NET Framework die komplexe Verarbeitung regulärer Ausdrücke im Namespace System.Text.RegularExpressions. Die wichtigste Klasse hierbei ist System.Text.RegularExpressions.RegEx.

Sie stellt einen kompilierten regulären Ausdruck dar und verfügt über Methoden zu dessen Verwendung, einschließlich dem Suchen und Ersetzen von regulären Ausdrücken in Zeichenfolgen und dem Trennen einer Zeichenfolge in Zeichenfolgenarrays. Reguläre Ausdrücke sind bereits umfassend dokumentiert worden, daher gehen wir an dieser Stelle nicht näher darauf ein. Vielleicht behandeln wir dieses Thema in einer zukünftigen Kolumne.

Versuchen Sie es einfach mal!


Wer gehört zu Ihrem .NET-Framework-Lernteam?
Dr. GUI hofft, dass Sie nicht nur ein wenig mit .NET herumexperimentieren, sondern auch zusammen mit anderen Benutzern mehr über .NET erfahren möchten. Das ist nämlich viel kurzweiliger, und Sie lernen auch viel mehr!

Was es auszuprobieren gilt...
Schauen Sie sich doch einmal die Quelldatei an. Kopieren Sie sie in Visual Studio, und verändern Sie sie nach Belieben.

Experimentieren Sie mit einigen Zeichenfolgen oder vielleicht auch mit Zeichenfolgenarrays.

Verändern Sie Zeichenfolgen mit StringBuilder. Verwenden Sie die erweiterten Funktionen von String zum Verarbeiten einer Zeichenfolge oder auch einer Befehlszeile.

Sollte Ihnen der Sinn nach mehr Spaß stehen, codieren und decodieren Sie doch einmal unterschiedliche Zeichensätze und Codepages. Eine richtige Herausforderung ist die Arbeit mit den Klassen der regulären Ausdrücke.

Die nächsten Schritte

In diesem Artikel haben wir Zeichenfolgen behandelt. Beim nächsten Mal geht es um Arrays.


Anzeigen: