Dr. GUI .NET #5

 

31. Mai 2002

Inhalt

Wo wir gewesen sind; Wohin wir gehen?
Streichinstrumente
Die System.String-Klasse
Zeichenfolgen in C#
Zeichenfolgen in Visual Basic .NET
Zeichenfolgen mit standardmäßigen .NET Framework-APIs
StringBuilder
System.Text Encoders und Decoder
Reguläre Ausdrücke
Versuch es doch mal!
Was wir getan haben; Was kommt als nächstes

Sprechen Sie aus! Verwenden Sie die Quelle, Luke!

Wenn Sie etwas haben, das Sie sagen möchten, teilen Sie uns (und der Welt) mit, was Sie über diesen Artikel im Dr. GUI .NET Message Boarddenken.

Und schauen Sie sich unbedingt die Beispiele an, die als Microsoft® ASP.NET-Anwendungen ausgeführt werden, mit Quellcode, oder schauen Sie sich einfach die Quelldatei in einem neuen Fenster an.

Wo wir gewesen sind; Wohin wir gehen?

Letzte Zeit haben wir die Mutter und vater aller .NET-Klassen diskutiert: die nerable System.Object. Darüber hinaus haben wir die Speicherzuweisung und Garbage Collection und ein bisschen darüber diskutiert, wie das dynamische Typsystem in .NET Framework funktioniert.

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

Streichinstrumente

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

Zeichenfolgen sind unveränderlich

Eine der schwierigen Dinge, die Sie in .NET Framework verwenden können, ist, dass String-Objekte unveränderlich sind, was bedeutet, dass ihre Werte nicht mehr geändert werden können. (Sie können den Zeichenfolgenverweis jedoch neu zuweisen, um auf eine andere Zeichenfolge zu verweisen, wobei die erste Zeichenfolge für die Garbage Collection freigegeben wird, wenn keine anderen Verweise darauf vorhanden sind.)

Die Methoden von String, die scheinbar die Zeichenfolge bearbeiten, ä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 bewirkt, dass eine neue Zeichenfolge erstellt wird und die alte Zeichenfolge weggeworfen wird.

Beachten Sie, dass der Prozess des wiederholten Erstellens und Auslösens von Zeichenfolgen langsam sein kann. Das Unveränderliche Erstellen von Zeichenfolgen hat jedoch eine Reihe von Vorteilen, da diese Besitz-, Alias- und Threadingprobleme bei unveränderlichen Objekten viel einfacher sind. Beispielsweise sind Zeichenfolgen für die Multithreadprogrammierung immer sicher, da kein Thread dazu führen kann, dass ein Thread einen anderen Thread durch Ändern einer Zeichenfolge ins Chaos bringen würde, da Zeichenfolgen nicht geändert werden können.

StringBuilder zur Rettung

