16.2 Die Klasse »String«

String-Variablen repräsentieren Zeichenfolgen mit einem ganz wesentlichen Charakteristikum: Sie sind unveränderlich. Ändern Sie den Inhalt einer Zeichenfolgevariablen durch eine neue Zuweisung, wird ein neues String-Objekt erzeugt und das alte verworfen. Dieses Phänomen können Sie sehr einfach verstehen, wenn Sie das folgende Listing ausprobieren:

string text = "Hallo";
Console.WriteLine(text.GetHashCode());
text = "Berlin";
Console.WriteLine(text.GetHashCode());

Listing 16.6 Ändern des Inhalts einer »String«-Variablen

Das Ergebnis wird sein, dass unterschiedliche Hashcodes in der Konsole angezeigt werden. Daraus kann der Schluss gezogen werden, dass beim Ändern des Werts der String-Variablen tatsächlich ein neues Objekt erzeugt worden ist.

Diesem anscheinenden Nachteil steht aber auch ein Vorteil gegenüber, denn intern verwaltet die Laufzeitumgebung eine Tabelle, die jeden String einer Anwendung enthält. Wenn Sie zur Laufzeit ein neues String-Objekt erzeugen, wird zuerst die Tabelle nach einem identischen String durchsucht. Ist ein solcher vorhanden, wird der neuen String-Variablen eine Referenz auf die bereits existierende Instanz zurückgeliefert, andernfalls wird der Pool vergrößert. Auch das können Sie sehr einfach prüfen, wenn Sie das Codefragment ein klein wenig ändern:

string text = "Hallo";
Console.WriteLine(text.GetHashCode());
string text1 = "Hallo";
Console.WriteLine(text1.GetHashCode());

Listing 16.7 »String«-Variablen gleichen Inhalts

Nun werden an der Konsole identische Hashcodes angezeigt.

Wird eine Zeichenfolge häufig verändert, werden die vorhandenen Ressourcen möglicherweise an den Rand ihrer Möglichkeiten getrieben, mit der Konsequenz der Performanceeinbuße.

16.2.1 Das Erzeugen eines Strings

Im einfachsten Fall wird ein Objekt vom Typ String durch eine einfache Deklaration erzeugt:

string str = "C# ist spitze!";

Das ist der Weg, den wir bisher meistens beschritten haben und der wohl auch die Regel darstellt. Es gibt aber noch weitere Möglichkeiten. Dazu sind in der Klasse String mehrere Konstruktoren definiert. Beispielsweise können Sie einem Konstruktor ein char-Array übergeben, aus dem ein String-Objekt erstellt wird:

char[] charArr = {'C','#',' ','5','.','0'};
string strText = new String(charArr);
Console.WriteLine(strText);

Dieses Codefragment bildet aus dem char-Array die Zeichenfolge »C# 5.0«.

Mit einem weiteren Konstruktor können Sie eine Zeichenfolge erzeugen, die sich aus einer bestimmten Anzahl gleicher Zeichen zusammensetzt. Benötigen Sie beispielsweise eine Zeichenfolge aus zehn »*«, könnten Sie das mit

string strtext = new String('*', 10);

erreichen.

16.2.2 Die Eigenschaften von »String«

String weist nur zwei Eigenschaften auf: Length und Chars. Length liefert die Anzahl der Zeichen, und mit Chars können Sie auf ein einzelnes Zeichen aus der Zeichenfolge zugreifen. Die Definition von Chars, die in C# als Indexer implementiert ist, lautet wie folgt:

public char this[int index] {get;}

Übergeben wird dem Indexer eine Zahl, die die Position eines Zeichens innerhalb der Zeichenfolge beschreibt, z. B.:

string text = "HALLO";
char newChar = text[2];

Die char-Variable enthält damit das Zeichen »L«.

16.2.3 Die Methoden der Klasse »String«

Sie werden sich oft mit der einfachen Existenz einer Zeichenfolge nicht zufrieden geben, da es sehr häufig vorkommt, dass Zeichenfolgen verglichen oder manipuliert werden müssen oder eine formatierte Ausgabe erwünscht ist. Die Klasse String bietet zu diesem Zweck eine Reihe von Methoden an, die wir uns nun ansehen wollen.

