namespace Zeichenketten {\r\n class Program {\r\n static void Main(string[] args) {\r\n String zeichenfolge = \"Beispieltext\";\r\n Console.WriteLine(zeichenfolge);\r\n Console.ReadLine();\r\n }\r\n }\r\n}<\/pre>\nDie Anweisung zum Deklarieren und Füllen der Variablen können Sie, wie üblich, auch auf zwei Anweisungen aufteilen:<\/p>\n
String zeichenfolge;\r\nzeichenfolge = \"Beispieltext\";<\/pre>\nEin String ist ein Array<\/h2>\n
Eingangs haben wir die Behauptung aufgestellt, dass ein String<\/b>-Objekt Eigenschaften eines Array aufweisen würde. Dabei handelt es sich beispielsweise um die Möglichkeit, per Index auf die einzelnen Elemente des Typs Char <\/b>zuzugreifen oder diese sogar per foreach<\/b>-Schleife zu durchlaufen. Um diese Erkenntnis zu gewinnen, gibt es zwei Möglichkeiten: Die erste ist es, sich einfach per IntelliSense die Eigenschaften und Methoden des String<\/b>-Objekts anzeigen zu lassen. Oder Sie öffnen mit Strg + Alt + J <\/b>den Objektkatalog und suchen dort nach der Zeichenkette String<\/b>, was unter System.String<\/b> schnell den richtigen Treffer liefert (siehe Bild 1).<\/p>\n
![\"Ausgabe](\"..\/fileadmin\/_temp_\/2015_02\/pic_11_001.png\")
<\/p>\n
Bild 1: Ausgabe zweier Write-Anweisungen<\/span><\/b><\/p>\nBuchstaben per foreach-Schleife durchlaufen<\/h2>\n
Wenn Sie sich die Basistypen des String<\/b>-Objekts ansehen, stoßen Sie schnell auf die IEnumerable<\/b>-Schnittstelle. Ist diese vorhanden, können Sie die Elemente eines Objekts per foreach<\/b>-Schleife durchlaufen.<\/p>\n
Dies erledigen wir im folgenden Beispiel, wo wir eine for-each<\/b>-Schleife über alle Char<\/b>-Elemente des String<\/b>-Objekts zeichenfolge <\/b>durchlaufen und das jeweilige Char<\/b>-Element mit der Variablen buchstabe <\/b>referenzieren. Innerhalb der Schleife geben wir den Inhalt der Char<\/b>-Variablen buchstabe <\/b>zweimal aus – einmal unbehandelt und einmal zu einem Integer-Wert konvertiert:<\/p>\nString zeichenfolge = \"Beispieltext\";\r\nforeach(Char buchstabe in zeichenfolge) {\r\n Console.WriteLine(\"{0} {1}\", buchstabe, \r\n (int)buchstabe);\r\n}\r\nConsole.ReadLine();<\/pre>\nDas Ergebnis sieht wie in Bild 2 aus – neben dem Buchstaben erscheint der ASCII-Wert entsprechend der UTF-16-Kodierung für das jeweilige Zeichen.<\/p>\n
![\"Ausgabe](\"..\/fileadmin\/_temp_\/2015_02\/pic_11_002.png\")
<\/p>\n
Bild 2: Ausgabe der Char-Elemente eines String-Objekts als Text und Integer<\/span><\/b><\/p>\nStatt int <\/b>hätten wir hier auch den Datentyp byte <\/b>verwenden können:<\/p>\n(byte)buchstabe<\/pre>\nZeichenkette mit for durchlaufen<\/h2>\n
Das folgende Beispiel zeigt, wie Sie die Anzahl der enthaltenen Zeichen in einer String<\/b>-Variablen ermitteln. Mit diesem Wert können wir dann eine for<\/b>-Schleife definieren, die mit jedem Durchlauf das aktuelle Char<\/b>-Element über den Index der String<\/b>-Variablen zeichenfolge <\/b>ermittelt und der Variablen buchstabe <\/b>zuweist.<\/p>\n
Auch hier landen der Buchstabe und der ASCII-Code in der Ausgabe:<\/p>\n
String zeichenfolge = \"Beispieltext\";\r\nint anzahl = zeichenfolge.Length;\r\nfor (int i = 0; i < anzahl; i++) {\r\n Char buchstabe = zeichenfolge[i];\r\n Console.WriteLine(\"{0} {1}\", buchstabe, \r\n (int)buchstabe); \r\n}\r\nConsole.ReadLine();<\/pre>\nDies ist schon einmal erheblich einfacher als unter VBA – dort hätten Sie erstens nur eine For…Next<\/b>-Schleife verwenden können, um auf die einzelnen Zeichen zuzugreifen, und zweitens hätten wir für jeden einzelnen Zugriff die Mid<\/b>-Funktion auf die Zeichenkette anwenden müssen:<\/p>\nFor i = 0 To Len<\/span>(strZeichenkette)\r\n Debug.Print<\/span> Mid<\/span>(strZeichenkette, i, 1)\r\nNext<\/span> i<\/pre>\nZur Ermittlung des ASCII-Codes hätten wir dort noch die Funktion Asc <\/b>verwenden müssen, statt einfach nur den Buchstaben in den Zahlentyp int <\/b>oder byte <\/b>zu konvertieren.<\/p>\n
Übrigens können Sie auch einfach über den Index auf ein Zeichen eines String-Objekts zugreifen – beispielsweise wie folgt auf das erste Zeichen:<\/p>\n
string Vorname = \"André\";\r\nchar Buchstabe = Vorname[0];<\/pre>\nUnterschied zwischen String und Char<\/h2>\n
Es gibt eine Reihe Unterschiede zwischen string<\/b>– und char<\/b>-Objekten. Einen haben Sie schon kennen gelernt: Ein Char ist ein Element eines Arrays, das in einer string<\/b>-Variablen gespeichert wird. Ein anderer ist, dass nicht beide etwa beim Zuweisen in Anführungszeichen eingefasst werden.<\/p>\n
Beim string <\/b>verwenden Sie das übliche Anführungszeichen:<\/p>\nstring zeichenfolge;\r\nzeichenfolge = \"Beispieltext\";<\/pre>\nBei einer Char<\/b>-Variable, die ja nur ein Zeichen aufnehmen kann, verwenden Sie hingegen einfache Anführungszeichen:<\/p>\nChar zeichen;\r\nzeichen = ''A'';<\/pre>\nDies nur, damit Sie sich nicht über Fehlermeldungen wundern, wenn Sie einmal einer Char<\/b>-Variablen ein Zeichen in Anführungszeichen übergeben möchten (Eine implizite Konvertierung von Typ ”string” in ”char” ist nicht möglich.<\/b>).<\/p>\nZeichenfolge aus Char-Elementen zusammensetzen<\/h2>\n
Eine Zeichenfolge müssen Sie nicht immer direkt zuweisen; Sie können diese auch aus einem Array von char<\/b>-Objekten zusammenstellen. Dazu brauchen Sie einfach nur das char<\/b>-Array als Parameter beim Erstellen einer neuen String<\/b>-Instanz anzugeben:<\/p>\nchar[] chars = { ''A'', ''n'', ''d'', ''r'', ''é'' };\r\nString strChars = new String(chars);\r\nConsole.WriteLine(\"String aus Char-Array: {0}\", strChars);\r\n\/\/Ausgabe:\r\n\/\/String aus Char-Array: André<\/pre>\nPosition einer Teilzeichenkette ermitteln<\/h2>\n
Unter VBA war hierzu die Funktion InStr <\/b>angezeigt, wenn Sie das erste Auftreten einer Teilzeichenfolge ermitteln wollten, und InStrRev<\/b>, wenn das erste Auftreten der Teilzeichenfolge von hinten gefragt war.<\/p>\n
Das erste Auftreten einer Zeichenfolge in einer String<\/b>-Variablen ermitteln Sie mit der Methode IndexOf<\/b>, die als Parameter die zu suchende Teilzeichenkette erwartet:<\/p>\nString zeichenfolge;\r\nzeichenfolge = \"Beispieltext\";\r\nint position = zeichenfolge.IndexOf(\"spiel\");\r\nConsole.WriteLine(\"Position von ''spiel'': {0}\", position);\r\n\/\/Ausgabe:\r\n\/\/3<\/pre>\nDie Zeichenfolge spiel <\/b>beginnt im Beispieltext mit dem vierten Zeichen, was dem Indexwert 3 <\/b>(nullbasiert) entspricht.<\/p>\n
Die VBA-Funktion InStrRev <\/b>bilden Sie unter C# mit der Methode LastIndexOf <\/b>ab. Diese sucht das erste Auftreten einer Zeichenfolge von hinten:<\/p>\nzeichenfolge = \"blablabla\";\r\nposition = zeichenfolge.LastIndexOf(\"bla\");\r\nConsole.WriteLine(\"Position: {0}\", position);<\/pre>\nZeichenfolge nicht gefunden<\/h2>\n
Findet IndexOf <\/b>keine passende Teilzeichenkette, liefert es den Wert -1 <\/b>zurück:<\/p>\nzeichenfolge = \"blablabla\";\r\nposition = zeichenfolge.IndexOf(\"bla\");\r\nwhile (position != -1) {\r\n Console.WriteLine(\"Position: {0}\", position);\r\n position = zeichenfolge.IndexOf(\"bla\", position + 1);\r\n}\r\n\/\/Ausgabe:\r\n\/\/Position: -1<\/pre>\nAlle Auftreten einer Zeichenfolge finden<\/h2>\n
Unter VBA haben Sie hier eine Do While<\/b>-Schleife genutzt, die so lange lief, bis der Wert für die gefundene Position den Wert 0 <\/b>angenommen hat.<\/p>\n
Hierzu ist anzumerken, dass InStr <\/b>1-basiert ist:<\/p>\nDim <\/span>intPosition As Integer<\/span>\r\nintPosition = InStr<\/span>(1, \"blablabla\", \"bla\")\r\nDo While<\/span> Not<\/span> intPosition = 0\r\n Debug.Print<\/span> intPosition\r\n intPosition = InStr<\/span>(intPosition + 1, \"blablabla\", \"bla\")\r\nLoop<\/span><\/pre>\nUnter C# hilft eine while<\/b>-Schleife weiter sowie eine Überladung der Methode IndexOf <\/b>– nämlich diejenige, die als zweiten Parameter die Startposition für die Suche erwartet:<\/p>\nzeichenfolge = \"blablabla\";\r\nposition = zeichenfolge.IndexOf(\"bla\");\r\nwhile (position != -1) {\r\n Console.WriteLine(\"Position: {0}\", position);\r\n position = zeichenfolge.IndexOf(\"bla\", position + 1);\r\n}\r\n\/\/Ausgabe:\r\n\/\/0\r\n\/\/3\r\n\/\/6<\/pre>\nHier ist zu beachten, dass IndexOf <\/b>– wie oben beschrieben – den Wert -1 <\/b>zurückliefert, wenn kein weiteres Auftreten mehr gefunden wird. Die Schleife verwendet dementsprechend den Ausdruck position != -1 <\/b>als Kriterium für die Fortsetzung.<\/p>\nZeichenfolgen vergleichen<\/h2>\n
Zum Vergleichen zweier Zeichenfolgen liefert C# gleich mehrere Möglichkeiten, die wir uns nun ansehen.<\/p>\n
Die erste Variante ist die Methode Equals <\/b>des string<\/b>-Objekts. Diese verwenden Sie als Methode des ersten zu vergleichenden string<\/b>-Objekts und geben das zweite string<\/b>-Objekt als Parameter an:<\/p>\nstring str1 = \"André\";\r\nstring str2 = \"André\";\r\nConsole.WriteLine(\"{0} Equals {1}: {2}\", str1.ToString(), \r\n str2.ToString(), str1.Equals(str2));\r\n\/\/Ausgabe: \r\n\/\/André Equals André: True<\/span><\/pre>\nDiese Methode vergleicht tatsächlich die in den beiden Variablen gespeicherten Objekte. Aber wie können diese gleich sein – wir haben doch unabhängig voneinander zwei string<\/b>-Objekte angelegt und gefüllt Der Grund ist: Die Strings werden intern gespeichert, aber nur jeweils einmal. Haben Sie also bereits eine string<\/b>-Variable mit dem Wert André <\/b>gefüllt und legen eine weitere Variable mit diesem Wert an, dann verweisen beide string<\/b>-Variablen auf das gleiche string<\/b>-Objekt.<\/p>\n
Anders funktioniert die Vergleichsmethode Compare<\/b>. Diese ist eine Methode der String<\/b>-Klasse und erwartet die beiden zu vergleichenden string<\/b>-Variablen als Parameter. Sie wird beispielsweise so aufgerufen:<\/p>\nConsole.WriteLine(String.Compare(str1, str2);<\/pre>\nMöchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t