Geben Sie StringBuilder-ein. Ein StringBuilder--Objekt ist keine Zeichenfolge, wird jedoch verwendet, um Zeichenfolgen mit 16-Bit-Unicode-Zeichen zu bearbeiten. Er enthält einen Puffer, der in der Regel mit einer Zeichenfolge initialisiert wird (in der Regel jedoch 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 mit dem Bearbeiten der Zeichen fertig sind, verwenden Sie StringBuilderToString-Methode, um die fertige Zeichenfolge daraus zu extrahieren. In den meisten Fällen wird StringBuilder.ToString ohne Kopiervorgang ausgeführt, sodass es sehr effizient ist.

Indizieren von Zeichenfolgen und StringBuilders

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

Da Zeichenfolgen- unveränderlich ist, ist der Indexer schreibgeschützt. Natürlich ist der StringBuilder Indexer Lese-/Schreibzugriff, sodass Sie zeichen sowohl betrachten als auch ändern können.

Die System.String-Klasse

System.String ist eine versiegelte Klasse, d. h., Sie können nicht von ihr erben (und das System kann auch bestimmte Optimierungen ausführen, um die Zeichenfolgenverarbeitung zu beschleunigen).

Die meisten .NET-Sprachen verfügen über eine integrierte Unterstützung für Zeichenfolgen. Beispielsweise 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 Kompilierungszeit mit dem +-Operator verkettet werden. Die Escapesequenzen beginnen alle mit einem umgekehrten Schrägstrich ("\") und werden in der folgenden Tabelle aufgeführt.

Tabelle 1. C#-Zeichenfolgenliterale Escapesequenzen

Escape-Sequenz Beschreibung
\t Registerkarte (Unicode-0x0009).
\r Wagenrücklauf (0x000d).
\n Neue Zeile (Zeilenvorschub) (0x000a).
\v Vertikale Registerkarte (0x000b).
\ein 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 Hexadezimaler Zeichencode mit variabler Anzahl von Ziffern.
\uABCD Unicode-Zeichen 0xABCD (entweder u oder U ist OK, wobei A, B, C und D gültige hexadezimale Ziffern 0-9, a-f, A-F sind).

Alle diese Escapesequenzen können in einem beliebigen regulären Zeichenfolgenliteral oder in einem beliebigen Zeichenliteral verwendet werden (z. B. "\t"). 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" ist). Auf diese Weise können Sie Bezeichner mit einem beliebigen gültigen Unicode-Zeichen schreiben, auch wenn dieses Zeichen nicht auf der Tastatur vorhanden ist oder in der Schriftart, die der Editor verwendet, nicht angezeigt werden kann.

Verbatim-Zeichenfolgenliterale beginnen mit " und enden mit dem übereinstimmenden Anführungszeichen. Sie haben keine Escapesequenzen. Also

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

ist identisch mit

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

ist aber viel einfacher und weniger fehleranfällig. Verbatim-Zeichenfolgenliterale können auch über einen Zeilenumbruch erweitert werden. 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 die "\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, daher benötigen Sie beides, wenn Sie die Datei mit dem Visual Studio .NET-Editor erstellen. (Andere Editoren können Zeilen mit nur Zeilenumbruchzeichen (ASCII-Code 10 oder Zeilenvorschub) enden.

Die nur Ausnahme der Regel "Keine Escapesequenz" für verbatim Zeichenfolgenliterale ist, dass Sie können ein doppeltes Anführungszeichen in eine Verbatimzeichenfolge einfügen, 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 der oder nicht kann ein anderer Typ als Zeichenfolge sein– wenn ja, wird er in eine Zeichenfolge konvertiert, indem ToString- aufgerufen wird. Der +-Operator wird als Teil der C#-Sprache implementiert, nicht als Mitglied der klasse String. Wenn ein Operand NULL- ist (im Gegensatz zu einer leeren Zeichenfolge, ""), wird er in eine leere Zeichenfolge konvertiert. Wenn der Vorgang zur Kompilierungszeit ausgeführt werden kann, wird er ausgeführt.
  • Gleichheit und Ungleichheit, wie in s == t und s != t. Diese Operatoren sind Teil String Klasse, sodass sie von jeder Sprache verwendet werden können, die überladene Operatoren unterstützt. Sie können sogar von Sprachen verwendet werden, die überladene Operatoren, z. B. Microsoft® Visual Basic® .NET, nicht unterstützen, indem sie die Membernamen op_Equality und op_Inequality anstelle der Operatorsyntax verwenden. Diese Operatoren rufen String.Equalsauf, bei dem ein binärer Vergleich der Zeichen in den beiden Zeichenfolgen ausgeführt wird, kein kulturbewusster Vergleich.

Verkettung erfolgt nach Möglichkeit zur Kompilierungszeit. Sie können auch jedes Objekt mit einer Zeichenfolge verketten. Dadurch wird der Rückgabewert aus der ToString--Methode des Objekts verkettet. Beispielsweise sind alle folgenden Gültigen:

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ührt der Compiler und die Laufzeit doppelte Zeichenfolgenliterale zusammen, sodass nur eine Kopie jedes Literals in Ihrem Programm vorhanden ist.

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 die Zeichenfolge einzuschließen, doppeltippen Sie 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 ist mit den Zeichenfolgenliteralen von C# vergleichbar, mit der Ausnahme, dass Visual Basic .NET-Zeichenfolgenliterale keine Zeilenendezeichen enthalten können– sie müssen in einer einzelnen Zeile enthalten sein.) Wenn Sie Zeichen einschließen müssen, die Sie nicht in einem Visual Basic .NET-Programm darstellen können, z. B. ein Zeilenvorschubzeichen, müssen Sie die Chr oder ChrW--Funktion verwenden, um das Zeichen aus dem 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ücklauf nicht zu einer neuen Zeile wechselt. Sie können die eigenschaft Environment.NewLine 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# sowie einige, die C# nicht unterstützt. Visual Basic . Zu den Operatoren von NET gehören:

  • Verkettung einer Zeichenfolge mit einem String- nur mit dem operator + verwendet, wie in s + t. Dieser Operator führt Zeichenfolgenverkettung nur aus, 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 auszuführen. Aus diesem Gründen ist es besser, den &-Operator zu verwenden, um verkettet zu werden, wie unten beschrieben.
  • Verkettung von zwei Objekten mithilfe des &-Operators, 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 verketten können, x und ybeispielsweise mit Syntax wie x & y. Dieser Operator wird für die Verkettung bevorzugt, da er eindeutig ist – er immer verkettet.
  • Ein vollständiger Satz von Vergleichen: =, <>, >, <, >=, <=, die abhängig von der Kompilierungsoption und der option compare Option Compare Anweisung , falls vorhanden. StrComp führt auch Zeichenfolgenvergleiche aus, indem entweder Option Compare verwendet wird, um den Typ des Vergleichs festzulegen oder einen Parameter zu übergeben, der angibt, welche Vergleichsmethode verwendet werden soll.
  • Mit dem Operator Like können Sie ermitteln, ob eine Zeichenfolge mit einem Muster übereinstimmt, das von einer vereinfachten Sprache für reguläre Ausdrücke beschrieben wird. Die von der System.Text.RegularExpressions.RegEx unterstützte Sprache für reguläre Ausdrücke verfügt über mehr Funktionen, daher sollten Sie stattdessen diese API verwenden.
  • Visual Basic .NET verfügt nicht über einen Indexer, mit dem Sie auf einzelne Zeichen von Zeichenfolgen mithilfe der Array-Subscript-Schreibweise zugreifen können. Sie können jedoch die eigenschaft Chars verwenden, um einzelne Zeichen von Zeichenfolgen abzurufen und einzelne Zeichen von StringBuilder-abzurufen/festzulegen.

Zeichenfolgenfunktionen und -anweisungen, die nur in Visual Basic .NET gefunden wurden

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 sie befinden sich nicht in der standardmäßigen .NET Framework-Bibliothek.

"Wenn Sie ein Visual Basic .NET-Programmierer sind, ist es Ihre Wahl, ob Sie die Nur-Visual Basic-Versionen oder die standardmäßigen .NET Framework-Versionen verwenden möchten. (Es gibt einige Bereiche, in denen Visual Basic Funktionen bereitstellt, die jedoch nicht vom Framework bereitgestellt werden.) Dr. GUI empfiehlt, dass Sie unbedingt die standardmäßigen .NET Framework-APIs berücksichtigen, wo dies praktisch ist. Auf diese Weise können Sie Ihre Fähigkeiten so entwickeln, dass sie später mit anderen Sprachen verwendet werden können.

Andererseits können die Nur-Visual Basic-Versionen äußerst praktisch sein, wenn Sie älteren Visual Basic-Code zu Visual Basic .NET portieren, da die Syntax und das Verhalten der nur Visual Basic-Versionen in älteren Versionen von Visual Basic vergleichbar sind.

Teilzeichenfolgen

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

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

Dies ist ein ernstes Problem, das Dr. GUI empfiehlt, niemalsMid in neuem Code zu verwenden. Reservieren Sie stattdessen ihre Verwendung für Code, den Sie portieren, das bereits funktioniert – und bereiten Sie sich bereit, beim Debuggen Ihr Haar herauszuziehen. Wenn Sie zwischen einer basierten und nullbasierten Zählung hin- und herwechseln, werden Sie verrückt.

Die String.SubString--Methode stellt Überladungen bereit, die für Left und die funktion Mid hervorragend geeignet sind. Für Links verwenden einfach str. Teilzeichenfolge(0, len); für Midverwenden Sie str. SubString(start, len), daran denken, den Anfangspunkt um eins anzupassen, da Teilzeichenfolge den Anfangspunkt auf Null basiert und Mid sie auf einer Basis basiert.

Rechts- ist etwas schwieriger, da Sie die Anfangsposition berechnen müssen. Zum 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 sich dafür aus, dass Visual Basic .NET keine Escapesequenz für das Neuelinezeichen hat, indem er trotzdem die Escapesequenz ("\n") einschleiht, dann ersetzte er jedes Vorkommen der Escapesequenz durch die zweistellige Environment.NewLine Zeichenfolge ("\r\n") unmittelbar vor der Rückgabe der Zeichenfolge. Wenn die Ausgabezeichenfolge exakt mit 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 zu entfernen und String.Insert, um die neuen Zeichen einzufügen, erfordert jedoch die Erstellung von zwei neuen Zeichenfolgen. Es ist effizienter, eine StringBuilder- aus der ersten Teilzeichenfolge der zu ändernden Zeichenfolge zu erstellen, den Ersetzung an sie anzufügen und das End 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 ungerade Funktion

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

Für die meisten dieser Konvertierungen in der .NET Framework-API gibt es keine Entsprechung. Die Konvertierungen werden jedoch mit der Windows LCMapString--API durchgeführt. Wenn Sie sie wirklich aus einer anderen .NET-Sprache als Visual Basic ausführen möchten, verwenden Sie die Plattform-API-Interoperabilität, um LCMapString- aufzurufen (genau wie Visual Basic anscheinend).

Funktionen, die mit .NET Framework-Funktionen übereinstimmen

Es gibt eine Reihe von .NET-Zeichenfolgenfunktionen in Visual Basic, die eng mit .NET Framework-Funktionen übereinstimmen. Nachfolgend finden Sie eine Tabelle, in der die Visual Basic .NET-Funktion und die nächstgelegene .NET Framework-Entsprechung aufgeführt sind. Beachten Sie, dass die Funktionalität in einigen Fällen nicht genau gleichwertig ist. Beachten Sie auch, dass in vielen Fällen die .NET Framework-Versionen zusätzliche Überladungen aufweisen, die zusätzliche Funktionen bereitstellen. Sie müssen die Dokumentation so gut wie möglich lesen. verwenden Sie die nachstehende Tabelle, um die entsprechende Methode zum Lesen zu finden.

Tabelle 2. Visual Basic-spezifische Zeichenfolgenfunktionen und die nächstgelegenen .NET Framework-Standardäquivalente

Visual Basic .NET-Funktion Semantik Nächstliegende .NET Framework-Entsprechung
StrReverse- Umgekehrte Zeichenfolge. None – Verwenden Sie StringBuilder- und Schleife, um die Schleife umzukehren, indem Sie Zeichen an Ort und Stelle austauschen.
InStr, InStrRev Suchen Sie den ersten/letzten Index der Teilzeichenfolge. IndexOf, LastIndexOf
LCase, UCase In Klein-/Großbuchstabe konvertieren. ToLower, ToUpper
Format, FormatCurrency, FormatNumber, FormatPercent Kultursensible Formatierung von Werten in Zeichenfolgendarstellung. obj.ToString- oder "String.Format"-
Str, Val Zahl in/aus Zeichenfolge konvertieren; nicht kulturempfindlich. Einer von oben mit CultureInfo.Invariant angegeben.
Trim, LTrim, RTrim (nur Leerzeichen) Schneidet Leerzeichen von Enden von Zeichenfolgen 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 eine Zeichenfolge mit wiederholten Leerzeichen oder anderen Zeichen. Konstruktor "String", der Zeichen und Anzahl akzeptiert.
Ersetzen Ersetzen Sie eine Unterzeichenfolge innerhalb einer Zeichenfolge. Ersetzen Sie entweder in Zeichenfolgen- oder StringBuilder-.
Teilen, Beitreten Erstellen Sie ein Array von Zeichenfolgen, indem Sie eine Zeichenfolge bei einem angegebenen Trennzeichen aufteilen 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. Keine Entsprechung; schreiben Sie für jede Schleife, z. B. das Einfügen von Zeichenfolgen in eine dynamisch erweiterbare ArrayList-.
AscW, ChrW Konvertieren Sie Unicode-Ganzzahl in/aus einer einstelligen Zeichenfolge. Umwandeln von Zeichen in einen ganzzahligen Typ oder visa-versa.
Asc, Chr Konvertieren Sie die ganze Zahl der Codeseite in/aus einer Zeichenfolge mit einem Zeichen. Verwenden Sie eine Codierung (weiter unten beschrieben).
CStr- In Zeichenfolge konvertieren. obj.ToString-

Zeichenfolgen mit standardmäßigen .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 String--Konstruktoren 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 verwendet. Es gibt jedoch einen Konstruktor, der eine Char- und eine ganze Zahl verwendet. Die resultierende Zeichenfolge hat das Zeichen so oft wie die Anzahl angibt.

Die am häufigsten verwendeten 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 klonen Sie nicht?

Aber was geschieht, wenn Sie zwei separate Zeichenfolgen haben möchten, die jeweils denselben Wert enthalten? Nun, im Allgemeinen Sie dies nicht wollen. Warum wird der Speicher verschwendet? Und da Zeichenfolgen unveränderlich sind, gibt es nicht viel Sinn, zwei separate Zeichenfolgen mit demselben Wert zu haben.

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

Alles geht jedoch nicht verloren: Sie können die statische Methode Copy verwenden, wenn Sie darauf bestehen, eine zweite Kopie der Zeichenfolge zu haben. Beachten Sie, dass die Referenzgleichheit auf zwei Arten überprüft wird: zuerst durch Aufrufen von Object.ReferenceEqualsund zweitens durch Umwandeln der Verweise auf Objekt vor dem Testen der Gleichheit in C# und mithilfe des Operators Is in Visual Basic.

[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 auch einige oder alle Zeichenfolgen in ein Zeichenarray mit der String.CopyTo--Methode kopieren. (Verwenden Sie einen Zeichenfolgenkonstruktor, der ein Zeichenarray als Parameter verwendet, um eine Zeichenfolge aus einem Zeichenarray oder einem Teil davon zu erstellen.)

Andere Schnittstellen sowie Eigenschaften und ein Feld

Wie wir gesehen haben, implementiert String-ICloneable, obwohl sie auf ungerade (aber vernünftige) Weise funktioniert. Außerdem wird IComparableimplementiert. Das bedeutet, dass Sie zwei Zeichenfolgen mit IComparable's CompareTo-Methode vergleichen können (weitere Informationen hierzu weiter unten). Obwohl StringIConvertableimplementiert, sollten Sie die Methoden in der Convert Klasse verwenden, um eine Zeichenfolge in alle integrierten Werttypen mithilfe der To... Methoden zu konvertieren.

String hat auch einige interessante Eigenschaften. Sie können die Länge (in Zeichen, nicht Byte) einer Zeichenfolge finden, indem Sie auf die Length-Eigenschaft (schreibgeschützt) zugreifen. Außerdem können Sie über die Indexereigenschaft Chars (die dem C#-Indexer zugeordnet ist und auch schreibgeschützt ist) auf die Zeichenfolge um jeweils ein Zeichen 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

Da Zeichenfolgenzeichen beginnend mit Null indiziert werden, auch in Visual Basic .NET, müssen wir darauf achten, dass die Schleife ordnungsgemäß geschrieben wird (das gleiche Problem wird mithilfe des <-Operators 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. Bei Gleichheit und Ungleichheit besteht natürlich ein großer Unterschied darin, ob der Vergleich nach Bezug erfolgt (die beiden Zeichenfolgen zeigen auf dasselbe Objekt) oder nach Wert (sie enthalten dieselben Zeichen).

Bei Gleichheits- und relationalen Vergleichen besteht der andere hauptunterschied darin, ob die Sortierreihenfolge der aktuellen Kultur oder die rohen Ordnungswerte für jedes Zeichen in der Zeichenfolge verwendet werden sollen. (Ein kleiner Unterschied besteht darin, ob bei dem Vergleich die Groß-/Kleinschreibung beachtet wird.) Der Standardwert für Vergleiche besteht darin, dass sie die aktuelle Kultur des Threads verwenden, auf 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, bei dem bei einem kulturabhängigen Vergleich zwischen Groß- und Kleinschreibung unterschieden wird. Wenn Sie in C# einen Verweisvergleich durchführen möchten, wandeln Sie beide Zeichenfolgenverweise in Object um, oder verwenden Sie Object.ReferenceEquals. Verwenden Sie in Visual Basic .NET den Operator Is (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 (=, <>, >, <, >=, <=) führen abhängig von den Compileroptionen und der option Compare-Anweisung entweder ordinale Vergleiche oder kultursensitive Vergleiche durch. Verwenden Sie zum Ausführen eines Referenzvergleichs den Operator Is. Visual Basic .NET verfügt auch über einen Like-Operator für Zeichenfolgenvergleiche, die einfache Musterabgleiche ausführen.

Die Equals Methode kommt in verschiedenen Geschmacksrichtungen. Es gibt zwei Instanzmethoden: eine akzeptiert eine String- als Parameter, und eine akzeptiert ein Object (das auf eine String-verweisen muss). Es gibt auch eine statische Version von Equals, die zwei Zeichenfolgen akzeptiert. Die Version, die ein Object akzeptiert, wird überschrieben (ursprünglich in Objectdefiniert), die eine Zeichenfolge benötigt, ist schneller, da keine Konvertierung erforderlich ist, und die statische Version kann null/Nothing verarbeiten, ohne eine Ausnahme zu auslösen.

Für Vergleiche gibt es drei Methoden: Compare, CompareOrdinalund 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 überladener statischer Methoden, bei denen die Groß-/Kleinschreibung standardmäßig beachtet wird. Jede der Überladungen benötigt mindestens die beiden zu vergleichenden Zeichenfolgen; Es gibt auch Überladungen, um eine booleschen zu übernehmen, die die Groß-/Kleinschreibung angibt, und Int32-s, um Indizes und Die Länge der zu vergleichenden Teilzeichenfolgen anzugeben (anstatt die gesamte Zeichenfolge zu vergleichen).

CompareOrdinal ist ein Paar überladener statischer Methoden, die Ordinalvergleiche von zwei Zeichenfolgen oder Teilzeichenfolgen innerhalb der beiden Zeichenfolgen ausführen.

CompareTo ist eine Instanzmethode, die IComparableimplementiert. Sie vergleicht die aktuelle Zeichenfolge mit der Zeichenfolge oder dem Objekt, die als Parameter übergeben wird, wobei bei Vergleichen zwischen Kultur und Groß-/Kleinschreibung unterschieden wird.

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

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

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

Teilzeichenfolgen- ist wie die alte GW-BASIC MID$--Funktion und die Visual Basic .NET Mid-Funktion, mit der Ausnahme, dass der Index in der Zeichenfolge nullbasiert ist und nicht 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 Formatierungsfähigkeiten, die mit den in unseren Aufrufen von Console.WriteLineverwendet wurden. Sie erstellen und geben eine neue Zeichenfolge mit dem Formatbezeichner zurück, der durch die Zeichenfolgendarstellung der verbleibenden Parameter ersetzt wird. Sie können beispielsweise 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 nicht die Zeit, in diese Zeit zu gehen. Beachten Sie, dass .NET Framework im Allgemeinen kulturbezogene Konvertierungen und Formatierungen vorgibt, es sei denn, Sie übergeben CultureInfo.InvariantCulture an die Formatierungsmethode. Die integrierten .NET-Methoden von Visual Basic werden häufig invarianter Kultur standardmäßig verwendet, also beachten Sie!

Syntaxanalyse

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

Abstand 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), die PadLeft- und PadRight-genannt werden. Es gibt auch mehrere Methoden zum Kürzen der Leerzeichen oder einer reihe von Zeichen, die Sie am Anfang und/oder Ende einer Zeichenfolge angeben (TrimStart, TrimEndund Trim). Diese erstellen alle neue Zeichenfolgen und geben sie zurück.

Einfügen/Entfernen/Ersetzen/Verketten

Diese Methoden ähneln den methoden in StringBuilder, obwohl es weniger Überladungen in String als in StringBuilder. Weitere Informationen zu den Unterschieden finden Sie im Abschnitt "StringBuilder".

Einfügen erstellt eine neue Zeichenfolge mit der angegebenen Zeichenfolge, die an der angegebenen Position eingefügt wurde. Remove erstellt eine neue Zeichenfolge mit der angegebenen Anzahl von Zeichen, die aus der angegebenen Position entfernt wurden. Replace erstellt und gibt eine neue Zeichenfolge mit allen Vorkommen eines angegebenen Zeichens oder einer Zeichenfolge zurück, die durch ein anderes Zeichen oder eine andere Zeichenfolge ersetzt wird. Und die verschiedenen Überladungen der statischen Methode Concat erstellen und zurückgeben neue Zeichenfolgen durch Verketten der übergebenen Zeichenfolgen und/oder Objekte.

Teilen/Beitreten

Split und Join sind leistungsstarke Methoden. Join ist eine statische Methode, die eine Zeichenfolge zurückgibt, die durch Verketten einiger oder aller Zeichenfolgen im übergebenen Zeichenfolgenarray erstellt wird, wobei eine angegebene Zeichenfolge als Trennzeichen verwendet wird. Teilen eine Zeichenfolge in ein neu erstelltes und zurückgegebenes Array von Zeichenfolgen unter Verwendung der angegebenen Trennzeichen aufteilen.

Umwandlungen

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 vom Formular In...sind. Die Liste, die in integrierte Typen in eine Zeichenfolge konvertiert wird, enthält ToBoolean-, ToByte-, ToChar-, ToDecimal, ToDouble, ToInt16, ToInt32ToInt64, ToSByte, ToSingle, ToString, ToUInt16, ToUInt32und ToUInt64. Es gibt auch eine Methode zum Konvertieren in ein DateTime--Objekt –ToDateTime-– und Methoden (FromBase64String und ToBase64String), um zwischen Bytearrays und base64-codierten Zeichenfolgen zu konvertieren (nützlich für das Übertragen von Binären Daten über Textprotokolle).

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

Intern/IsInterned

Die .NET-Laufzeit verwaltet einen Pool von Literalzeichenfolgen in der Anwendungsdomäne (ungefähr ä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 eine Duplizierung von Zeichenfolgenliteralen vermieden wird. (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 korrekt auf Vergleiche von Zeichenfolgenliteralen verweisen können, da nur eine Kopie jedes Zeichenfolgenliterals vorhanden ist.

Wenn Sie jedoch eine Zeichenfolge selbst erstellen, z. B. über eine der String- Methoden, die eine neue Zeichenfolge erstellen, oder mithilfe einer StringBuilder-, handelt es sich um eine andere Zeichenfolge als die Zeichenfolge mit demselben Wert im Literalpool (vorausgesetzt, es gibt einen), sodass Verweisvergleiche fehlschlagen. Dies könnte ein großer Teil sein, da Referenzvergleiche viel schneller als Wertvergleiche sind – alles, was verglichen werden muss, ist die Adresse. (In Code, den Sie wirklich schnell ausführen möchten, können Sie Referenzvergleiche verwenden, wenn Sie sicher sind, dass sie funktionieren!)

Wenn Sie ihre Zeichenfolgen in den Literalpool hinzufügen möchten, können Sie dies mit der statischen Methode Interntun, die die Zeichenfolge zum Literalpool hinzufügt (sofern sie nicht bereits vorhanden ist) und einen Verweis auf die Literalpoolzeichenfolge zurückgibt. Zum 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 denken Sie daran, dass letzten Mal wir die Idee diskutiert haben, dass Sie, wenn Sie Equalsüberschreiben, auch GetHashCodeüberschreiben sollten. In Zeichenfolgen-wird Gleich überschrieben, sodass GetHashCode- ebenfalls eine gute Hashing- und 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, die das Erstellen einer neuen Zeichenfolge umfasst, fahren Sie fort, und verwenden Sie die entsprechende Methode in String (oder die entsprechende Visual Basic .NET-Funktion). Wenn Sie jedoch mehrere Vorgänge ausführen und die benötigten Vorgänge in System.Text.Stringbuilder-verfügbar sind, erstellen Sie eine StringBuilder- aus ihrer Zeichenfolge, führen Sie die mehreren Vorgänge für die StringBuilder-aus, und rufen Sie dann ToString für die StringBuilder- auf, um die Ergebniszeichenfolge zurückzuerhalten. Sehen Sie sich das vorherige Beispiel an, in dem dies alles in einer Zeile erfolgt.

Es ist sehr üblich, eine Zeichenfolge in einer 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 Aufwand für die Verwendung der StringBuilder- ist in der Regel ein Kopiervorgang, nicht zwei. Aus diesem Grund haben wir die Einzeloperationsregel. Bei mindestens zwei Vorgängen ist die Verwendung eines StringBuilder- mindestens so gut.

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

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

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

Es gibt vier Eigenschaften: Capacity, die gelesen oder geschrieben werden können; MaxCapacity, das schreibgeschützt ist; Länge, die aktuelle Länge der Zeichenfolge (kann kürzer oder länger festgelegt werden); und Chars, einem 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 noch nicht groß genug ist.

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

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

Mit den vielen Überladungen von Insert können Sie eine Zeichenfolge (möglicherweise aus einem Aufruf der ToString--Methode) eines Parameters an einer beliebigen Stelle im StringBuilder-einfügen.

Entfernen von ermöglicht es Ihnen, eine beliebige Anzahl von Zeichen an einer beliebigen Position zu entfernen.

Replace ermöglicht das Ersetzen einzelner Zeichen oder, wie bereits erwähnt, teilzeichenfolgen.

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

System.Text Encoders und Decoder

Sie haben bemerkt, 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, daher müssen Sie manchmal von einer anderen Zeichencodierung in Unicode oder von Unicode in eine andere Zeichencodierung konvertieren.

.NET Framework bietet mehrere Klassen zum Codieren (Konvertieren von Unicode-Zeichen in einen Byteblock in einer anderen Codierung) und Decodieren (Konvertieren eines Bytesblocks in einigen Codierungszeichen in Unicode-Zeichen).

Es gibt eine Klasse für jede unterstützte Codierung: ASCIIEncoding, CodePageEncoding, UnicodeEncoding (nützlich für die Konvertierung von Big-Endian in Little-Endian), UTF7Encodingund 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 jede GetEncoder- und GetDecoder-, die Encoder und Decoder zurückgeben, die den Schichtzustand beibehalten können, sodass sie mit Datenströmen und Blöcken verwendet werden können.

Reguläre Ausdrücke

Möglicherweise haben Sie bemerkt, dass Visual Basic .NET einen eingeschränkten regulären Ausdrucksabgleich über die Like-Anweisung unterstützt. Darüber hinaus unterstützt .NET Framework eine 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 die Verwendung bereitstellt, einschließlich suchen und ersetzen reguläre Ausdrücke in Zeichenfolgen und Teilen einer Zeichenfolge in ein Array von Zeichenfolgen. Die Dokumentation zu regulären Ausdrücken ist jetzt spärlich, daher werden wir noch nicht in die Dokumentation eingehen. Vielleicht in einer zukünftigen Spalte.

Versuch es doch mal!

Wer befindet sich in Ihrem .NET Framework-Lernteam?

Der gute Arzt hofft, dass Sie nicht nur mit .NET spielen, sondern auch mit anderen Leuten arbeiten. Es macht mehr Spaß auf diese Weise, und Sie werden garantiert mehr erfahren.

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

Sehen Sie sich die Quelldateian. Kopieren Sie es in Visual Studio, und nehmen Sie eigene Änderungen vor.

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

Führen Sie einige Zeichenfolgenmanipulationen mit StringBuilder-aus. Und verwenden Sie einige der erweiterten Funktionen von String-, um eine Zeichenfolge zu analysieren, z. B. eine Befehlszeile.

Wenn Sie wirklich spaßigen, versuchen Sie, verschiedene Zeichensätze und Codeseiten zu codieren und zu decodieren. Wenn Sie für einen echten Nachdruck geeignet sind, arbeiten Sie mit den Klassen für reguläre Ausdrücke zusammen.

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.

  • Last updated on