Zeichenfolgen-Vergleiche

Um zwei Zeichenfolgen zu vergleichen, haben Sie die Qual der Wahl, denn dazu stehen Ihnen mit Equals, Compare, CompareTo und CompareOrdinal gleich vier Methoden zur Verfügung. Alle sind sich ähnlich und unterscheiden sich nur in kleinen Nuancen.

Bekanntlich werden mit Equals standardmäßig zwei Referenzen miteinander verglichen. Da zwei String-Variablen, die denselben Inhalt haben, ein und dasselbe Objekt im Speicher referenzieren, können Sie diese Methode auch dazu benutzen, den Inhalt der Variablen miteinander zu vergleichen. Verweisen zwei Strings auf dieselbe Speicheradresse, muss deren Inhalt zwangsläufig identisch sein.

Sehr ähnlich arbeitet auch Compare. Die Methode liefert jedoch keinen booleschen Wert, sondern einen Integer, der entweder < 0, 0 oder > 0 ist. Dazu ein Beispiel:

string strText = "Hallo";
string myString = "Hallo";
if(String.Compare(strText, myString) == 0)
   Console.WriteLine("Die beiden Strings sind identisch");

Listing 16.8 Zeichenfolgenvergleich mit der Methode »Compare«

Das Ergebnis an der Konsole bestätigt, dass beide Zeichenfolgen denselben Inhalt aufweisen. Ändern wir nun einen der beiden Strings von »Hallo« in »hallo«, und wir testen noch einmal. Diesmal erhalten wir keine Bestätigung, was uns zu folgender Aussage führt:

Die Interpretation der Rückgabewerte von Compare, die ebenfalls für die Vergleichsmethode CompareTo gilt, können Sie Tabelle 16.2 entnehmen.

Die spezifische Ländereinstellung entscheidet darüber, wann ein Zeichen als größer oder kleiner im Vergleich zu einem zweiten gilt. Im mitteleuropäischen Sprachraum ist festgelegt, dass den Großbuchstaben ein größerer Wert zugeordnet ist als ihrem kleingeschriebenen Pendant. Daher gilt:

A > a
B > b

Innerhalb von Groß- bzw. Kleinbuchstaben gilt die Reihenfolge, dass A < B < C bzw. a < b < c ist. Ganz allgemein kann man die Sortierregel dann wie folgt beschreiben:

a < A < b < B < c < C ... < y < Y < z < Z

Compare durchläuft die beiden zu vergleichenden Zeichenfolgen Zeichen für Zeichen. Dabei wird zunächst die Wertigkeit eines Buchstabens im Alphabet festgestellt, und bei Gleichheit wird zwischen Groß- und Kleinschreibung unterschieden.

CompareOrdinal vergleicht zwei Zeichenfolgen auf Basis der ANSI-Werte. Die Methode durchläuft dazu die beiden Zeichenfolgen Zeichen für Zeichen. Stimmt auch das letzte Zeichen in beiden Zeichenfolgen überein, ist der Rückgabewert 0. Stellt die Methode an einer Ordinalposition keine Übereinstimmung fest, bricht die Methode ab und liefert als Rückgabewert die Differenz der Zeichencodes. Tabelle 16.3 zeigt dies mit den Zeichenfolgen text1 und text2.

Fassen wir zum Abschluss noch einmal alle Vergleichsoperationen zur besseren Übersicht in einer Tabelle zusammen.

Suchen in einer Zeichenkette

Viele Aufgaben, die sich im Zusammenhang mit Zeichenfolgen stellen, beziehen sich auf die Suche nach einem bestimmten Zeichen oder nach einer Abfolge von Zeichen innerhalb einer Zeichenfolge. Das Ergebnis der Suche wird beispielsweise zur Konstruktion eines neuen Strings oder als Anweisung innerhalb einer anderen, äußeren Anweisung benötigt. Wir wollen uns im Folgenden diese Methoden und ihren Einsatz anschauen. Doch zunächst verschaffen wir uns einen ersten Überblick:

• StartsWith
• EndsWith
• IndexOf
• LastIndexOf
• Substring

