Dr. GUI .NET #5

Artikel
07/13/2006

31. Mai 2002

Inhalte

Wo wir waren; Wohin wir gehen
Zeichenfolgen
Die System.String-Klasse
Zeichenfolgen in C#
Zeichenfolgen in Visual Basic .NET
Zeichenfolgen mit Standard-.NET Framework-APIs
StringBuilder
System.Text Encoder und Decoder
Reguläre Ausdrücke
Versuch es doch mal!
Was wir getan haben; Was kommt als nächstes

Sprechen Sie aus! Verwende die Quelle, Luke!

Wenn Sie etwas sagen möchten, teilen Sie uns (und der Welt) mit, was Sie über diesen Artikel auf dem Dr. GUI .NET-Meldungsboard halten.

Sehen Sie sich auch die Beispiele an, die als Microsoft® ASP.NET-Anwendungen mit Quellcode ausgeführt werden, oder werfen Sie einfach einen Blick auf die Quelldatei in einem neuen Fenster.

Wo wir waren; Wohin wir gehen

Beim letzten Mal haben wir die Mutter und den Vater aller .NET-Klassen besprochen: das ehrwürdige System.Object. Wir haben auch die Speicherbelegung und Garbage Collection sowie ein wenig über die Funktionsweise des dynamischen Typsystems im .NET Framework.

Dieses Mal werden wir über Zeichenfolgen in der .NET-Runtime sprechen.

Zeichenfolgen

String (oder genauer gesagt System.String) ist der Typ von Zeichenfolgen, einschließlich Zeichenfolgenliteralen, im .NET Framework. Im .NET Framework enthält eine Zeichenfolge 0 oder mehr 16-Bit-Unicode-Zeichen (zwei Byte).

Zeichenfolgen sind unveränderlich

Eine der schwer zu gewöhnlichen Dingen in der .NET Framework besteht darin, dass String-Objekte unveränderlich sind, d. h., sobald sie erstellt wurden, können ihre Werte nicht mehr geändert werden. (Sie können den Zeichenfolgenverweis jedoch erneut zuweisen, um auf eine andere Zeichenfolge zu verweisen, wodurch die erste Zeichenfolge für die Garbage Collection freigegeben wird, wenn keine anderen Verweise darauf vorhanden sind.)

Die Methoden von String , die die Zeichenfolge zu bearbeiten scheinen, ändern die aktuelle Zeichenfolge nicht. Stattdessen erstellen sie eine neue Zeichenfolge und geben sie zurück. Selbst das Ändern, Einfügen oder Löschen eines einzelnen Zeichens führt dazu, dass eine neue Zeichenfolge erstellt und die alte entfernt wird.

Beachten Sie, dass der Prozess des wiederholten Erstellens und Wegwerfens von Zeichenfolgen langsam sein kann. Die Unveränderlichkeit von Zeichenfolgen hat jedoch eine Reihe von Vorteilen, da Probleme mit Besitz, Aliasing und Threading bei unveränderlichen Objekten viel einfacher sind. Für instance sind Zeichenfolgen für die Multithreadprogrammierung immer sicher, da ein Thread nichts tun kann, was einen anderen Thread durch das Ändern einer Zeichenfolge durcheinander bringen würde, da Zeichenfolgen nicht geändert werden können.

StringBuilder zur Rettung

Geben Sie StringBuilder ein. Ein StringBuilder-Objekt ist keine Zeichenfolge, sondern wird verwendet, um Zeichenfolgen aus 16-Bit-Unicode-Zeichen zu bearbeiten. Es enthält einen Puffer, der in der Regel mit einer Zeichenfolge initialisiert wird (aber in der Regel größer als diese Zeichenfolge). Die Zeichen im Puffer können direkt bearbeitet werden, ohne einen neuen Puffer zu erstellen. Sie können Zeichen einfügen, anfügen, entfernen und ersetzen. (Natürlich wird ein neuer Puffer erstellt, wenn Sie genügend Zeichen einfügen, um den ursprünglichen Puffer zu überlaufen.) Wenn Sie die Bearbeitung der Zeichen abgeschlossen haben, verwenden Sie die ToString-Methode von StringBuilder, um die fertige Zeichenfolge daraus zu extrahieren. In den meisten Fällen funktioniert StringBuilder.ToString , ohne einen Kopiervorgang zu verursachen, sodass es sehr effizient ist.

Indizieren von Zeichenfolgen und StringBuildern

Da beide Typen Unicode-Zeichen vom Typ Char enthalten, unterstützen sie einen Indexer namens Chars , der das einzelne Char am angegebenen Index zurückgibt. Wenn Sie C# verwenden, können Sie wie ein Array-Tiefgestellt auf diesen Indexer zugreifen.

Da String unveränderlich ist, ist der Indexer schreibgeschützter Wert. Natürlich ist der StringBuilder-Indexer lese-/schreibzugriff, sodass Sie Zeichen anzeigen und ändern können.

Die System.String-Klasse

System.String ist eine versiegelte Klasse, was bedeutet, dass Sie nicht von ihr erben können (was auch bedeutet, dass das System bestimmte Optimierungen durchführen kann, um die Zeichenfolgenverarbeitung zu beschleunigen).

Die meisten .NET-Sprachen verfügen über eine integrierte Unterstützung für Zeichenfolgen. Für instance unterstützen sie in der Regel Zeichenfolgenliterale und Vorgänge wie Verkettung. Die Syntax dafür variiert jedoch von Sprache zu Sprache.

Zeichenfolgen in C#

Zeichenfolgenliterale in C#

C# unterstützt zwei Typen von Zeichenfolgenliteralen: "reguläre" Zeichenfolgenliterale und "verbatim"-Zeichenfolgenliterale.