Fangen wir mit den beiden erstgenannten Methoden an, die in ihrer Funktionalität einander sehr ähnlich sind: Mit StartsWith und EndsWith wird der Anfang oder das Ende einer Zeichenfolge auf eine vorgegebene Zeichensequenz hin überprüft. Beide liefern als Ergebnis ihres Aufrufs einen booleschen Wert zurück.

Die Anzahl der dem Parameter mitgeteilten Zeichen spielt keine Rolle, es kann sich um ein einzelnes handeln oder um eine Zeichenfolge. Mit

string text = "Eine Kröte überquert die Fahrbahn";
if (text.StartsWith("Ein"))
  [...]

Listing 16.9 Die Methode »String.StartsWith«

werden Sie demnach das Ergebnis true erhalten. In gleicher Weise lässt sich die Methode EndsWith einsetzen:

string text = "Eine Kröte überquert die Fahrbahn";
if (text.EndsWith("Bahn"))
  [...]

Listing 16.10 Die Methode »EndsWith«

Beachten Sie, dass die Groß- und Kleinschreibung auch bei der Untersuchung einer Zeichenfolge berücksichtigt wird. Daher wird der Rückgabewert in diesem Fall false sein.

Mit IndexOf bzw. LastIndexOf lässt sich das erste oder das letzte Auftreten eines Zeichens oder einer Zeichenkette ermitteln. Beide Methoden sind vielfach überladen und erlauben die Übergabe eines char ebenso wie die Übergabe einer Zeichenfolge, nach der gesucht werden soll. Der Rückgabewert ist die Position, an der das oder die Zeichen zum ersten Mal auftritt bzw. auftreten. Ist die Suche erfolglos, ist der Rückgabewert –1.

Im einfachsten Fall ähnelt die Funktionalität der beiden Methoden der von StartsWith und EndsWith. Die Überladung ermöglicht es aber, die Suche ab einer bestimmten Position zu beginnen und – falls gewünscht – die Anzahl der Positionen anzugeben, an denen das Original mit dem Suchstring verglichen wird. Das folgende Codefragment demonstriert den Einsatz der IndexOf-Methode.

string = "Da wird der Hund in der Pfanne verrückt.";
int position = –1;
do {
  position++;
  pos = text.IndexOf("der", position);
  if(position == –1)
    Console.WriteLine("Ende des Strings erreicht.");
  else
    Console.WriteLine("Vorkommen an Position {0}", position);
} while(!(position == –1));

Listing 16.11 Die Methode »String.IndexOf«

Wir geben zwar nur eine statische Zeichenfolge vor, aber das sollte uns in dieser Demonstration genügen. Gesucht wird in dieser Zeichenfolge der Teilstring »der«. Wir deklarieren zunächst die Variable position, die in der folgenden do-Schleife als Positionszeiger dient und der das Ergebnis des Aufrufs IndexOf zugewiesen wird. Wird der gesuchte Teilstring gefunden, muss der Positionszeiger um eine Position verschoben werden, um nicht in einer Endlosschleife zu enden. Das hat aber zur Konsequenz, dass vor dem Eintritt in die Schleife position mit –1 vorinitialisiert werden muss, damit die Suche beim ersten Schleifendurchlauf auch mit 0 startet.

Der Ausstieg aus der Schleife ist gewährleistet, wenn IndexOf das Ergebnis –1 liefert. Innerhalb des zu durchsuchenden Strings ist der Suchstring an den Positionen 8 und 20 enthalten. Beachten Sie, dass dem ersten Zeichen im zu durchsuchenden String der Index 0 zugeordnet ist.

Etwas allgemeiner gehalten ist die sehr flexibel einsetzbare Methode Substring, die überladen ist und aus einer gegebenen Zeichenfolge einen Teilstring zurückliefert. Substring wird in jedem Fall der Index der Startposition übergeben, ab der ein vorhandener String ausgewertet wird. Übergeben Sie einen zweiten Parameter, können Sie zudem die Anzahl der einzulesenden Zeichen ab der im ersten Parameter angegebenen Position festlegen. Wollen Sie beispielsweise die ersten sieben Zeichen einer Zeichenfolge einlesen, würde die Anweisung dazu wie folgt lauten:

string text = "Projektmappen-Explorer";
string teilString = text.Substring(0, 7);

Listing 16.12 Die Methode »String.SubString«

Die Variable teilString wird den Inhalt »Projekt« haben. Benötigen Sie einen Teilabschnitt vom Ende eines Strings – nehmen wir an, die letzten acht Zeichen –, setzen Sie den Positionszeiger auf das erste einzulesende Zeichen, indem Sie von der Gesamtlänge des Strings die Anzahl der einzulesenden Zeichen subtrahieren:

String text = "Projektmappen-Explorer";
string teilString = teilString.Substring(teilString.Length – 8, 8);

Nun lautet der Inhalt von teilString »Explorer«.

Die Methoden »Trim« und »Pad«

Stellen Sie sich vor, Sie schreiben ein Programm, das auf eine Datenbank zugreift. In der Datenbank befindet sich eine Tabelle mit dem Kundenstamm eines Unternehmens. Aus dieser Tabelle soll ein ganz bestimmter Datensatz herausgegriffen werden, beispielsweise um die Kundendaten einzusehen oder zu ändern. Um nicht die gesamte Kundenliste der Reihe nach zu durchforsten (natürlich auch, um die Ressourcen zu schonen und um eine gute Performance der Anwendung zu gewährleisten), sollte der Anwender dazu aufgefordert werden, den Namen des Unternehmens anzugeben. Diese Eingabe wird nachfolgend dazu benutzt, in der Tabelle den passenden Datensatz zu suchen und ihn an den Anwender zurückzugeben.

Nehmen wir an, der Anwender sucht nach dem Unternehmen »Tollsoft GmbH« und gibt dazu das folgende Suchkriterium ein, nach dem der Kundenstamm der Tabelle durchsucht wird:

Tollsoft GmbH

Fällt Ihnen etwas auf? Wenn nicht, dann sei Ihnen gesagt, Sie machen denselben Fehler wie unser fiktiver Anwender – der Datensatz wird nämlich nicht gefunden. Der Grund ist ganz trivial: Vor dem Namen des Unternehmens steht – kaum bemerkbar – ein Leerzeichen. "Tollsoft GmbH" und "Tollsoft GmbH" sind aber unterschiedliche Firmennamen – zumindest aus Sicht des Programms. Fehler dieser Art schleichen sich sehr schnell ein und müssen daher schon in der Entwicklungsphase ausgeschlossen werden.

Die Klasse String stellt Ihnen zur Lösung die Methoden Trim, TrimStart und TrimEnd zur Verfügung. Trim entfernt bestimmte Zeichen sowohl am Anfang als auch am Ende einer Zeichenfolge, und TrimStart und TrimEnd entfernen bestimmte Zeichen am Anfang bzw. Ende einer Zeichenfolge.

Sehen wir uns die Definition der Methode Trim an, die einfach überladen ist:

public string Trim();
public string Trim(params char[]);

Die erste Variante wird auf ein String-Objekt aufgerufen und entfernt automatisch die Leerzeichen, die sich am Anfang und am Ende der Zeichenfolge befinden. Die parameterlose Trim-Methode ist damit auf Leerzeichen spezialisiert und dürfte in den meisten Anwendungsfällen genügen.

Die parametrisierte Version ist deutlich leistungsfähiger. Ihr wird ein char-Array übergeben, das diejenigen Zeichen enthält, die weder am Anfang noch am Ende der Zeichenfolge erlaubt sind. Das folgende Codefragment zeigt die Wirkungsweise der Methode:

string text = "Am Straßenrand sitzt eine Kröte.";
char[] charArr = {' ','m','A','.'};
text = text.Trim(charArr);

Listing 16.13 Die Methode »String.Trim«

Wir definieren das Array so, dass weder das Leerzeichen noch ein Punkt oder die Buchstaben »A« und »m« zugelassen sind. Die aus dem Aufruf der Trim-Methode resultierende Zeichenfolge wird lauten:

Straßenrand sitzt eine Kröte

Sehr ähnlich arbeiten auch die beiden Methoden TrimStart und TrimEnd, die nicht überladen sind und ein char-Array als Übergabeparameter erwarten.

Die Methoden PadLeft und PadRight schneiden keine Zeichen an den String-Enden ab, sondern fügen bestimmte Zeichen entweder am Anfang oder Ende der Zeichenfolge hinzu. Auch diese Methoden sind überladen. Wir wollen uns kurz beide Parameterlisten anschauen:

public string PadLeft(int);
public string PadLeft(int, char);

Dieselbe Überladungsliste weist auch die Methode PadRight auf.

Die einfach parametrisierte Variante hängt Leerzeichen an den Anfang (PadLeft) oder das Ende (PadRight) der Zeichenfolge an. Der Integer gibt an, wie lang die am Ende resultierende Zeichenfolge insgesamt werden soll – einschließlich der Anzahl der Zeichen des Strings selbst. Wenn Sie einen Wert übergeben, der gleich oder kleiner der Länge der Zeichenfolge ist, verpufft der Methodenaufruf wirkungslos. Daher ist es sinnvoll, die Länge der Zeichenfolge zu bestimmen und dazu die Anzahl der gewünschten Leerzeichen zu addieren.

string text = "Kaffeepause";
Console.WriteLine(text.PadLeft(text.Length + 3));

Listing 16.14 Die Methode »String.PadLeft«

Wenn Sie ein anderes Zeichen am Anfang oder Ende des Strings wünschen, müssen Sie sich für die zweite Variante der Methode entscheiden. Dem zweiten Parameter übergeben Sie das gewünschte Zeichen als char:

string text = "Kaffeepause"; 
text = text.PadLeft(text.Length + 3, '*');
text = text.PadRight(text.Length + 3, '*');

Listing 16.15 Die Methoden »String.PadLeft« und »String.PadRight«

Das Ergebnis der Operationen lautet »***Kaffeepause***«.

Zeichenfolgen ändern

Bisher haben wir Strings verglichen, nach bestimmten Zeichensequenzen in einer Zeichenfolge gesucht und am Anfang oder am Ende einer Zeichenfolge Zeichen beliebiger Länge angehängt. Eine Reihe weiterer Methoden eröffnet uns die Möglichkeit, in der Zeichenfolge einzelne Zeichen zu manipulieren, indem wir sie durch andere ersetzen oder einfach aus dem String löschen. Zu diesen Methoden gehören:

• Insert
• Remove
• Replace
• Split
• ToUpper
• ToLower

ToUpper und ToLower sind sehr einfach einzusetzen. Sie wandeln alle Zeichen einer Zeichenfolge entweder in Großbuchstaben (ToUpper) oder in Kleinbuchstaben (ToLower) um. Aus

string text = "Visual Studio .NET";

wird mit

text = text.ToUpper();

der Inhalt zu:

VISUAL STUDIO .NET

Einsetzen oder Ersetzen eines Teilstrings

Manchmal ist es notwendig, eine Zeichenfolge ab einer bestimmten Position zu erweitern, ohne dabei aus dem Original Zeichen durch Überschreiben zu löschen. Hier spielt Insert seine Möglichkeiten aus:

public string Insert(int, string);

Dem ersten Parameter übergeben Sie die Position, ab der die im zweiten Parameter genannte Zeichenkette eingefügt werden soll. Aus der Zeichenfolge

string text = "C# ist spitze.";

wollen wir die noch näher an der Wahrheit liegende Zeichenfolge

"C# ist absolut spitze."

formulieren. Den String, den wir mittels Insert einfügen wollen, kennen wir. Was noch fehlt, ist die Position, ab der er eingefügt werden soll. Dabei hilft IndexOf weiter:

text = text.Insert(text.IndexOf("spitze"), "absolut ");

Diese Methode liefert den Index des ersten Zeichens der übergebenen Zeichenfolge spitze, der als Einfügemarke für das zusätzliche Wort von Insert benutzt wird.

Mit Replace können Sie einen String – man sollte besser von einem Teilstring sprechen – durch einen anderen ersetzen. Replace ist aber nicht nur auf den Austausch einer bestimmten Zeichensequenz in einer Zeichenfolge beschränkt, es kann auch jedes Zeichen durch ein anderes ersetzt werden.