Reguläre Zeichenfolgenliterale ähneln Zeichenfolgenliteralen in C und C++: Sie sind durch Anführungszeichen getrennt und können Escapesequenzen enthalten, um verschiedene Steuerzeichen und unicode-Zeichen darzustellen. Sie können nicht auf eine neue Zeile erweitert werden, aber benachbarte Zeichenfolgenliterale können zur Kompilierzeit mit dem + Operator verkettet werden. Die Escapesequenzen beginnen alle mit einem umgekehrten Schrägstrich ("\") und werden in der folgenden Tabelle aufgeführt.

Tabelle 1. Escapesequenzen für C#-Zeichenfolgenliterale

Escapesequenz	BESCHREIBUNG
\t	TAB (Unicode-0x0009).
\r	Wagenrücklauf (0x000d).
\n	Zeilenumbruch (Zeilenvorschub) (0x000a).
\v	Vertikale Registerkarte (0x000b).
\a	Warnung (0x0007).
\b	Rücktaste (0x0008).
\f	Formularfeed (0x000c).
\0	NULL (0x0000).
\\	Umgekehrter Schrägstrich (0x005c).
\'	Einfaches Anführungszeichen (0x0027).
\"	Doppeltes Anführungszeichen (0x0022).
\Xd	Hexadezimalzeichencode mit variabler Anzahl von Ziffern.
\uABCD	Unicode-Zeichen 0xABCD (entweder u oder U ist OK, wobei A, B, C und D gültige Hexadezimalstellen 0-9, a-f, A-F sind).

Alle diese Escapesequenzen können in jedem regulären Zeichenfolgenliteral oder in einem beliebigen Zeichenliteral (z. B. "\t") verwendet werden. Darüber hinaus können die Unicode-Escapesequenzen in Bezeichnern verwendet werden, sodass "if (a\U0066b == true)" mit "if (afb == true)" identisch ist (da Unicode-0x0066 "f"). Dadurch können Sie Bezeichner mit einem beliebigen gültigen Unicode-Zeichen schreiben, auch wenn dieses Zeichen auf der Tastatur nicht vorhanden ist oder nicht in der Schriftart angezeigt werden kann, die ihr Editor verwendet.

Wörtliche Zeichenfolgenliterale beginnen mit " und enden mit dem übereinstimmenden Anführungszeichen. Sie verfügen über keine Escapesequenzen. Daher gilt:

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

gleich

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

ist aber viel einfacher und weniger fehleranfällig. Ausführliche Zeichenfolgenliterale können sich auch über einen Zeilenumbruch erstrecken. Wenn dies der Fall ist, enthalten sie Leerzeichen zwischen den Anführungszeichen:

@"First \t line
   tabbed second line"
// same as "First \\t line\r\n\ttabbed second line"

Hinweis Ob Sie "\r" in der zweiten Zeichenfolge benötigen, hängt von Ihrem Editor ab. Microsoft® Visual Studio® .NET verwendet am Ende jeder Zeile ein Wagenrücklauf-/Zeilenvorschubpaar, sodass Sie beides benötigen, wenn Sie die Datei mit dem Visual Studio .NET-Editor erstellen. (Andere Editoren können Zeilen nur mit Zeilenumbruchzeichen (ASCII-Code 10 oder Zeilenvorschub) beenden.

Die einzige Ausnahme von der Regel "keine Escapesequenz" für wörtliche Zeichenfolgenliterale besteht darin, dass Sie ein doppeltes Anführungszeichen in eine wörtliche Zeichenfolge einfügen können , indem Sie sie verdoppeln:

@"This is a ""quote"" from me."
// same as "This is a \"quote\" from me."

Zeichenfolgenvorgänge in C#

C# unterstützt die folgenden Zeichenfolgenvorgänge in der Sprache:

Indizieren einer Zeichenfolge zum Lesen (aber nicht Schreiben) der einzelnen Zeichen, wie in s[i].
Verketten von zwei Zeichenfolgen mit dem + Operator, wie in s + t. Einer von s oder t kann ein anderer Typ als Zeichenfolge sein. Wenn einer ist, wird er in eine Zeichenfolge konvertiert, indem ToString aufgerufen wird. Der + Operator wird als Teil der C#-Sprache implementiert, nicht als Member der String-Klasse . Wenn einer der Operanden NULL ist (im Gegensatz zu einer leeren Zeichenfolge , ""), wird er in eine leere Zeichenfolge konvertiert. Wenn der Vorgang zur Kompilierzeit ausgeführt werden kann, ist er das.
Gleichheit und Ungleichheit, wie in s == t und s != t. Diese Operatoren sind Teil der String-Klasse , sodass sie in jeder Sprache verwendet werden können, die überladene Operatoren unterstützt. Sie können sogar von Sprachen verwendet werden, die keine überladenen Operatoren unterstützen, z. B. Microsoft® Visual Basic® .NET, indem sie die Membernamen op_Equality und op_Inequality anstelle der Operatorsyntax verwenden. Diese Operatoren rufen String.Equals auf, die einen binären Vergleich der Zeichen in den beiden Zeichenfolgen durchführt, nicht einen kulturorientierten Vergleich.

Die Verkettung erfolgt nach Möglichkeit zur Kompilierzeit. Sie können auch jedes Objekt mit einer Zeichenfolge verketten. Dadurch wird der Rückgabewert der ToString-Methode des Objekts verkettet. Für instance sind alle folgenden Elemente gültig:

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 Compiler und Runtime doppelte Zeichenfolgenliterale zusammen, sodass es nur eine Kopie jedes Literals in Ihrem Programm gibt.

Zeichenfolgen in Visual Basic .NET

Zeichenfolgenliterale in Visual Basic .NET

Visual Basic .NET-Zeichenfolgenliterale sind sehr einfach: Sie bestehen aus einem doppelten Anführungszeichen gefolgt von einer Reihe von Unicode-Zeichen gefolgt von einem schließenden doppelten Anführungszeichen. Um ein doppeltes Anführungszeichen in Ihre Zeichenfolge einzuschließen, doppelten Sie diese wie in:

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

Es gibt keinen Escapesequenzmechanismus für Visual Basic .NET-Zeichenfolgen oder Zeichenliterale mit Ausnahme der Verdoppelung des doppelten Anführungszeichens. (Dies ähnelt den wörtlichen C#-Zeichenfolgenliteralen, mit dem Unterschied, dass Visual Basic .NET-Zeichenfolgenliterale keine Zeilenendezeichen enthalten dürfen– sie müssen in einer einzelnen Zeile enthalten sein.) Wenn Sie Zeichen einschließen müssen, die Sie in einem Visual Basic .NET-Programm nicht darstellen können, z. B. ein Zeilenvorschubzeichen, müssen Sie die Chr- oder ChrW-Funktion verwenden, um das Zeichen aus dem zugehörigen Code zu erstellen und dann mit der Zeichenfolge zu verketten. Beachten Sie, dass die Verwendung eines Wagenrücklaufs (Chr(13)) dazu führen würde, dass die beiden Zeilen auf dem Bildschirm überschrieben werden, da die Wagenrückfahrt nicht zu einer neuen Linie führt. Sie können die Environment.NewLine-Eigenschaft verwenden, wenn Sie sowohl einen Wagenrücklauf als auch einen Zeilenvorschub wünschen:

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

Zeichenfolgenvorgänge in Visual Basic .NET

Visual Basic .NET verfügt über alle Zeichenfolgenoperatoren von C# und einige, die C# nicht. Visual Basic . NET-Operatoren umfassen:

Verkettung einer Zeichenfolge mit einer Zeichenfolge nur mithilfe des + -Operators, wie in s + t. Dieser Operator führt nur Zeichenfolgenverkettungen durch, wenn beide Operanden Zeichenfolgen sind. Wenn ein Operand etwas anderes als eine Zeichenfolge ist, versucht Visual Basic .NET, die Zeichenfolge in Double zu konvertieren und numerische Ergänzungen durchzuführen. Aus diesem Fall ist es besser, den & Operator zu verwenden, um verkettet zu werden, wie unten beschrieben.
Verkettung von zwei beliebigen Objekten mit dem & Operator, wie in s & "There". Wenn die Operanden des & Operators keine Zeichenfolgen sind, werden sie in Zeichenfolgen konvertiert. Das bedeutet, dass Sie sogar die Zeichenfolgendarstellungen von zwei Zahlen, x und y, für instance mit Syntax wie x & y verketten können. Dieser Operator wird für die Verkettung bevorzugt, da er eindeutig ist – er führt immer Verkettungen durch.
Ein vollständiger Satz von Vergleichen: =, <>, >, <, =>, <die entweder binär- oder Textvergleiche (kultursensitiv) durchführen, abhängig von der Kompilierungsoption und der Option Compare-Anweisung, falls vorhanden. StrComp führt auch Zeichenfolgenvergleiche durch, indem entweder Option Compare verwendet wird, um den Vergleichstyp festzulegen, oder durch Übergeben eines Parameters, der angibt, welche Vergleichsmethode verwendet werden soll.
Mit dem Like-Operator können Sie ermitteln, ob eine Zeichenfolge einem Muster entspricht, das durch eine vereinfachte Sprache für reguläre Ausdrücke beschrieben wird. Die von System.Text.RegularExpressions.RegEx unterstützte Sprache für reguläre Ausdrücke verfügt über mehr Funktionen, sodass Sie stattdessen diese API verwenden möchten.
Visual Basic .NET verfügt nicht über einen Indexer, um den Zugriff auf einzelne Zeichen von Zeichenfolgen mithilfe der Subscript-Notation des Arrays zu ermöglichen, aber Sie können die Chars-Eigenschaft verwenden, um einzelne Zeichen von Zeichenfolgen abzurufen und einzelne Zeichen von StringBuilder-Zeichenabzurufen/festzulegen.

Nur in Visual Basic .NET gefundene Zeichenfolgenfunktionen und -Anweisungen

Zusätzlich zu den Operatoren, die von der Visual Basic .NET-Sprache bereitgestellt werden, gibt es eine Gruppe von Funktionen und Anweisungen zum Bearbeiten von Zeichenfolgen, die für Visual Basic .NET eindeutig sind und sich nicht in der Standardbibliothek .NET Framework befinden.

"Wenn Sie ein Visual Basic .NET-Programmierer sind, ist es Ihre Wahl, ob Sie die Nur-Visual Basic-Versionen oder die Standardversionen .NET Framework verwenden möchten. (Es gibt jedoch einige Bereiche, in denen Visual Basic Funktionen bereitstellt, die vom Framework nicht bereitgestellt werden.) Dr. GUI empfiehlt, dass Sie dringend erwägen, sich an die Standard-.NET Framework-APIs zu halten, wo dies sinnvoll ist. Dies wird Ihnen helfen, Ihre Fähigkeiten auf eine Weise zu entwickeln, die später mit anderen Sprachen verwendet werden kann.

Andererseits können nur Visual Basic-Versionen sehr praktisch sein, wenn Sie ältere Visual Basic-Code zu Visual Basic .NET portieren, da die Syntax und das Verhalten der reinen Visual Basic-Versionen denen in älteren Versionen von Visual Basic ähneln.

Teilzeichenfolgen

Wenn Sie in BASIC überhaupt programmiert haben, erinnern Sie sich an die Funktionen Links, Rechts und Mitte zum Extrahieren von Zeichen aus der linken, rechten und mittleren Zeichenfolge. Vielleicht erinnern Sie sich sogar daran, dass Mid auf der linken Seite eines Zuweisungsoperators verwendet werden kann, um Zeichen in der Mitte einer Zeichenfolge zu ändern!

All diese Funktionen sind in Visual Basic .NET vorhanden – genau wie Sie sich daran erinnern. Ein sehr wichtiger Punkt: Der index, der in Mitte für das Startzeichen verwendet wird, ist einsbasiert, nicht nullbasiert wie bei allem anderen in .NET. (Das liegt daran, dass Mid seit dem Start in BASIC als MID$ einsbasiert ist.)

Dies ist ein schwerwiegendes Problem, das Dr. GUI empfiehlt, nieMid in neuem Code zu verwenden. Reservieren Sie stattdessen die Verwendung für Code, den Sie portieren, der bereits funktioniert – und machen Sie sich bereit, beim Debuggen die Haare herauszureißen. Das Hin- und Herwechseln zwischen 1-basiertem und nullbasiertem Zählen wird Sie verrückt machen.

Die String.SubString-Methode stellt Überladungen bereit, die einen hervorragenden Ersatz für Left und die Mid-Funktion bieten. Verwenden Sie für Left einfach str. Teilzeichenfolge(0, len); verwenden Sie für Midstr. SubString(start, len), denken Sie daran, den Startpunkt um eins anzupassen, da Substring den Startpunkt auf 0 und Mid auf eins basiert.

Richtig ist etwas schwieriger, da Sie die Startposition berechnen müssen. Beispiel:

Dim s As String = "Hello, world!"
Dim t1 As String = s.Substring(s.Length - subLen)
      ' same as below
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 gemacht hat. Er machte die Tatsache, dass Visual Basic .NET keine Escapesequenz für das Zeilenumbruchzeichen hat, indem er die Escapesequenz ("\n") sowieso einschließt, ersetzte er jedes Vorkommen der Escapesequenz durch die zweistellige Environment.NewLine-Zeichenfolge ("\r\n"), bevor er die Zeichenfolge zurückgibt. Wenn die Ausgabezeichenfolge genau mit der in der C#-Version identisch sein soll, sollten Sie "\n" durch Chr(10) anstelle von Environment.NewLine ersetzen.

Die Mid-Anweisung , die Zeichen in einer Zeichenfolge ersetzt, ist etwas schwieriger zu ersetzen. Sie können String.Remove verwenden, um die zu ersetzenden Zeichen und String.Insert zum Einfügen der neuen Zeichen zu entfernen. Dies erfordert jedoch die Erstellung von zwei neuen Zeichenfolgen. Es ist effizienter, einen StringBuilder aus der ersten Teilzeichenfolge der zu ändernden Zeichenfolge zu erstellen, die Ersetzung an ihn anzufügen und das Ende der ursprünglichen Zeichenfolge wie folgt anzufügen:

Dim s As String = "123456xxx0"
' SubString is ZERO-BASED
Dim sb As StringBuilder = New StringBuilder(s.Substring(0, 6))
sb.Append("789")
sb.Append(s.Substring(9, 1)) ' zero-based, 10th character
s = sb.ToString()
' same as Mid(s, 7, 3) = "789" ' one-based
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 sehr seltsame Funktion

Visual Basic .NET enthält eine sehr seltsame Funktion, StrConv. Es konvertiert eine Zeichenfolge in eine andere Zeichenfolge mithilfe einer Vielzahl von Konvertierungen, die durch eine Reihe von Bits angegeben werden. Es konvertiert in Groß- oder Kleinschreibung mithilfe von Dateisystemregeln oder kultursensiblen Regeln– Kleinschreibung mit groß geschriebenem ersten Buchstaben jedes Worts und mehrere Konvertierungen, die nur sinnvoll sind (und tatsächlich nur funktionieren), wenn Sie ein geeignetes ostasiatisches Lanaguage (z. B. Japanisch, Chinesisch oder Koreanisch) verwenden: in voll/halber Breite, und von Katakana nach Hiragana und zurück (nur japanisch). Es gibt angeblich eine Konvertierung in/von vereinfachten und traditionellen chinesischen Zeichen, aber Dr. GUI wird gesagt, dass diese Funktionalität nicht gut funktioniert, daher empfiehlt er nicht, sie zu verwenden.

Es gibt keine Entsprechung für die meisten dieser Konvertierungen in der .NET Framework-API. Die Konvertierungen werden jedoch mithilfe der Windows LCMapString-API durchgeführt. Wenn Sie dies wirklich über eine andere .NET-Sprache als Visual Basic ausführen möchten, verwenden Sie Plattform-API-Interop, um LCMapString aufzurufen (genau wie Visual Basic anscheinend).

Funktionen, die .NET Framework Funktionalität entsprechen

Es gibt eine Reihe von Visual Basic .NET-Zeichenfolgenfunktionen, die .NET Framework Funktionalität eng entsprechen. Im Folgenden finden Sie eine Tabelle, in der die Visual Basic .NET-Funktion und die nächstgelegene .NET Framework Äquivalent aufgeführt sind. Beachten Sie, dass die Funktionalität in einigen Fällen nicht genau gleichwertig ist. Beachten Sie außerdem, dass die .NET Framework Versionen in vielen Fällen zusätzliche Überladungen aufweisen, die zusätzliche Funktionen bieten. Sie müssen die Dokumentation lesen, um dies so gut wie möglich zu tun. Verwenden Sie die folgende Tabelle, um die geeignete Methode zum Lesen zu finden.

Tabelle 2: Visual Basic-spezifische Zeichenfolgenfunktionen und ihre nächstgelegenen Standard-.NET Framework-Entsprechungen

Visual Basic .NET-Funktion	Semantik	Nächstliegende .NET Framework Äquivalent
StrReverse	Umgekehrte Zeichenfolge.	Keine : Verwenden Sie StringBuilder und die Schleife, um das Reverse zu ändern, indem Sie Zeichen an Ort und Stelle austauschen.
InStr, InStrRev	Suchen Sie nach dem ersten/letzten Index der Teilzeichenfolge.	IndexOf, LastIndexOf
LCase, UCase	Konvertieren in Klein-/Großbuchstaben.	ToLower, ToUpper
Format, FormatCurrency, FormatNumber, FormatPercent	Kultursensitive Formatierung von Werten in Zeichenfolgendarstellung.	obj.ToString oder String.Format
Str, Val	Konvertieren der Zahl in/aus Zeichenfolge; nicht kultursensibel.	Eine der obigen Mit dem Angegebenen CultureInfo.Invariant .
Trim, LTrim, RTrim (nur Leerzeichen)	Schneidet Leerzeichen von Zeichenfolgenenden ab.	String.Trim, String.TrimStart, String.TrimEnd (Kann Zeichen neben Leerzeichen ausführen.)
Len	Gibt die Länge der Zeichenfolge zurück.	String.Length
Space, StrDup	Erstellen Sie Zeichenfolge mit wiederholten Leerzeichen oder anderen Zeichen.	Zeichenfolgenkonstruktor , der Zeichen und Anzahl annimmt.
Replace	Ersetzen Sie eine Unterzeichenfolge in einer Zeichenfolge.	Ersetzen Sie entweder in String oder StringBuilder.
Teilen, Beitreten	Erstellen Sie ein Array von Zeichenfolgen, indem Sie eine Zeichenfolge an einem angegebenen Trennzeichen durchbrechen oder eine durch Trennzeichen getrennte Zeichenfolge aus einem Array von Zeichenfolgen erstellen.	String.Split, String.Join
Filter	Erstellt ein Array von Zeichenfolgen aus einem anderen Array, das eine Teilzeichenfolge enthält.	Kein Äquivalent; schreiben Sie für jede Schleife, und platzieren Sie Zeichenfolgen in eine dynamisch erweiterbare ArrayList.
AscW, ChrW	Konvertieren Sie unicode-ganzzahlige Zeichenfolge in/aus einer einstelligen Zeichenfolge.	Umwandlung von char in einen ganzzahligen Typ oder umgekehrt.
Asc, Chr	Konvertieren Sie ganzzahlige Codeseiten in/aus einer einstelligen Zeichenfolge.	Verwenden Sie eine Codierung (weiter unten beschrieben).
CStr	Konvertieren in Zeichenfolge.	obj.ToString

Zeichenfolgen mit Standard-.NET Framework-APIs

Erstellen von Zeichenfolgenobjekten

In beiden Sprachen können Sie ein String-Objekt mit der new/New-Anweisung erstellen. Die meisten CLI-kompatiblen Zeichenfolgenkonstruktoren nehmen nichts, ein Zeichen und eine ganze Zahl oder ein Array von Zeichen. Wenn Sie also nicht über ein Array von Zeichen verfügen, verwenden Sie wahrscheinlich eine andere Methode, um Ihre Zeichenfolgen zu erstellen. Es gibt keinen Konstruktor, der eine Zeichenfolge akzeptiert. Es gibt jedoch einen Konstruktor, der ein Char und eine ganzzahlige Anzahl akzeptiert. In der resultierenden Zeichenfolge wird das Zeichen so oft wiederholt, wie die Anzahl angibt.

Die gängigsten Methoden initialisieren mit einem Zeichenfolgenliteral und weisen einen Wert aus einer anderen Zeichenfolge zu:

[C#]
string s = "Hello, world!";
string t = s;   // no copy; s and t refer to same string
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 ' no copy; s and t refer to same string
Dim ret as string = String.Format("s and t refer to same: {0}", s Is t)

Wann ist Klonen nicht Klonen?

Aber was ist, wenn Sie zwei separate Zeichenfolgen haben möchten, die jeweils denselben Wert enthalten? Nun, in der Regel wollen Sie dies nicht . Warum sollte der Speicher verschwendet werden? Da Zeichenfolgen unveränderlich sind, hat es wenig Sinn, zwei separate Zeichenfolgen mit dem gleichen Wert zu haben.

Obwohl StringIClonable implementiert, gibt String.Clone einfach einen Verweis auf dieselbe Zeichenfolge zurück, ohne sie zu klonen.

Es geht jedoch nicht alles verloren: Sie können die statische Methode Copy verwenden, wenn Sie darauf bestehen, eine zweite Kopie der Zeichenfolge zu erhalten. Beachten Sie, dass wir auf zwei Arten auf Verweisgleichheit überprüfen: erstens durch Aufrufen von Object.ReferenceEquals und zweitens durch Das Umwandeln der Verweise auf ein Objekt , bevor sie auf Gleichheit in C# testen, und indem sie den Is-Operator in Visual Basic verwenden.

[C#]
string s = "Hello";
string t = (string)s.Clone();   // no copy; s and t refer to same string
string u = String.Copy(s); // makes copy; s and u refer to diff. objects
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()) ' no copy; s and t refer to same string
Dim u as string = String.Copy(s)  ' makes copy; s and u refer to 2 objects
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 eine Zeichenfolge auch ganz oder teilweise mit der String.CopyTo-Methode in ein Zeichenarray kopieren. (Verwenden Sie einen Zeichenfolgenkonstruktor, der ein Zeichenarray als Parameter annimmt, um eine Zeichenfolge aus einem Zeichenarray oder einem Teil davon zu erstellen.)

Andere Schnittstellen sowie Eigenschaften und ein Feld

Wie wir gesehen haben, implementiert StringICloneable, obwohl es dies auf eine seltsame (aber vernünftige) Weise tut. Außerdem wird IComparable implementiert. Das bedeutet, dass Sie zwei Zeichenfolgen mit der CompareTo-Methode von IComparable vergleichen können (dazu später mehr). Obwohl StringIConvertable implementiert, sollten Sie die Methoden in der Convert-Klasse verwenden, um eine Zeichenfolge mithilfe der To... -Methoden in alle integrierten Werttypen zu konvertieren.

String hat auch einige interessante Eigenschaften. Sie können die Länge (in Zeichen, nicht in Bytes) einer beliebigen Zeichenfolge ermitteln, indem Sie auf die Length-Eigenschaft zugreifen (die schreibgeschützt ist). Außerdem können Sie über die Indexereigenschaft Chars (die dem C#-Indexer zugeordnet ist und auch schreibgeschützt ist) ein Zeichen nach dem anderen auf die Zeichenfolge zugreifen:

[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

Beachten Sie, dass Zeichenfolgenzeichen ab null indiziert werden, auch in Visual Basic .NET, wir darauf achten müssen, die Schleife ordnungsgemäß zu schreiben (das gleiche Problem wird mit dem < Operator und <nicht mit = in C# behandelt).

Oh, und es gibt ein interessantes statisches Feld namens Empty, das die leere Zeichenfolge enthält. Dadurch erhalten Sie eine sprachunabhängige Möglichkeit, eine leere Zeichenfolge ("") auszudrücken.

Zeichenfolgengleichheit/Vergleichsmethoden

Es gibt verschiedene Möglichkeiten, zwei Zeichenfolgen zu vergleichen. Für Gleichheit und Ungleichheit besteht ein großer Unterschied natürlich darin, ob der Vergleich durch Verweis (die beiden Zeichenfolgen zeigen auf dasselbe Objekt) oder nach Wert (sie enthalten die gleichen Zeichen) erfolgt.

Für Gleichheits- und relationale Vergleiche besteht der andere Hauptunterschied darin, ob die Sortierreihenfolge der aktuellen Kultur oder die unformatierten Ordnungswerte für jedes Zeichen in der Zeichenfolge verwendet werden sollen. (Ein geringfügiger Unterschied besteht darin, ob beim Vergleich die Groß-/Kleinschreibung beachtet wird oder nicht.) Die Standardeinstellung für Vergleiche besteht darin, dass sie die aktuelle Kultur des Threads verwenden, in dem sie ausgeführt werden, und dass die Groß-/Kleinschreibung beachtet wird. Dies ist in der Regel das, was Sie wollen.

Der == Operator generiert einen Aufruf von String.Equals, der einen Kulturvergleich zwischen Groß- und Kleinschreibung durchführt. Wenn Sie einen Verweisvergleich in C# durchführen möchten, wandeln Sie beide Zeichenfolgenverweise auf Object um, oder verwenden Sie Object.ReferenceEquals. Verwenden Sie in Visual Basic .NET den Is-Operator (in Visual Basic) wie unten, oder verwenden Sie Object.ReferenceEquals. Beachten Sie, dass Sie Object.ReferenceEquals in beiden Sprachen verwenden können.

[C#]
      string s = "Hello", t = "there";
      bool valueComp = (s == t); // value comparison
      bool refComp1 = ((Object)s == (Object)t); // reference comparison
      bool refComp2 = Object.ReferenceEquals(s, t); // referece comparison
      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 ' value comparison
Dim refComp1 as Boolean = s Is t ' reference comparison
Dim refComp2 as Boolean  = Object.ReferenceEquals(s, t) ' ref. comparison
Dim ret as string = _
String.Format("s = t: {0}, s Is t: {1}, ObRefEq(s, t): {2}", _
   valueComp, refComp1, refComp2)

Visual Basic . Die Gleichheits-, Ungleichheits- und Vergleichsoperatoren von NET (=, <>, >, <, >=<) führen entweder Ordnungsvergleiche oder kulturabhängige Vergleiche durch, abhängig von den Compileroptionen und der Option Compare-Anweisung. Verwenden Sie den Is-Operator , um einen Verweisvergleich durchzuführen. Visual Basic .NET verfügt auch über einen Like-Operator für Zeichenfolgenvergleiche, der einen einfachen Musterabgleich durchführt.

Die Equals-Methode ist in mehreren Varianten verfügbar. Es gibt zwei instance Methoden: Eine nimmt einen String als Parameter und eine nimmt ein Object an (das auf eine Zeichenfolge verweisen muss). Es gibt auch eine statische Version von Equals, die zwei Zeichenfolgen benötigt. Die Version, die ein Object akzeptiert, wird überschrieben (ursprünglich in Object definiert), die Version, die eine Zeichenfolge annimmt, ist schneller, da keine Konvertierung erforderlich ist, und die statische Version kann null/Nothing übergeben werden, ohne eine Ausnahme zu auslösen.

Für Vergleiche gibt es drei Methoden: Compare, CompareOrdinal und CompareTo. Alle diese Methoden geben eine negative Zahl zurück, wenn die erste Zeichenfolge kleiner als die zweite ist, null, wenn sie denselben Wert haben, und eine positive Zahl, wenn die erste Zeichenfolge größer als die zweite ist.

Compare ist eine Reihe von überladenen statischen Methoden, die kulturbezogene Vergleiche durchführen, wobei standardmäßig die Groß-/Kleinschreibung beachtet wird. Jede der Überladungen benötigt mindestens die beiden Zeichenfolgen zum Vergleich. Es gibt auch Überladungen, um einen booleschen Wert zu verwenden, der die Groß-/Kleinschreibung angibt, und Int32s, um Indizes und die Länge der zu vergleichenden Teilzeichenfolgen anzugeben (anstatt die gesamte Zeichenfolge zu vergleichen).

CompareOrdinal ist ein Paar von überladenen statischen Methoden, die Ordnungsvergleiche von zwei Zeichenfolgen oder Teilzeichenfolgen innerhalb der beiden Zeichenfolgen durchführen.

CompareTo ist eine instance-Methode, die IComparable implementiert. Es vergleicht die aktuelle Zeichenfolge mit der Zeichenfolge oder dem Objekt, die als Parameter übergeben wird, indem Vergleiche zwischen Kultur und Groß-/Kleinschreibung berücksichtigt werden.

Suchen einer Zeichenfolge: EndsWith/StartsWith/IndexOf/LastIndexOf/Substring

Es gibt eine Reihe von Methoden, um herauszufinden, was in einer Zeichenfolge enthalten ist. EndsWith und StartsWith geben true zurück, wenn die aktuelle Zeichenfolge mit der angegebenen Zeichenfolge endet/beginnt, oder andernfalls false .

IndexOf und LastIndexOf verfügen jeweils über eine Reihe von Überladungen. Jede gibt die erste/letzte Position in der aktuellen Zeichenfolge (oder einer Teilzeichenfolge davon) zurück, an der die Zeichenfolge (oder das Zeichenarray) auftritt.

Die Teilzeichenfolge ähnelt der alten GW-BASIC MID$ -Funktion und der Visual Basic .NET Mid-Funktion , mit dem Unterschied, dass der Index in der Zeichenfolge nullbasiert ist anstatt einsbasiert wie in Mid/MID$. Es gibt zwei Überladungen: Eine erstellt und gibt eine neue Zeichenfolge zurück, die die Teilzeichenfolge vom angegebenen Index bis zum Ende der Zeichenfolge enthält. Die andere erstellt und gibt eine neue Zeichenfolge zurück, die die Teilzeichenfolge der angegebenen Länge ab dem angegebenen Index enthält.

Formatierung

Die String-Klasse verfügt über eine Familie statischer Format-Methodenüberladungen . Alle bieten Formatierungsfunktionen wie die, die wir in unseren Aufrufen von Console.WriteLine verwendet haben. Sie erstellen und geben eine neue Zeichenfolge zurück, wobei der Formatbezeichner durch die Zeichenfolgendarstellung der verbleibenden Parameter ersetzt wird. Für instance können Sie Folgendes verwenden:

[C#]
string ret = String.Format("The value is {0}", 5);
// "The value is 5" (without quotes)

[Visual Basic .NET]
Dim ret as string = String.Format("The value is {0}", 5)
' "The value is 5" (without quotes)

Es gibt auch andere Möglichkeiten zum Formatieren von Daten und viele Probleme im Zusammenhang mit dem Kulturbewusstsein. Leider haben wir diesmal nicht die Zeit, sie zu untersuchen. Beachten Sie, dass die .NET Framework im Allgemeinen kulturbewusste Konvertierungen und Formatierungen durchführt, es sei denn, Sie übergeben CultureInfo.InvariantCulture an die Formatierungsmethode. Die integrierten .NET-Methoden von Visual Basic sind häufig standardmäßig invariante Kultur. Beachten Sie also!

Analyse

Sie können von einer Zeichenfolge in viele andere Typen konvertieren, indem Sie die Parse-Methode der Klasse verwenden, in die Sie konvertieren möchten. Um instance in eine ganze Zahl zu konvertieren, können Sie die Int32.Parse-Methode verwenden. Beachten Sie, dass es andere Möglichkeiten gibt, Konvertierungen durchzuführen, z. B. die Verwendung der Methoden in der Convert-Klasse , oder Sie könnten in einigen Fällen das Objekt (in C#) umwandeln oder die CType - oder CStr-Funktionen von Visual Basic verwenden.

Auffüllen und Kürzen

Es gibt eine Vielzahl von Methoden zum Auffüllen des linken oder rechten Teils einer Zeichenfolge mit Leerzeichen (oder einem beliebigen Zeichen) namens PadLeft und PadRight. Es gibt auch mehrere Methoden zum Kürzen der Leerzeichen oder eines beliebigen Zeichensatzes, die Sie am Anfang und/oder Ende einer Zeichenfolge angeben (TrimStart, TrimEnd und Trim). Diese alle erstellen neue Zeichenfolgen und geben sie zurück.

Einfügen/Entfernen/Ersetzen/Verketten

Diese Methoden ähneln denen in StringBuilder, obwohl es in StringBuilder weniger Überladungen gibt als in StringBuilder. Weitere Informationen zu den Unterschieden finden Sie im folgenden Abschnitt StringBuilder.

Insert erstellt eine neue Zeichenfolge mit der angegebenen Zeichenfolge, die an der angegebenen Position eingefügt wird. Remove erstellt eine neue Zeichenfolge mit der angegebenen Anzahl von Zeichen, die von der angegebenen Position entfernt wurden. Replace erstellt und gibt eine neue Zeichenfolge zurück, wobei alle Vorkommen eines angegebenen Zeichens oder einer angegebenen Zeichenfolge durch ein anderes Zeichen oder eine andere Zeichenfolge ersetzt werden. Und die verschiedenen Überladungen der statischen Methode Concat erstellen und geben neue Zeichenfolgen zurück, indem die übergebenen Zeichenfolgen und/oder Objekte verkettet werden.

Teilen/Verknüpfen

Split und Join sind leistungsstarke Methoden. Join ist eine statische Methode, die eine Zeichenfolge zurückgibt, die erstellt wird, indem einige oder alle Zeichenfolgen in dem übergebenen Zeichenfolgenarray verkettet werden, wobei eine angegebene Zeichenfolge als Trennzeichen verwendet wird. Split teilt eine Zeichenfolge unter Verwendung des angegebenen Satz von Trennzeichen in ein neu erstelltes und zurückgegebenes Array von Zeichenfolgen auf.

Konvertierungen

String enthält keine direkt zugänglichen Konvertierungsmethoden, aber die Convert-Klasse enthält eine Reihe von statischen/freigegebenen Konvertierungsmethoden, von denen die meisten in einen integrierten Typ konvertieren und das Format To... haben. Die Liste, die in integrierte Typen in eine Zeichenfolge konvertiert wird, umfasst ToBoolean, ToByte, ToChar, ToDecimal, ToDouble, ToInt16, ToInt32, ToInt64, ToSByte, ToSingle, ToString, ToUInt16, ToUInt32 und ToUInt64. Es gibt auch eine Methode zum Konvertieren in ein DateTime-Objekt – ToDateTime – und Methoden (FromBase64String und ToBase64String), um zwischen Bytearrays und Base-64-codierten Zeichenfolgen zu konvertieren (nützlich für die Übertragung von Binärdaten über Textprotokolle).

String enthält eine ToCharArray-Methode , die in ein Zeichenarray konvertiert wird. Außerdem gibt es Methoden zum Konvertieren der Zeichenfolge in Groß- oder Kleinbuchstaben: ToUpper und ToLower.

Intern/IsInterned

Die .NET-Runtime verwaltet einen Pool von Literalzeichenfolgen in der Anwendungsdomäne (ähnlich einem Prozess). Wenn eine Assembly, z. B. Ihr Programm, in eine Anwendungsdomäne geladen wird, werden die Zeichenfolgenliterale der Assembly in den Pool der Zeichenfolgenliterale der Anwendungsdomäne zusammengeführt, wodurch Duplizierungen von Zeichenfolgenliteralen vermieden werden. (Dies kann erfolgen, ohne die Ergebnisse Ihres Programms zu ändern, da Zeichenfolgen unveränderlich sind.) Die Tatsache, dass alle Zeichenfolgenliterale interniert sind, bedeutet auch, dass Sie Verweisvergleiche von Zeichenfolgenliteralen korrekt durchführen können, da es nur eine Kopie jedes Zeichenfolgenliterals gibt.

Wenn Sie jedoch eine Zeichenfolge selbst erstellen, z. B. durch eine der String-Methoden , die eine neue Zeichenfolge erstellt, oder mithilfe eines StringBuilders, handelt es sich um eine andere Zeichenfolge als die Zeichenfolge mit demselben Wert im Literalpool (vorausgesetzt, es gibt einen), sodass Referenzvergleiche fehlschlagen. Dies kann eine große Sache sein, da Referenzvergleiche viel schneller sind als Wertevergleiche – alles, was verglichen werden muss, ist die Adresse. (In Code, den Sie wirklich schnell ausführen möchten, sollten Sie also Referenzvergleiche verwenden, wenn Sie sicher sind, dass sie funktionieren!)

Wenn Sie Ihre Zeichenfolgen dem Literalpool hinzufügen möchten, können Sie dies mit der statischen Methode Intern tun, die die Zeichenfolge dem Literalpool hinzufügt (sofern sie noch nicht vorhanden ist) und einen Verweis auf die Literalpoolzeichenfolge zurückgibt. Beispiel:

[C#]
string s2 = new StringBuilder().Append("Foo").Append("Bar").ToString();
string s3 =String.Intern(s2);   // return reference to literal pool
string s = "FooBar";            // was in literal pool all along
StringBuilder sb = new StringBuilder();
sb.Append(Object.ReferenceEquals(s2, s));   // false: different
sb.Append(", ");
sb.Append(Object.ReferenceEquals(s3, s));   // true: same

[Visual Basic .NET]
Dim s2 as string = New _
     StringBuilder().Append("Foo").Append("Bar").ToString()
Dim s3 as string = String.Intern(s2) ' return reference to literal pool
Dim s as string = "FooBar"  ' was in literal pool all along
Dim sb as new StringBuilder()
sb.Append(s2 Is s) ' false: different
sb.Append(", ")
sb.Append(s3 Is s) ' true: same

Sie können auch überprüfen, ob eine Zeichenfolge im Pool bereits mit der statischen IsInterned-Methode vorhanden ist, die true zurückgibt, wenn sich die Zeichenfolge im Pool befindet.

GetHashCode

Vielleicht erinnern Sie sich daran, dass wir beim letzten Mal über die Idee diskutiert haben, dass Sie getHashCode auch außer Kraft setzen sollten, wenn Sie Equals überschreiben. In String wird Equals überschrieben , sodass GetHashCode ebenfalls ist und ein gutes Hashing und eine gute Leistung bietet.

StringBuilder

Möglicherweise haben Sie bemerkt, dass viele der Methoden in String neue Zeichenfolgen erstellen und zurückgeben. Wie Sie vielleicht erraten haben, kann dies teuer sein, wenn Sie viele Zeichenfolgen zuordnen und wegwerfen.

Wenn Sie in der Regel nur einen Zeichenfolgenvorgang für eine bestimmte Zeichenfolge ausführen möchten, bei der eine neue Zeichenfolge erstellt wird, verwenden Sie die entsprechende Methode in String (oder die entsprechende Visual Basic .NET-Funktion). Wenn Sie jedoch mehrere Vorgänge ausführen und die erforderlichen Vorgänge in System.Text.Stringbuilder verfügbar sind, erstellen Sie einen StringBuilder aus Ihrer Zeichenfolge, führen Sie die mehreren Vorgänge im StringBuilder aus, und rufen Sie dann ToString für den StringBuilder auf, um die Ergebniszeichenfolge wieder abzurufen. Sehen Sie sich das vorherige Beispiel an, in dem dies alles in einer Zeile geschieht.

Es ist sehr üblich, eine Zeichenfolge in einem StringBuilder zu erstellen, sie zu bearbeiten und in eine Zeichenfolge zu konvertieren. Beachten Sie, dass der Aufruf von ToString die Zeichenfolge nicht tatsächlich kopiert, es sei denn, Sie ändern später dasselbe StringBuilder-Objekt , sodass es tatsächlich sehr effizient ist. Der Mehraufwand für die Verwendung von StringBuilder ist in der Regel ein Kopiervorgang, nicht zwei. Aus diesem Grund haben wir die 1-Vorgangsregel. Bei mindestens zwei Vorgängen ist die Verwendung eines StringBuilders mindestens genauso gut.

Sie können auch einen StringBuilder verwenden, wenn die verfügbaren Überladungen wesentlich einfacher zu verwenden sind als die eingeschränkteren Überladungen in String.

Um StringBuilder verwenden zu können, müssen Sie (Imports System.Text in Visual Basic) am Anfang ihrer Programmdatei einschließen using System.Text; .

StringBuilder verfügt über mehrere Konstruktoren, die das Objekt aus einer Zeichenfolge initialisieren und dessen Kapazität und maximale Kapazität festlegen können. (Die maximale Standardkapazität beträgt etwa zwei Milliarden Zeichen, daher ist es nicht unvernünftig, sie auf einen etwas kleineren Wert festzulegen, obwohl es keine Strafe gibt, wenn Sie dies nicht getan haben.) Die Kapazität des Objekts wird bei Bedarf nach oben angepasst, solange Sie die maximale Kapazität nicht überschreiten. Die maximale Kapazität kann nicht angepasst werden, nachdem der StringBuilder erstellt wurde.

Es gibt vier Eigenschaften: Kapazität, die gelesen oder geschrieben werden kann; MaxCapacity, das schreibgeschützt ist; Länge, die aktuelle Länge der Zeichenfolge (kann kürzer oder länger festgelegt werden); 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, wenn sie nicht bereits groß genug ist.

Mit der Append-Methode können Sie eine Zeichenfolge oder einen beliebigen Typ (es gibt viele Überladungen) an das Ende des StringBuilders anfügen. Wenn Sie einen anderen Typ übergeben, wird die ToString-Methode aufgerufen, und das Ergebnis wird an den StringBuilder angefügt.

Mit der AppendFormat-Methode können Sie die Zeichenfolge formatieren, die Sie an den StringBuilder anfügen. Die Formatierung ist identisch mit String.Format und Console.WriteLine.

Die vielen Überladungen von Insert ermöglichen es Ihnen, eine Zeichenfolge (möglicherweise berechnet aus einem Aufruf der ToString-Methode Ihres Parameters) an einer beliebigen Stelle im StringBuilder einzufügen.

Mit Remove können Sie eine beliebige Anzahl von Zeichen aus einer beliebigen Position entfernen.

Ersetzen ermöglicht das Ersetzen einzelner Zeichen oder, wie gerade erwähnt, von Teilzeichenfolgen.

Schließlich erstellen die Überladungen von ToString ein neues String-Objekt aus dem StringBuilder (oder der angegebenen Teilzeichenfolge).

System.Text Encoder und Decoder

Sie haben festgestellt, dass alle Zeichenfolgen in einem .NET Framework-Programm als 16-Bit-Unicode gespeichert werden. Möglicherweise haben Sie auch bemerkt, dass nicht jeder Unicode verwendet, sodass Sie manchmal von einer anderen Zeichencodierung in Unicode oder von Unicode in eine andere Zeichencodierung konvertieren müssen.

Die .NET Framework bietet mehrere Klassen für die Codierung (Konvertieren von Unicode-Zeichen in einen Bytesblock in einer anderen Codierung) und die Decodierung (Konvertieren eines Bytesblocks in einer Codierung in Unicode-Zeichen).

Für jede unterstützte Codierung gibt es eine Klasse: ASCIIEncoding, CodePageEncoding, UnicodeEncoding (nützlich für die Konvertierung von big-endian in Little-Endian), UTF7Encoding und UTF8Encoding.

Jede dieser Klassen verfügt über Methoden für die Codierung (z. B . GetBytes) und die Decodierung (z. B . GetChars) zum Codieren und Decodieren eines einzelnen Arrays auf einmal. Darüber hinaus unterstützt jeder GetEncoder und GetDecoder, die Encoder und Decoder zurückgeben, die den Umschaltzustand beibehalten können, sodass sie mit Streams und Blöcken verwendet werden können.

Reguläre Ausdrücke

Möglicherweise haben Sie bemerkt, dass Visual Basic .NET eingeschränkte Übereinstimmung mit regulären Ausdrücken über die Like-Anweisung unterstützt. Darüber hinaus unterstützt der .NET Framework einige sehr anspruchsvolle Verarbeitung regulärer Ausdrücke im System.Text.RegularExpressions-Namespace. Die Schlüsselklasse hier ist System.Text.RegularExpressions.RegEx, die einen kompilierten regulären Ausdruck darstellt und Methoden für seine Verwendung bereitstellt, einschließlich des Suchens und Ersetzens regulärer Ausdrücke in Zeichenfolgen sowie das Aufteilen einer Zeichenfolge in ein Array von Zeichenfolgen. Die Dokumentation zu regulären Ausdrücken ist jetzt spärlich, sodass wir noch nicht darauf eingehen werden. Vielleicht in einer zukünftigen Spalte.

Versuch es doch mal!

Wer ist In Your .NET Framework Learning Team?

Der gute Arzt hofft, dass Sie nicht nur mit .NET spielen, sondern auch mit einigen anderen Personen zusammenarbeiten. Auf diese Weise macht es mehr Spaß, und Sie werden garantiert mehr erfahren.

Einige Dinge, die Sie ausprobieren können...

Sehen Sie sich die Quelldatei an. Kopieren Sie es in Visual Studio, und nehmen Sie Ihre eigenen Änderungen vor.

Spielen Sie einige mit Zeichenfolgen und vielleicht mit Arrays von Zeichenfolgen.

Führen Sie einige Zeichenfolgenbearbeitungen mit StringBuilder durch. Verwenden Sie einige der erweiterten Funktionen von String , um eine Zeichenfolge zu analysieren, z. B. eine Befehlszeile.

Wenn Sie wirklich Spaß haben, versuchen Sie, verschiedene Zeichensätze und Codepages zu codieren und zu decodieren. Wenn Sie wirklich wegweisend sind, sollten Sie einige mit den regulären Ausdrucksklassen verwenden.

Was wir getan haben; Was kommt als nächstes

Dieses Mal haben wir über Zeichenfolgen gesprochen. Beim nächsten Mal werden wir über Arrays sprechen.

Share via