public string Replace(char, char);
public string Replace(string, string);

Der erste Parameter beschreibt das zu ersetzende Zeichen bzw. die zu ersetzende Zeichenfolge. Wodurch ersetzt werden soll, weiß der zweite Parameter zu berichten. Sollte Ihnen der Satz »Schule macht viel Spaß« nicht gefallen, können Sie ihn mit

text = text.Replace("viel", "nie");

in eine möglicherweise ehrlichere Aussage überführen.

Die »Split«-Methode

Es können Situationen auftreten, in denen mehrere Zeichenketten vorliegen, die Sie für eine bestimmte Operation wie eine einzige Zeichenkette behandeln wollen. Stellen Sie sich dazu vor, Sie möchten Ihre Adresse über das Netzwerk einer anderen Person mitteilen. Dazu können Sie zuerst Ihren Vornamen bekannt geben, im Anschluss daran Ihren Zunamen, schließlich den Wohnort usw. Besser wäre es, die vollständige Information in einem String zu verschicken und sich mit dem Empfänger auf ein Format zu einigen, nach dem der übermittelte String wieder in seine ursprünglichen Einzelstrings zerlegt werden kann und die Substrings zu interpretieren sind. Schließlich müssen beide Parteien wissen, ob es sich bei Otto um den Vor- oder Zunamen handelt.

Neben der Interpretationsreihenfolge müssen Sie ein als Separator dienendes Zeichen festlegen, das die Teilzeichenfolgen voneinander trennt. Haben sich Sender und Empfänger darüber geeinigt, lässt sich die beim Empfänger eingehende Zeichenfolge in die ursprünglichen Teilstrings zerlegen.

Die String-Klasse unterstützt mit ihrer Methode Split das eben beschriebene Szenario des Zerlegens einer Zeichenfolge in Teilstrings. Schauen wir uns zunächst einmal die Definition der Split-Methode an:

public string[] Split(params char[]);

Die Methode durchsucht den String, auf den Split aufgerufen wird, nach den spezifizierten Separatoren, die dem Parameter mitgeteilt werden. Da dieser Parameter als params-Parameter definiert ist, können durchaus mehrere verschiedene Trennzeichen spezifiziert werden. Das eröffnet Interpretationsmöglichkeiten hinsichtlich der Teilzeichenfolgen. So könnten Sie beispielsweise festlegen, dass als Separator zwischen dem Vor- und dem Zunamen ein Semikolon benutzt wird, zwischen dem Zunamen und dem Wohnort ein Ausrufezeichen usw. Die einzelnen Teilstrings werden in einem String-Array an den Aufrufer zurückgegeben.

Wir wollen uns die Arbeitsweise dieser etwas komplexeren Methode an einem Beispiel verdeutlichen und legen dazu fest, das Semikolon als Separator zu benutzen. Eine Methode, die in der Lage ist, eine ihr übergebene Zeichenfolge wieder in die ursprünglichen Teilstrings zu zerlegen, könnte wie folgt aussehen:

public static void GetSubstrings(string text) {
  string[] liste = text.Split(';');
  for(int i = 0; i <= liste.GetUpperBound(0); i++)
    Console.WriteLine(liste[i]);
}

Listing 16.16 Zerlegen einer Zeichenfolge in Teilstrings

Beim Aufruf der Methode GetSubstrings wird dem Parameter text eine Zeichenfolge übergeben, deren Teilstrings durch ein Semikolon getrennt sind. In der Methode wird text in seine Teilstrings zerlegt und dem Array liste zugewiesen. Die Aufsplittung erfolgt mit der Split-Methode auf das Objekt text. Der Semikolon-Separator wird der Split-Methode als Argument übergeben. In den einzelnen Elementen des String-Arrays liegen danach alle Teilzeichenfolgen vor, die in einer Schleife der Reihe nach an der Konsole angezeigt werden.

Nun wollen wir die Methode testen und entwickeln dazu ein kleines Beispielprogramm:

static void Main(string[] args) {
  string[] str = new String[4];
  str[0] = "Busch;";
  str[1] = "Fridolin;";
  str[2] = "Schlauberger Gasse 12;";
  str[3] = "München";
  string strArr;
  strArr = string.Concat(str);
  GetSubstrings(strArr);
  Console.ReadLine();
}

Listing 16.17 Testen der Methode »GetSubstrings« aus Listing 16.16

Der Konvention folgend, ist bis auf die Angabe des Wohnortes hinter jedem String ein Strichpunkt als Abschluss gesetzt. Jeder String wird als Element eines Arrays gespeichert.

Um aus allen Teilstrings einen einzigen zu erstellen, könnten wir mit dem +-Operator arbeiten, aber die Klasse String bietet uns eine Alternative in Form der Methode Concat an. Diese dient dazu, aus mehreren Einzelstrings einen Gesamtstring zu erzeugen. Concat ist überladen, um den vielfältigen Anforderungen gerecht zu werden, die sich bei der String-Verknüpfung ergeben. Im Beispielcode fiel die Entscheidung auf die überladene Methode, die als Argument ein String-Array erwartet und aus allen Array-Elementen einen String erzeugt, der unserer benutzerdefinierten Methode GetSubstrings übergeben wird.

Die Ausgabe an der Konsole beweist die korrekte Interpretation: Der übergebene String wird wieder in seine ursprünglichen Substrings zerlegt. Beachten Sie, dass die Split-Methode die Trennzeichen im String erkennt und weiß, dass diese nicht zu den einzelnen String-Objekten gehören. Sie werden deshalb automatisch entfernt.

Zeichenfolgen und »char«-Arrays

Sie werden, wenn Sie sich intensiver mit den Klassen des .NET Frameworks beschäftigen, immer wieder auf Methoden treffen, die Parameter entweder vom Typ eines char-Arrays oder vom Typ string deklarieren. Je nach Ausgangssituation im Programm ist dann die Umwandlung eines char-Arrays in string oder umgekehrt notwendig. Möchten Sie aus einem char-Array einen String erzeugen, übergeben Sie dem passenden string-Konstruktor die Referenz auf das Array, beispielsweise:

char[] charArr = {'K','a','r','n','e','v','a','l'};
string text = new string(charArr);

Der umgekehrte Weg, die einzelnen Zeichen einer string-Referenz in ein char-Array zu schreiben, scheint ein wenig kniffliger zu sein. Mit den bisher gezeigten Methoden der Klasse String sollte das kein allzu großes Problem sein, aber die .NET-Baumeister haben Ihnen diese Arbeit bereits abgenommen, wie ein Blick in die Dokumentation der String-Klasse verrät. Diese veröffentlicht die Methode ToCharArray:

public char[] ToCharArray();
public char[] ToCharArray(int, int);

Entscheiden Sie sich für die parameterlose Methode, werden die Zeichen des gesamten Strings, auf dem die Methode aufgerufen wird, einem char-Array zugewiesen. Wollen Sie ab einer bestimmten Position einen Teil des Strings einem char-Array zuweisen, entscheiden Sie sich für die parametrisierte ToCharArray-Methode. Das folgende Listing benutzt die parameterlose Methode, um das Array zu füllen und anschließend die einzelnen Elemente zeilenweise an der Konsole auszugeben:

string text = "Quantenmechanik";
char[] charArray = text.ToCharArray();
for(int i = 0; i<= charArray.GetUpperBound(0); i++)
   Console.WriteLine(charArray[i]);

Listing 16.18 Zeichenfolge in ein »char«-Array umwandeln

An der Konsole wird das Wort, das ursprünglich durch einen String gebildet wurde, nun Buchstabe für Buchstabe in je einer Zeile angezeigt.

16.2.4 Zusammenfassung der Klasse »String«

Zum Abschluss unserer Betrachtungen der Klasse String wollen wir des besseren Gesamtüberblicks wegen in tabellarischer Form noch einmal alle in diesem Abschnitt erwähnten Methoden auflisten.

Ihre Meinung

Wie hat Ihnen das Openbook gefallen? Wir freuen uns immer über Ihre Rückmeldung. Schreiben Sie uns gerne Ihr Feedback als E-Mail an kommunikation@rheinwerk-verlag.de.