C# 21 Tagen eBook

Visual C# 2008 in 21 Tagen

Visual C# 2008Schritt fr Schritt zum ProfiDIRK LOUIS SHINJA STRASSER

Bibliografische Information Der Deutschen Bibliothek Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet ber abrufbar. Die Informationen in diesem Produkt werden ohne Rcksicht auf einen eventuellen Patentschutz verffentlicht. Warennamen werden ohne Gewhrleistung der freien Verwendbarkeit benutzt. Bei der Zusammenstellung von Texten und Abbildungen wurde mit grter Sorgfalt vorgegangen. Trotzdem knnen Fehler nicht vollstndig ausgeschlossen werden. Verlag, Herausgeber und Autoren knnen fr fehlerhafte Angaben und deren Folgen weder eine juristische Verantwortung noch irgendeine Haftung bernehmen. Fr Verbesserungsvorschlge und Hinweise auf Fehler sind Verlag und Herausgeber dankbar.

Alle Rechte vorbehalten, auch die der fotomechanischen Wiedergabe und der Speicherung in elektronischen Medien. Die gewerbliche Nutzung der in diesem Produkt gezeigten Modelle und Arbeiten ist nicht zulssig. Fast alle Hardware- und Softwarebezeichnungen und weitere Stichworte und sonstige Angaben, die in diesem Buch verwendet werden, sind als eingetragene Marken geschtzt. Da es nicht mglich ist, in allen Fllen zeitnah zu ermitteln, ob ein Markenschutz besteht, wird das -Symbol in diesem Buch nicht verwendet. Umwelthinweis: Dieses Buch wurde auf chlorfrei gebleichtem Papier gedruckt. Um Rohstoffe zu sparen, wurde auf Folienverpackung verzichtet.

10 9 8 7 6 5 4 3 2 1 10 09 08

ISBN 978-3-8272-4325-6

2008 by Markt+Technik Verlag, ein Imprint der Pearson Education Deutschland GmbH, Martin-Kollar-Strae 1012, D81829 Mnchen/Germany Alle Rechte vorbehalten Lektorat: Brigitte Bauer-Schiewek, [email protected] Herstellung: Philipp Burkart, [email protected] Korrektur: Martina Gradias Satz: Reemers Publishing Services GmbH, Krefeld, (www.reemers.de) Druck und Verarbeitung: Bercker, Kevelaer Printed in Germany

InhaltsverzeichnisWochenvorschau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tag 1 Erste Schritte in C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.1 Warum C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2 .NET Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2.1 Was versteht man unter dem .NET Framework? . 1.2.2 Common Language Runtime CLR . . . . . . . . . . 1.2.3 Intermediate Language . . . . . . . . . . . . . . . . . . . . . 1.2.4 JIT-Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2.5 Die Ausfhrung Execution . . . . . . . . . . . . . . . . 1.3 Eine Klasse fr sich. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.4 Hallo .NET Vom Quelltext zum Programm. . . . . . . . . . 1.5 Hallo .NET der Quelltext . . . . . . . . . . . . . . . . . . . . . . . . 1.6 Hallo .NET Die Zweite . . . . . . . . . . . . . . . . . . . . . . . . . . 1.7 Hallo .NET Gro- oder Kleinschreibung . . . . . . . . . . . . 1.8 Hallo .NET Die Argumente . . . . . . . . . . . . . . . . . . . . . . 1.9 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.10 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.11 Workshop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.11.1 Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.11.2 bungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Visual C#-Umgebung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1 Die Entwicklungsumgebung . . . . . . . . . . . . . . . . . . . . . . . 2.2 Programmerstellung in Visual C# . . . . . . . . . . . . . . . . . . . 2.2.1 Erstellung der Beispielprogramme . . . . . . . . . . . . 2.3 Die Projektverwaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3.1 Vom Nutzen der Projektverwaltung . . . . . . . . . . . 2.3.2 Wie untersttzt Visual C# die Arbeit mit Projekten? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3.3 Projektmappen. . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3.4 Projekte speichern, schlieen und ffnen. . . . . . . 19 21 22 23 23 25 27 28 30 31 33 37 41 44 46 48 48 49 49 50 51 53 54 60 60 61 61 63 65

Tag 2

5

Inhaltsverzeichnis

2.4

2.5

2.6

2.7 2.8 2.9

Der Editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4.1 Dateien laden . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4.2 Eingabehilfen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4.3 Syntax-Hervorhebung und -kontrolle . . . . . . . . . . 2.4.4 Automatischer Einzug . . . . . . . . . . . . . . . . . . . . . . 2.4.5 Anweisungsvervollstndigung . . . . . . . . . . . . . . . . 2.4.6 Quickinfo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.5.1 Compileraufrufe . . . . . . . . . . . . . . . . . . . . . . . . . . 2.5.2 Das Ausgabefenster . . . . . . . . . . . . . . . . . . . . . . . . 2.5.3 Die Projekteinstellungen. . . . . . . . . . . . . . . . . . . . 2.5.4 Die Arbeit mit Projektkonfigurationen . . . . . . . . . Weitere Tools. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.6.1 Die Klassenansicht . . . . . . . . . . . . . . . . . . . . . . . . 2.6.2 Der Windows Forms-Designer . . . . . . . . . . . . . . . 2.6.3 Der Debugger . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.9.1 Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.9.2 bungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

66 66 66 67 67 67 69 70 70 71 72 73 74 74 75 76 76 77 77 77 78

Tag 3

Variablen und Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 3.1 Was ist eine Variable? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 3.1.1 Der Variablenname die Qual der Wahl . . . . . . 82 3.1.2 Variablendeklaration . . . . . . . . . . . . . . . . . . . . . . . 84 3.2 Schlsselwrter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 3.3 Elementare Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 3.3.1 Der integer-Typ . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 3.3.2 Der short-Typ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 3.3.3 Der long-Typ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 3.3.4 Der byte-Typ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 3.3.5 Der character-Typ . . . . . . . . . . . . . . . . . . . . . . . . . 95 3.3.6 Der float-Typ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 3.3.7 Der double-Typ . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 3.3.8 Der decimal-Typ . . . . . . . . . . . . . . . . . . . . . . . . . . 99 3.3.9 Der boolean-Typ . . . . . . . . . . . . . . . . . . . . . . . . . . 102 3.3.10 Ist das der richtige Typ?. . . . . . . . . . . . . . . . . . . . . 102 3.4 Implizite Konvertierungen . . . . . . . . . . . . . . . . . . . . . . . . . 103

6

Inhaltsverzeichnis

3.5

3.6

3.7 3.8 3.9

3.10

3.11 3.12 3.13

Typumwandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.5.1 Fehler bei der expliziten Konvertierung . . . . . . . . 3.5.2 Vermeiden von Konvertierungsfehlern. . . . . . . . . Konstanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.6.1 Literale Konstanten . . . . . . . . . . . . . . . . . . . . . . . . 3.6.2 Symbolische Konstanten . . . . . . . . . . . . . . . . . . . . Aufzhlungstyp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Escape-Sequenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.9.1 Whitespaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.9.2 Leeranweisungen. . . . . . . . . . . . . . . . . . . . . . . . . . 3.9.3 Verbundanweisung und Blcke . . . . . . . . . . . . . . 3.9.4 Ausdrcke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.10.1 Zuweisungsoperator. . . . . . . . . . . . . . . . . . . . . . . . 3.10.2 Mathematische Operatoren . . . . . . . . . . . . . . . . . 3.10.3 Modulo, der Restwertoperator. . . . . . . . . . . . . . . . 3.10.4 Inkrement- und Dekrement-Operatoren. . . . . . . . 3.10.5 Zusammengesetzte Operatoren . . . . . . . . . . . . . . 3.10.6 Rangfolge und Klammern . . . . . . . . . . . . . . . . . . . 3.10.7 Vergleichsoperatoren. . . . . . . . . . . . . . . . . . . . . . . 3.10.8 Logische Operatoren . . . . . . . . . . . . . . . . . . . . . . . 3.10.9 Bedingungsoperator. . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.13.1 Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.13.2 bungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

104 105 107 108 108 111 112 114 116 116 118 119 120 121 122 122 126 127 130 132 136 145 149 150 151 152 153 154 155 156 159 161 161 162 163 164

Tag 4

Ein-/Ausgabe und Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.1 Strings und die Ein-/Ausgabe . . . . . . . . . . . . . . . . . . . . . . . 4.2 Formatieren mit Escape-Sequenzen. . . . . . . . . . . . . . . . . . 4.3 Zahlen formatieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3.1 Standardformatierung von Zahlen . . . . . . . . . . . . 4.3.2 Formatieren von Gleitkommazahlen . . . . . . . . . . 4.3.3 Whrungsformat . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3.4 Spezielle Formatierungen . . . . . . . . . . . . . . . . . . .

7

Inhaltsverzeichnis

4.4

4.5

4.6

4.7 4.8 4.9

Benutzerdefinierte Formatierung . . . . . . . . . . . . . . . . . . . . 4.4.1 0-Formatierung . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.4.2 Kreuz-Formatierung . . . . . . . . . . . . . . . . . . . . . . . 4.4.3 Formatieren von Gruppen . . . . . . . . . . . . . . . . . . 4.4.4 Prozent-Formatierung . . . . . . . . . . . . . . . . . . . . . . 4.4.5 Literale Formatierung . . . . . . . . . . . . . . . . . . . . . . 4.4.6 Fall-Formatierung . . . . . . . . . . . . . . . . . . . . . . . . . Datums- und Zeitwerte formatieren . . . . . . . . . . . . . . . . . . 4.5.1 Datumsformatierung . . . . . . . . . . . . . . . . . . . . . . . 4.5.2 Zeitformatierung . . . . . . . . . . . . . . . . . . . . . . . . . . 4.5.3 Datums- und Zeitformatierung . . . . . . . . . . . . . . . 4.5.4 Ausgabe von Aufzhlungen . . . . . . . . . . . . . . . . . . Methoden der Klasse String . . . . . . . . . . . . . . . . . . . . . . . . 4.6.1 Vergleichen von Strings . . . . . . . . . . . . . . . . . . . . 4.6.2 Einfgen, Lschen und Ersetzen . . . . . . . . . . . . . 4.6.3 Vorbereiten von Strings . . . . . . . . . . . . . . . . . . . . . 4.6.4 Lnge eines Strings . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.9.1 Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.9.2 bungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

165 166 166 167 169 169 170 171 172 174 174 176 178 178 182 183 185 185 186 186 186 187 189 190 190 192 195 199 200 201 204 206 210 210 211 212 213

Tag 5

Ablaufsteuerung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1 Verzweigungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1.1 if-Anweisung Review. . . . . . . . . . . . . . . . . . . . . . 5.1.2 if-else-Statement Review. . . . . . . . . . . . . . . . . . . 5.1.3 switch-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . 5.2 Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.2.1 Der Urvater der Schleifen goto Anweisung . . . . 5.2.2 while-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.2.3 do-while-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . 5.2.4 for-Schleife. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.2.5 foreach-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3 Sprunganweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3.1 break-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3.2 continue-Anweisung . . . . . . . . . . . . . . . . . . . . . . . 5.4 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

8

Inhaltsverzeichnis

5.5 5.6

Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.6.1 Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.6.2 bungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

214 214 214 215 217 218 221 221 223 227 232 232 234 235 238 242 246 247 247 247 248 251 252 253 254 255 255 258 258 259 261 261 263 267 267 267 271

Tag 6

Methoden, Parameter und Gltigkeit von Variablen . . . . . . . . 6.1 Definition und Aufruf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.2 Parameter einer Methode . . . . . . . . . . . . . . . . . . . . . . . . . . 6.2.1 Parameter definieren . . . . . . . . . . . . . . . . . . . . . . . 6.2.2 Arten von Parametern . . . . . . . . . . . . . . . . . . . . . . 6.2.3 Variable Parameterlisten . . . . . . . . . . . . . . . . . . . . 6.3 Gltigkeitsbereich von Variablen . . . . . . . . . . . . . . . . . . . . 6.3.1 Lokale Datenobjekte . . . . . . . . . . . . . . . . . . . . . . . 6.3.2 Globale Datenobjekte . . . . . . . . . . . . . . . . . . . . . . 6.3.3 Global, lokal hinter den Kulissen. . . . . . . . . . . . 6.4 Rekursive Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.5 berladen von statischen Methoden . . . . . . . . . . . . . . . . . 6.6 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.7 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.8 Workshop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.8.1 Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.8.2 bungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.1 Datenverwaltung mit Arrays . . . . . . . . . . . . . . . . . . . . . . . . 7.1.1 Arrays definieren . . . . . . . . . . . . . . . . . . . . . . . . . . 7.1.2 Auf Array-Elemente zugreifen. . . . . . . . . . . . . . . . 7.1.3 Arrays initialisieren . . . . . . . . . . . . . . . . . . . . . . . . 7.1.4 Arrays in Schleifen durchlaufen . . . . . . . . . . . . . . 7.2 Array-Programmierung leicht gemacht . . . . . . . . . . . . . . . 7.2.1 Arrays von Objekten . . . . . . . . . . . . . . . . . . . . . . . 7.2.2 Array-Lnge bestimmen. . . . . . . . . . . . . . . . . . . . . 7.2.3 Arrayteile lschen . . . . . . . . . . . . . . . . . . . . . . . . . 7.2.4 Arrays kopieren . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2.5 Arrays sortieren . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2.6 Arrays als Parameter. . . . . . . . . . . . . . . . . . . . . . . . 7.3 Zusammengesetzte Arrays . . . . . . . . . . . . . . . . . . . . . . . . . 7.3.1 Mehrdimensionale Arrays . . . . . . . . . . . . . . . . . . . 7.3.2 Arrays aus Arrays . . . . . . . . . . . . . . . . . . . . . . . . . .

Tag 7

9

Inhaltsverzeichnis

Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.6.1 Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.6.2 bungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Woche 1 im Rckblick. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tag 8 Grundkurs OOP I. Die Klasse . . . . . . . . . . . . . . . . . . . . . . . . . 8.1 Klassen und objektorientierte Programmierung (OOP) . . 8.1.1 Der Grundgedanke der objektorientierten Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . 8.1.2 Objekte und Klassen . . . . . . . . . . . . . . . . . . . . . . . 8.1.3 Beispiel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.1.4 Vorteile der objektorientierten Programmierung . 8.2 Eigene Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.2.1 Klassen definieren . . . . . . . . . . . . . . . . . . . . . . . . . 8.2.2 Felder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.2.3 Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.2.4 Der Konstruktor . . . . . . . . . . . . . . . . . . . . . . . . . . 8.2.5 Zugriffsspezifizierer . . . . . . . . . . . . . . . . . . . . . . . . 8.2.6 Instanzbildung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.2.7 Mit Objekten programmieren. . . . . . . . . . . . . . . . 8.3 Wert- und Referenztypen . . . . . . . . . . . . . . . . . . . . . . . . . . 8.3.1 Was passiert bei der Instanzbildung? . . . . . . . . . . 8.3.2 Wert- und Referenztypen . . . . . . . . . . . . . . . . . . . 8.3.3 Heap und Stack . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.3.4 Warum Referenzen? . . . . . . . . . . . . . . . . . . . . . . . 8.3.5 Boxing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.4 Klassen-Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.4.1 Was ist eine gute Klasse? . . . . . . . . . . . . . . . . . 8.4.2 Nicht verzweifeln! . . . . . . . . . . . . . . . . . . . . . . . . . 8.4.3 Auswahl der Klassenelemente . . . . . . . . . . . . . . . . 8.4.4 Einsatz des Konstruktors . . . . . . . . . . . . . . . . . . . . 8.4.5 Zugriffsrechte und ffentliche Schnittstelle . . . . . 8.4.6 Klassen als Funktionensammlungen. . . . . . . . . . . 8.4.7 Klassen versus Strukturen . . . . . . . . . . . . . . . . . . .

7.4 7.5 7.6

274 275 275 276 276 276 287 289 289 293 295 299 300 301 302 303 306 307 312 313 318 318 319 321 322 323 325 325 326 327 328 329 334 334

Wochenvorschau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283

10

Inhaltsverzeichnis

8.5 8.6 8.7 8.8

Alles Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.8.1 Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.8.2 bungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

336 337 338 339 339 340 341 343 343 344 345 346 348 349 349 353 356 362 362 365 368 371 375 377 381 382 384 386 386 387 390 393 394 395 396 396

Tag 9

Grundkurs OOP II. Die einzelnen Klassenelemente . . . . . . . . . . . . . . . . . . . . . . . 9.1 Felder. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.1.1 Initialisierung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.1.2 Objektvariablen als Felder. . . . . . . . . . . . . . . . . . . 9.1.3 Konstante Felder . . . . . . . . . . . . . . . . . . . . . . . . . . 9.1.4 Statische Felder . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.1.5 Variablenterminologie. . . . . . . . . . . . . . . . . . . . . . 9.2 Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.2.1 this . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.2.2 Statische Methoden. . . . . . . . . . . . . . . . . . . . . . . . 9.3 Eigenschaften . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.4 Der Konstruktor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.4.1 Klassen ohne selbst definierten Konstruktor . . . . . 9.4.2 Der Standardkonstruktor . . . . . . . . . . . . . . . . . . . . 9.4.3 berladene Konstruktoren . . . . . . . . . . . . . . . . . . 9.5 Destruktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.6 Typdefinitionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.7 Indexer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.8 Delegaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.8.1 Delegaten einrichten. . . . . . . . . . . . . . . . . . . . . . . 9.8.2 Methoden mit Delegaten verbinden. . . . . . . . . . . 9.9 Ereignisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.9.1 Problembeschreibung . . . . . . . . . . . . . . . . . . . . . . 9.9.2 Ereignisse verffentlichen . . . . . . . . . . . . . . . . . . . 9.9.3 Ereignisse abonnieren . . . . . . . . . . . . . . . . . . . . . . 9.10 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.11 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.12 Workshop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.12.1 Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.12.2 bungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

11

Inhaltsverzeichnis

Tag 10

Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.1 Das Prinzip der Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . 10.1.1 Der grundlegende Mechanismus . . . . . . . . . . . . . 10.1.2 Der Sinn der Vererbung . . . . . . . . . . . . . . . . . . . . 10.1.3 Einige wichtige Fakten . . . . . . . . . . . . . . . . . . . . . 10.2 Wie greift man auf geerbte Elemente zu? . . . . . . . . . . . . . 10.2.1 Geerbte Elemente bilden Unterobjekte . . . . . . . . 10.2.2 Drei Zugriffsebenen . . . . . . . . . . . . . . . . . . . . . . . 10.3 Wie initialisiert man geerbte Elemente? . . . . . . . . . . . . . . 10.3.1 Konstruktor und Basisklassenkonstruktor . . . . . . . 10.3.2 Expliziter Aufruf eines Basisklassenkonstruktors. . 10.4 berladen und verdecken. . . . . . . . . . . . . . . . . . . . . . . . . . 10.4.1 berladung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.4.2 Verdeckung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.5 Vererbung kennt weder Programm- noch Sprachgrenzen 10.5.1 Ableitung von Bibliotheksklassen . . . . . . . . . . . . . 10.5.2 Ableitung von Visual Basic .NET-Klassen . . . . . . 10.6 Vererbung und objektorientiertes Design . . . . . . . . . . . . . 10.6.1 Wann ist Vererbung gerechtfertigt? . . . . . . . . . . . 10.6.2 Vererbung versus Einbettung . . . . . . . . . . . . . . . . 10.6.3 Verschachtelte Klassen . . . . . . . . . . . . . . . . . . . . . 10.6.4 Klassenhierarchien . . . . . . . . . . . . . . . . . . . . . . . . 10.6.5 Es gibt eine oberste Basisklasse: System.Object . . 10.7 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.8 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.9 Workshop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.9.1 Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.9.2 bungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Polymorphie und Schnittstellen . . . . . . . . . . . . . . . . . . . . . . . . . 11.1 Was bedeutet Polymorphie? . . . . . . . . . . . . . . . . . . . . . . . . 11.2 Polymorphie basiert auf berschreibung . . . . . . . . . . . . . . 11.2.1 Methoden berschreiben . . . . . . . . . . . . . . . . . . . 11.2.2 Statische und dynamische Bindung . . . . . . . . . . . 11.2.3 Regeln fr die berschreibung . . . . . . . . . . . . . . . 11.2.4 berladen, verdecken und berschreiben . . . . . . 11.3 Abstrakte Klassen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

399 401 401 403 404 405 406 408 415 415 419 422 422 423 430 430 438 441 441 443 444 445 446 447 448 449 449 450 453 454 458 459 461 464 465 466

Tag 11

12

Inhaltsverzeichnis

11.4 Basisklassen-Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.5 Basisklassenparameter. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.6 Typidentifizierung zur Laufzeit (RTTI) . . . . . . . . . . . . . . 11.6.1 Typidentifizierung fr Objekte . . . . . . . . . . . . . . . 11.6.2 Typidentifizierung fr Klassen . . . . . . . . . . . . . . . 11.7 Schnittstellen (Interfaces) . . . . . . . . . . . . . . . . . . . . . . . . . . 11.7.1 Was sind Schnittstellen? . . . . . . . . . . . . . . . . . . . . 11.7.2 Schnittstellen definieren . . . . . . . . . . . . . . . . . . . . 11.7.3 Schnittstellen implementieren . . . . . . . . . . . . . . . 11.7.4 Schnittstellenmethoden aufrufen . . . . . . . . . . . . . 11.7.5 Mehrere Schnittstellen implementieren . . . . . . . 11.8 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.9 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.10 Workshop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.10.1 Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.10.2 bungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tag 12 Ntzliche .NET-Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.1 Objekte kopieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.1.1 Flaches Kopieren mit MemberwiseClone() . . . . . 12.1.2 Tiefes Kopieren (und ICloneable) . . . . . . . . . . . . 12.2 Objekte vergleichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.2.1 Gleichheit feststellen . . . . . . . . . . . . . . . . . . . . . . 12.2.2 Grenvergleiche . . . . . . . . . . . . . . . . . . . . . . . . . 12.3 Objekte ausgeben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.4 Objekte mit Operatoren bearbeiten . . . . . . . . . . . . . . . . . . 12.4.1 Binre Operatoren berladen . . . . . . . . . . . . . . . . 12.4.2 Unre Operatoren berladen . . . . . . . . . . . . . . . . 12.4.3 Nicht berladbare Operatoren . . . . . . . . . . . . . . . 12.5 Datum und Uhrzeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.5.1 Datum und Uhrzeit ermitteln . . . . . . . . . . . . . . . . 12.5.2 Datums- und Zeitangaben manipulieren . . . . . . . 12.5.3 Datums- und Zeitangaben ausgeben . . . . . . . . . . 12.5.4 Zeitspannen messen . . . . . . . . . . . . . . . . . . . . . . . 12.6 Zeitgeber . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.7 Zufallszahlen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

468 471 474 477 478 480 481 484 485 487 490 494 495 496 496 496 499 500 503 508 512 512 520 523 524 525 525 528 529 529 530 531 533 534 536

13

Inhaltsverzeichnis

12.8 Die Auflistungsklassen (Container) . . . . . . . . . . . . . . . . . . 12.8.1 Historisches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.8.2 Die Auflistungen im Vergleich . . . . . . . . . . . . . . . 12.8.3 ArrayList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.8.4 List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.8.5 Dictionary . . . . . . . . . . . . . . . . . 12.8.6 Stack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.9 Streams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.10 Textdateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.10.1 In Textdateien schreiben. . . . . . . . . . . . . . . . . . . . 12.10.2 Aus Textdateien lesen . . . . . . . . . . . . . . . . . . . . . . 12.11 Binrdateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.11.1 In Binrdateien schreiben . . . . . . . . . . . . . . . . . . . 12.11.2 Aus Binrdateien lesen . . . . . . . . . . . . . . . . . . . . . 12.12 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.13 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.14 Workshop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.14.1 Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.14.2 bungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tag 13 GUI-Programmierung: Fenster und Steuerelemente . . . . . . . . 13.1 Die erste GUI-Anwendung . . . . . . . . . . . . . . . . . . . . . . . . . 13.1.1 Ein einfaches Codegerst . . . . . . . . . . . . . . . . . . . 13.1.2 Kompilierung von GUI-Anwendungen . . . . . . . . 13.1.3 Windows, Fenster und Hauptfenster . . . . . . . . . . 13.2 Das Fenster konfigurieren. . . . . . . . . . . . . . . . . . . . . . . . . . 13.2.1 Gre und Position . . . . . . . . . . . . . . . . . . . . . . . . 13.2.2 Titelleiste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.2.3 Rahmen und Funktionalitt . . . . . . . . . . . . . . . . . 13.2.4 Farben und Hintergrundbilder . . . . . . . . . . . . . . . 13.3 Auf Ereignisse reagieren . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.3.1 Die Message Loop . . . . . . . . . . . . . . . . . . . . . . . . . 13.3.2 Meldungen und Ereignisbehandlung. . . . . . . . . . 13.3.3 Mausklicke im Fenster abfangen . . . . . . . . . . . . . 13.4 Das Fenster mit Steuerelementen bestcken . . . . . . . . . . . 13.4.1 Programmieren mit Steuerelementen . . . . . . . . . 13.4.2 Textfelder. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

538 539 539 541 543 546 547 549 550 551 554 558 563 565 567 567 569 569 570 573 574 575 577 578 579 580 580 581 582 586 586 587 588 592 592 593

14

Inhaltsverzeichnis

13.5

13.6 13.7 13.8

13.4.3 Schaltflchen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4.4 Weitere Steuerelemente . . . . . . . . . . . . . . . . . . . . GUI-Anwendungen mit Visual C#. . . . . . . . . . . . . . . . . . . 13.5.1 Projekte fr GUI-Anwendungen . . . . . . . . . . . . . . 13.5.2 Das Codegerst . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.5.3 Oberflchenerstellung im Windows Forms-Designer . . . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.8.1 Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.8.2 bungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

596 599 602 603 603 607 612 612 613 613 613 615 616 616 618 621 623 623 628 629 629 630 630 634 637 640 640 641 641 642 642

Tag 14

GUI-Programmierung: Mens, Dialoge, Grafik . . . . . . . . . . . . 14.1 Grafik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.1.1 Grafik-Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . 14.1.2 Text ausgeben . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.1.3 Zeichnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.2 Mens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.2.1 Eigene Mens aufbauen . . . . . . . . . . . . . . . . . . . . 14.2.2 Menbefehle konfigurieren . . . . . . . . . . . . . . . . . 14.2.3 Beenden-Befehle . . . . . . . . . . . . . . . . . . . . . . . . . . 14.2.4 Mens mit Visual C# . . . . . . . . . . . . . . . . . . . . . . 14.3 Dialogfenster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.3.1 Dialogfenster einrichten . . . . . . . . . . . . . . . . . . . . 14.3.2 Dialogfenster anzeigen . . . . . . . . . . . . . . . . . . . . . 14.3.3 Vordefinierte Dialoge . . . . . . . . . . . . . . . . . . . . . . 14.4 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.5 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.6 Workshop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.6.1 Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.6.2 bungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Woche 2 im Rckblick. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Wochenvorschau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657 Tag 15 Ausnahmebehandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 659 15.1 Einfache Fehlerbehandlung . . . . . . . . . . . . . . . . . . . . . . . . 660 15.2 Ausnahmen abfangen mit try und catch. . . . . . . . . . . . . . . 662

15

Inhaltsverzeichnis

15.3 Mit Fehlerinformationen arbeiten . . . . . . . . . . . . . . . . . . . 15.4 1 catch, 2 catch, ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.4.1 try-catch-finally . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.4.2 Lokal, Global try-catch-finally . . . . . . . . . . . . . . 15.5 Eigene Ausnahmen auslsen . . . . . . . . . . . . . . . . . . . . . . . 15.5.1 Eigene Exception-Klasse definieren . . . . . . . . . . . Tag 16 Attribute . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.1 Einfhrung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.2 Benutzerdefinierte Attribute verwenden. . . . . . . . . . . . . . . 16.3 Benutzerdefinierte Attribute erstellen. . . . . . . . . . . . . . . . . 16.4 Benutzerdefinierte Attribute anwenden . . . . . . . . . . . . . . . 16.5 Benutzerdefinierte Attribute ausgeben . . . . . . . . . . . . . . . . Von der Klasse zur Komponente. . . . . . . . . . . . . . . . . . . . . . . . . 17.1 Eine einfache Komponente erstellen . . . . . . . . . . . . . . . . . 17.1.1 Erste Schritte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17.1.2 Eine Methode einbinden . . . . . . . . . . . . . . . . . . . 17.1.3 Eine Eigenschaft einbinden . . . . . . . . . . . . . . . . . 17.1.4 Weiteren Code hinzufgen. . . . . . . . . . . . . . . . . . 17.1.5 Erstellen der Komponente . . . . . . . . . . . . . . . . . . 17.2 Der Client Das Testprogramm . . . . . . . . . . . . . . . . . . . . 17.2.1 Das Konsolenprogramm . . . . . . . . . . . . . . . . . . . . 17.2.2 Referenzieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17.2.3 Der Client-Code . . . . . . . . . . . . . . . . . . . . . . . . . . Einfhrung in die Thread-Programmierung . . . . . . . . . . . . . . . 18.1 Der Prozess . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18.2 Multitasking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18.2.1 Multithreading. . . . . . . . . . . . . . . . . . . . . . . . . . . . 18.2.2 Singlethread und Multithread. . . . . . . . . . . . . . . . 18.3 Thread-Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . 18.3.1 Multithreading mit Thread.Sleep . . . . . . . . . . . . . XML Web Services in .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19.1 Vorbereitungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19.1.1 Luft der IIS? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19.1.2 Laufen ASP.NET-Anwendungen? . . . . . . . . . . . . 19.2 XML veni, vidi, vici . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

664 666 668 671 674 676 681 682 684 685 687 688 691 692 692 695 697 699 702 702 703 705 706 711 712 713 713 713 714 716 721 722 722 724 727

Tag 17

Tag 18

Tag 19

16

Inhaltsverzeichnis

19.3 SOAP Simple Object Access Protocol. . . . . . . . . . . . . . . 19.4 Hello Webservice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19.4.1 Erstellen eines Webservice . . . . . . . . . . . . . . . . . . 19.4.2 Implementieren eines Webservice . . . . . . . . . . . . 19.4.3 Verwenden eines Webservice . . . . . . . . . . . . . . . . Tag 20 Testen und Debuggen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20.1 Grundlagen des Debuggens . . . . . . . . . . . . . . . . . . . . . . . . 20.2 Debug, Trace und die defensive Programmierung . . . . . . 20.2.1 Bedingte Methoden. . . . . . . . . . . . . . . . . . . . . . . . 20.2.2 Assert-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . . 20.3 Direktiven und die defensive Programmierung . . . . . . . . . 20.3.1 Codesteuerung mit #define, #undef und #if, #endif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20.3.2 #warning- und #line-Direktive und der Vorteil von Direktiven . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20.3.3 #region #endregion. . . . . . . . . . . . . . . . . . . . . . . 20.4 Der Visual C#-Debugger . . . . . . . . . . . . . . . . . . . . . . . . . . 20.4.1 Vorbereitung des Programms fr das Debuggen . 20.4.2 Programm in Debugger laden und starten . . . . . . 20.4.3 Programm anhalten . . . . . . . . . . . . . . . . . . . . . . . 20.4.4 Programm schrittweise ausfhren . . . . . . . . . . . . . 20.4.5 Die Debug-Fenster . . . . . . . . . . . . . . . . . . . . . . . . 20.4.6 Weitere Debug-Mglichkeiten . . . . . . . . . . . . . . . Vermischtes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.1 Ausfhrung der Beispielprogramme. . . . . . . . . . . . . . . . . . 21.1.1 Programmerstellung mit dem csc-Compiler. . . . . 21.1.2 Programmerstellung mit Visual C# . . . . . . . . . . . 21.2 Programme aus mehreren Dateien . . . . . . . . . . . . . . . . . . 21.2.1 Wie verteilt man Code auf mehrere Dateien? . . . 21.2.2 Wie kompiliert man Programme aus mehreren Dateien?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.3 Namensrume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.3.1 bersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.4 CSC-Compileroptionen . . . . . . . . . . . . . . . . . . . . . . . . . . 21.4.1 Syntax und Regeln des C#-Compilers in der Befehlszeile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

730 731 732 736 740 745 746 750 751 753 756 756 760 765 766 767 768 768 769 770 772 775 776 776 779 781 781 782 782 782 789 790

Tag 21

17

Inhaltsverzeichnis

21.4.2 Compileroptionen nach Kategorie sortiert . . . . . . 21.4.3 Compilerfehler CS0001 bis CS9999 . . . . . . . . . . 21.5 Lsungen zu den bungen . . . . . . . . . . . . . . . . . . . . . . . . 21.5.1 Tag 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.5.2 Tag 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.5.3 Tag 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.5.4 Tag 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.5.5 Tag 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.5.6 Tag 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.5.7 Tag 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.5.8 Tag 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.5.9 Tag 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.5.10 Tag 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.5.11 Tag 11 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.5.12 Tag 12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.5.13 Tag 13 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.5.14 Tag 14 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.6 Unicode-Zeichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.7 Glossar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

790 794 794 794 795 797 801 803 805 808 812 816 822 828 834 844 850 854 857

Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 867

18

Tag 1 Tag 2 Tag 3 Tag 4 Tag 5 Tag 6 Tag 7

Erste Schritte in C# Die Visual C#-Umgebung Variablen und Operatoren Ein-/Ausgabe und Strings Ablaufsteuerung Methoden, Parameter und Gltigkeit von Variablen Arrays

21 51 79 155 189 217 251

W O C H E


Grundkurs OOP I. Die Klasse Grundkurs OOP II. Die einzelnen Klassenelemente Vererbung Polymorphie und Schnittstellen Ntzliche .NET-Klassen GUI-Programmierung: Fenster und Steuerelemente GUI-Programmierung: Mens, Dialoge, Grafik

287 341 399 453 499 573 615

W O C H E


Ausnahmebehandlung Attribute Von der Klasse zur Komponente Einfhrung in die Thread-Programmierung XML Web Services in .NET Testen und Debuggen Vermischtes

659 681 691 711 721 745 775

W O C H E

Wochenvorschau

Vorschau auf die erste WocheWillkommen zu C# in 21 Tagen! Die erste Woche vermittelt Ihnen ein solides Basiswissen ber C# und das .NET Framework. Sie lernen, was C# auszeichnet und welche Philosophie und Konzepte sich dahinter verbergen. Neben der Vermittlung der Programmiersprache selbst wird auch auf die Umgebung eingegangen, unter der C# luft. Der erste Tag beschftigt sich mit dieser Umgebung, dem .NET Framework. Sie lernen, wie Sie Programme in dieser Umgebung kompilieren und ausfhren, wie der C#-Compiler eingesetzt wird und welche Vorteile die Intermediate Language und die Common Language Runtime mit sich bringen. Der zweite Tag stellt die Entwicklungsumgebung Visual C# vor. Sie lernen den Umgang mit dem Projektmappen-Explorer und wie Programme mit Visual C# entwickelt und kompiliert werden. Am dritten Tag dreht sich alles um die einzelnen Datentypen und Schlsselwrter. Sie erfahren im Detail, was Variablen und Konstanten sind, und lernen den internen Aufbau kennen. Sie erfahren etwas ber die verschiedenen Schreibkonventionen und werden angeregt, eine eigene Konvention zu entwickeln, um die Namensgebung von Bezeichnern sinnvoll zu gestalten. Zum Schluss des Tages lernen Sie, mit Operatoren umzugehen und diese in Ihre Programmlogik einzubauen. Der vierte Tag widmet sich dem Umgang mit Zeichenketten bzw. Strings und stellt Besonderheiten und Fallen der String-Programmierung vor. Sie erfahren, wie die Ausgabe durch Verwendung bestimmter Formate wie Datum, Whrung usw. beeinflusst werden kann. Der fnfte Tag hat die Ablaufsteuerung zum Thema. Hier lernen Sie, wie man den Programmfluss steuert und Anweisungen mehrfach ausfhrt. Der sechste Tag stellt die Programmierung mit Methoden und Parametern vor. Hier lernen Sie, welche Arten von Parametern es gibt und wie sie in der Praxis richtig eingesetzt werden. Der letzte Tag der Woche widmet sich den Arrays, ber die man Datenstrukturen abbilden kann, und zeigt, wie man Datenelemente darin lscht, sortiert und ndert.

20

Erste Schritte in C#

1


Ein Programm zu schreiben, ohne die Umgebung zu kennen, in der es ausgefhrt werden soll, ist wie Autofahren in einer Grostadt ohne Stadtplan. Man erreicht sein Ziel nur ber Umwege und durch stndiges Anhalten, um nach dem Weg fragen zu knnen.

Heute lernen Sie

Ihre Umgebung kennen .NET Framework, wie Programme ablaufen CLR, IL, JIT, was im Wesentlichen eine Klasse darstellt, was Sie beim Programmieren beachten mssen, wie Sie den C#-Compiler verwenden, wie Sie Fehlermeldungen interpretieren.

1.1

Warum C#

C# ist grundstzlich keine neue Programmiersprache, zumindest was die Syntax betrifft. C# ist mehr oder weniger aus der Syntax der C++-Sprachfamilie hervorgegangen. Das Konzept von C# ist aber von Grund auf neu entwickelt worden und fgt sich hundertprozentig in die neue .NET-Technologie ein. C++ ist eine uerst komplexe Sprache und entsprechend schwer zu erlernen. C# dagegen ist eine leicht verstndliche Sprache. Da die Sprache neu entwickelt wurde, enthlt sie im Unterschied zu C++ keine strenden Relikte aus Vorgngerversionen. Es existieren ber 20 Programmiersprachen fr die .NET-Technologie. Warum aber nimmt C# eine spezielle Rolle in der neuen Technologie ein? C# ist die primre Sprache der .NET-Technologie und wurde speziell fr den Einsatz von .NET entwickelt. Viele Teile des .NET Frameworks sind in C# geschrieben. Auerdem untersttzt C# vollstndig die komponentenbasierte Programmierung. Komponenten sind Bausteine, die einmal entwickelt immer wieder verwendet werden knnen, auch ohne dass Kenntnisse hinsichtlich der internen Arbeitsweise

22

.NET Framework

der Komponenten vorhanden sein mssen. Komponenten knnen projekt- und programmiersprachenunabhngig eingesetzt werden, was nicht zuletzt Entwicklungszeit spart. C# vereint die hohe Performance von C++ und die Einfachheit von Visual Basic.

1.2

.NET Framework

Um mit C# effektiv programmieren zu knnen, bentigt man ein wenig theoretisches Hintergrundwissen, was das so genannte .NET Framework angeht. Deshalb ist das .NET Framework ein wesentlicher Bestandteil dieses Buches. Bevor wir uns mit dem .NET Framework genauer beschftigen, sollten Sie wissen, dass dieses ein wesentlicher Bestandteil der .NET-Technologie ist. .NET besteht grundstzlich aus drei Teilen:

.NET Framework Webservices .NET Enterprise Server

1.2.1 Was versteht man unter dem .NET Framework?Primr ist darunter eine konzeptionelle Plattform zu sehen, die es ermglicht, Programme und Dienste zu schreiben. Auf dieser Grundlage wurden bisher unterschiedliche Frameworks fr verschiedene Plattformtechnologien bereitgestellt. C# und auch alle anderen Programmiersprachen, die fr .NET entwickelt wurden und werden, bentigen das .NET Framework als Laufzeitumgebung (englisch runtime environment). Genauer gesagt besteht die Laufzeitumgebung des .NET Frameworks aus der Common Language Runtime, kurz CLR genannt. Wie der Name Common Language Runtime bereits andeutet, handelt es sich um eine programmiersprachenbergreifende Laufzeitumgebung. Die Aufgabe einer Laufzeitumgebung liegt im Wesentlichen darin, den mit der jeweiligen Programmiersprache entwickelten Code auszufhren. Frher musste jedoch in der Regel fr jede Programmiersprache zum Teil auch fr jede Version eine separate Runtime-Bibliothek (Laufzeitbibliothek) mitgeliefert werden, um die entsprechenden Programme ausfhren zu knnen, z. B. bei C++ die Datei

23


MSVCRT.DLL und bei Visual Basic 6 die Datei MSVBVM60.DLL. Die Konzepte der mitgelieferten Laufzeitumgebungen waren und sind auch heute noch grundverschieden. Aus der sprachenbergreifenden Untersttzung ergeben sich wesentliche Vorteile des .NET Frameworks:

Es wird nur genau ein Framework bentigt. Es knnen verschiedene (und sehr unterschiedliche) Programmiersprachen eingesetzt werden, je nach Kenntnisstand und persnlicher Vorliebe. Es gibt exakt eine Laufzeitumgebung fr alle Programmiersprachen. die sprachbergreifende Integration die sprachbergreifende Ausnahmebehandlung, engl. Exception Handling (Mit Ausnahmebehandlung ist die Festlegung gemeint, wie ein Programm reagieren soll, wenn Ereignisse eintreten, die im Normalfall nicht erwartet werden. Dazu gehren z. B. Fehler.) eine verbesserte Sicherheit (Die Sicherheit kann bis zur Methodenebene kontrolliert werden.) eine vereinfachte Versionierung (Es knnen mehrere Versionen nebeneinander existieren.) Da das .NET Framework eine sprachbergreifende Laufzeitumgebung bereitstellt, ist die Interaktion und optimale Zusammenarbeit von Komponenten verschiedener Programmiersprachen sichergestellt.

Aus diesen Vorteilen lassen sich weitere ableiten:

Sie wissen nun, dass das .NET Framework ein Bestandteil der .NET-Technologie darstellt und welche Aufgaben es zu erfllen hat. Das .NET Framework besteht wiederum aus drei wesentlichen Bestandteilen:

Common Language Runtime die sprachbergreifende Laufzeitumgebung Klassenbibliotheken, engl. class libraries (Zu Klassen und Klassenbibliotheken erfahren Sie spter mehr.) ASP.NET serverseitige Anwendungen fr das World Wide Web

Wir beschftigen uns in diesem Buch ausfhrlich mit diesen drei Bestandteilen. Die Common Language Runtime und die Class Libraries (Klassenbibliotheken) werden uns im gesamten Buch immer wieder begegnen ebenso wie ASP.NET im Zusammenhang mit den Webservices. Die beiden Bestandteile Common Language Runtime und Class Libraries des .NET Frameworks bezeichnet man auch als Base Framework.

24

.NET Framework

Abbildung 1.1: Aufbau des .NET Frameworks

Das Base Framework ist kein Entwurf des .NET Frameworks, sondern eine gedankliche Einteilung, um die Begriffserklrungen zu erleichtern. Wenn man von Base Framework spricht, so ist nicht das gesamte .NET Framework gemeint, sondern nur die beiden Bestandteile Common Language Runtime (CLR) und Class Libraries (Klassenbibliotheken).

1.2.2 Common Language Runtime CLRDie sprachbergreifende Laufzeitumgebung des .NET Frameworks bezeichnet man als Common Language Runtime, kurz CLR. Sie hat die Aufgabe, die Ausfhrung (execution) des Codes zu verwalten, und bietet zustzlich noch Dienste an, welche die Entwicklung auf und mit dem .NET Framework vereinfachen. Mit der Common Language Runtime wird dem Entwickler sehr viel Arbeit abgenommen. Eine der groen Erleichterungen liegt im vereinfachten Speichermanagement, also der Verwaltung des Arbeitsspeichers. Sie knnen sich damit als Programmierer mehr auf die eigentliche Aufgabenstellung konzentrieren und werden weniger mit Interna konfrontiert, was die Organisation des Arbeitsspeichers angeht. Zudem existieren in jeder Programmiersprache die gleichen Datentypen, was beim Einsatz verschiedener Programmiersprachen sehr ntzlich ist, da man sich nicht mehr laufend in die Eigenheiten der jeweiligen Programmiersprache hineindenken muss. (Ein Datentyp legt fest, welche Art von Daten gespeichert wird, gegebenenfalls bei numerischen Daten auch deren Wertebereich und Genauigkeit.)

25


Das Speichermanagement und viele andere Aufgaben bernimmt grtenteils oder ganz die Common Language Runtime. Diese Art der Programmierung bzw. den entwickelten Code nennt man im .NET Framework Managed Code. Als Managed Code (verwalteter Code) bezeichnet man Code, der unter der Kontrolle der Common Language Runtime steht. Er darf bestimmte Dinge nicht selbst erledigen, zum Beispiel direkt auf den Arbeitsspeicher zugreifen; darum kmmert sich die CLR, als Vermittler und bergreifende Instanz. Nur wenn Sie Managed Code einsetzen, knnen Sie von bestimmten Vorteilen profitieren, z. B. der automatischen Speicherverwaltung oder der sprachbergreifenden Integration. Die Common Language Runtime verfgt ber eine eigene Speicherverwaltung, den so genannten Garbage Collector (wrtlich etwa Mllabfuhr fr nicht mehr gltige Daten im Speicher), kurz GC. Ohne Einsatz eines Garbage Collectors muss man sich selbst um die Arbeitsspeicherverwaltung und -freigabe kmmern, was sehr aufwndig und fehlertrchtig ist und sogar zu Systemabstrzen fhren kann. Der Garbage Collector verwaltet den Speicher automatisch, d.h., er kontrolliert alle Speicheranforderungen an das System, die Ihr Programm vornimmt, und entfernt alle Daten aus dem Speicher, die nicht mehr referenziert werden, also auf die keine Verweise mehr existieren oder noch einfacher ausgedrckt die nicht mehr verwendet werden.

Abbildung 1.2: Aufbau der Common Language Runtime

26

.NET Framework

1.2.3 Intermediate LanguageStellen Sie sich einmal vor, die ganze Welt spricht eine Sprache und jeder Bewohner auf diesem Planeten wrde sie verstehen. Das ganze klingt sehr philosophisch und ist bei menschlicher Kommunikation nur schwer vorstellbar. bertragen auf das .NET Framework wurde jedoch genau so etwas geschaffen: eine bergreifende, vermittelnde Sprache, die als Intermediate Language bezeichnet wird. Eines der Konzepte der .NET-Technologie ist es, unabhngig vom Betriebssystem zu sein. Ein weiterer Vorteil ist die groe Anzahl verfgbarer Programmiersprachen, die je nach Kenntnisstand und persnlicher Vorliebe gewhlt werden knnen, ohne dass Einschrnkungen gemacht werden mssen, z. B. was die Nutzung einer in einer bestimmten Programmiersprache geschriebenen Komponente aus einer anderen Sprache angeht. Wie aber werden Codeteile, die z. B. in C# entwickelt wurden, mit Codeteilen, die in Visual Basic .NET oder einer anderen Programmiersprache geschrieben wurden, zur Ausfhrung gebracht? Sptestens hier muss man von der konventionellen Programmierung mit ihren verschiedenen Laufzeitumgebungen Abschied nehmen und umdenken. Wir wissen von den vorhergehenden Abschnitten, dass das .NET Framework nur exakt eine Laufzeitumgebung besitzt und dass hier alle Programmiersprachen aufsetzen knnen und vom .NET Framework verstanden werden. Das Problem, das hier entsteht, ist der Zwischenschritt zwischen dem Programm (in einer beliebigen .NET-Programmiersprache geschrieben) und der fertigen Ausfhrungsdatei. Dieser Zwischenschritt wird in .NET mit einem Zwischencode gelst. Diesen Zwischencode nennt man Intermediate Language Code, kurz IL-Code. Dieser IL-Code wird vom .NET Framework verstanden und kann von diesem in eine ausfhrbare Datei bersetzt werden. Da das .NET Framework zwischen Programm und Betriebssystem liegt, spielt das Betriebssystem bei der Programmierung in der Regel keine Rolle mehr, da das .NET Framework als Vermittler zwischen Betriebssystem und Programm fungiert. Fr Entwickler, die auf der .NET Plattform programmieren, bedeutet dies, dass zunchst kein Maschinencode erzeugt wird (fr einen bestimmten Prozessor), sondern IL-Code. IL-Code kann man sich als Code fr einen virtuellen Prozessor vorstellen, einen Prozessor, den es physisch nicht gibt, der gedacht ist, nur in Form von Software existiert. Solch ein prozessorunabhngiger Code ist nichts vllig Neues, man bezeichnet diesen bei anderen Technologien meist als P-Code oder Bytecode. Im Unterschied zum IL-Code wird P-Code aber meist nur von einer

27


bestimmten Programmiersprache erzeugt; man ist damit zwar plattformunabhngig, aber gezwungen, eine bestimmten Programmiersprache einzusetzen. Durch das Konzept des IL-Codes wird klar, warum ein Programm in den unterschiedlichsten Programmiersprachen realisiert werden kann. Unabhngig davon, welche Programmiersprache eingesetzt wird, wird der lesbare Quelltext (also z. B. C#-Anweisungen) in den bergreifenden, allgemeinen IL-Code umgewandelt. Das Programm, das diese Umwandlung vornimmt, wird als Compiler bezeichnet, der Vorgang der Umwandlung heit Kompilierung. Die Compiler generieren neben dem IL-Code noch zustzliche Informationsdaten, die so genannten Metadaten. Diese Metadaten beinhalten z. B. Informationen ber Typen, Elemente (Members) und Verweise (References) aus Ihrem Programm. Die Common Language Runtime bentigt Metadaten, um z. B. die Klassen laden zu knnen. Metadaten werden, wie Sie der unteren Abbildung entnehmen, zusammen mit dem IL-Code gespeichert.

CompilerQuellcode (Sourcecode)

Jitter

Compiler (z.B. C#-Compiler)

Code Metadaten

Abbildung 1.3: Vorgang des Kompilierens

Der IL-Code ist das Produkt der verschiedenen Compiler und wird als Ausfhrungscode fr den JIT-Compiler bentigt.

1.2.4 JIT-CompilerAuch das .NET Framework basiert auf dem allgemeinen IL-Code. So erzeugt z. B. der C#-Compiler zwar IL-Code, dieser Code kann aber vom physischen Prozessor des Computers nicht verstanden werden. Jeder Prozessortyp verfgt ber seine eigene Maschinensprache. Letztendlich kann der Computer doch nur die Maschi-

28

.NET Framework

nensprache des physischen Prozessors ausfhren. Diesen Code bezeichnet man als Native Code (oder in Deutsch auch als nativen Code), was in etwa angeboren, ursprnglich bedeutet. Daraus folgt, dass zu irgendeinem Zeitpunkt der IL-Code noch in den nativen Code bersetzt werden muss. Gewhnlich wird fr vergleichbare Zwecke eine Art Interpreter eingesetzt (P-Code-Interpreter), was aber auf Kosten der Ausfhrungsgeschwindigkeit geht, da immer die gleichen Anweisungen stndig neu bersetzt werden, auch wenn sich am Programm nichts verndert hat. Alternativ knnte man den Code auch mit einem Compiler umwandeln, der nativen Code erzeugt. Dadurch wrde man eine hhere Geschwindigkeit erzielen, aber die Umwandlung msste dann vom Programmierer nach nderungen manuell vorgenommen werden, und es wren noch weitere Nachteile damit verbunden, die auch die Plattformunabhngigkeit von .NET in Frage stellen wrden. Um die Vorteile von Compiler und Interpreter zu vereinen, kommt daher eine Mischung zwischen beiden Anstzen in Form eines so genannten Just-in-TimeCompilers oder auch Jitters zum Einsatz. Der JIT-Compiler wandelt den IL-Code automatisch in Maschinencode um. Dies geschieht nur bei Bedarf, und zwar konkret dann, wenn ein Programm aufgerufen wird.

Compiler

JitterJIT-Compiler

Native Code

Abbildung 1.4: Vorgehensweise der JIT-Kompilierung

Diese Umwandlung geht so weit, dass Programmmodule, die nicht verwendet werden, auch nicht durch den JIT-Compiler bersetzt werden. Erst wenn die Programmmodule durch den Anwender oder andere Funktionsaufrufe im Programm aufgerufen werden, erfolgt die bersetzung. Der Vorteil ist, dass nur ganz unwesentlich Geschwindigkeit verloren geht; wenn das Programmmodul einmal bersetzt ist, luft es mit der vollen Ausfhrungsgeschwindigkeit des nativen Codes.

29


Gleichzeitig bleibt .NET ohne Einschrnkung plattformunabhngig, sodass der IL-Code nicht auf eine bestimmte Umgebung angewiesen ist.

1.2.5 Die Ausfhrung ExecutionMit dem C#-Compiler, csc.exe, kompilieren Sie den vorhandenen Code in den ILCode. Wir werden uns spter noch genauer mit dem C#-Compiler auseinander setzen. Nehmen wir an, Sie haben ein Programm entwickelt, das verschiedene, sehr komplexe Berechnungsarten durchfhren kann und haben diese als separate Module realisiert und in einer Berechnungs-Klasse zusammengefasst. Wenn Sie nun eine bestimmte Berechnung durchfhren, sucht sich der JIT-Compiler den Einstiegspunkt im IL-Code und bersetzt das betroffene Berechnungsmodul in nativen Code. Die brigen Berechnungsmodule liegen jetzt immer noch als IL-Code vor. Wenn das gleiche Modul ein zweites Mal ausgefhrt wird, muss der JIT-Compiler den Code nicht noch einmal bersetzen, er fhrt einfach den bereits bersetzten und vorhandenen Maschinencode erneut aus. Erst wenn weitere, noch nicht bersetzte Module aufgerufen werden, wandelt der JIT-Compiler diese Module wiederum in Maschinencode um. Auf diese Weise wird die Ausfhrung erheblich beschleunigt. Diese Beschleunigung macht sich vor allem bei greren Programmen positiv bemerkbar, da beim Aufruf nur die Module bersetzt werden, die derzeit tatschlich bentigt werden. Der JIT-Compiler ist sogar in der Lage, auf nderungen der Hardware des Computers zu reagieren und den Maschinencode hierfr zu optimieren.

CompilerQuellcode (Sourcecode)

JitterJIT-Compiler

Compiler (z.B. C#-Compiler)

Native Code

Code Metadaten

Abbildung 1.5: Ausfhrung eines Programms (IL-Code zu nativem Code)

30

Eine Klasse fr sich

1.3

Eine Klasse fr sich

Bevor wir mit der eigentlichen Programmierung beginnen, sollten wir uns mit den Grundzgen der objektorientierten Programmierung auseinander setzen und hier speziell mit den Klassen. C# ist eine objektorientierte Programmiersprache. Was eine Klasse im programmtechnischen Sinn darstellt, wird spter noch genauer beschrieben. Aber vorerst ein abstraktes Fallbeispiel, um die Grundidee von Klassen und Klassendesign zu vermitteln. Allgemein ausgedrckt, ist eine Klasse eine abstrakte Abbildung von realen Problemen des (Programmier-)Alltags, die in sich eine Lsung bereitstellt und/oder diese ihrer Umgebung mitteilt bzw. Aufgaben erfllt. Hierzu besitzen Klassen Methoden und Eigenschaften, die es miteinander zu kombinieren gilt, um die gestellten Probleme zu lsen. (Eine Methode fhrt eine konkrete Aktion aus eine Eigenschaft stellt mehr ein Merkmal da, gibt also eine Information zurck, wie etwas beschaffen ist. Die Bedeutung von Methoden und Eigenschaften wird spter noch ausfhrlich beschrieben.) Interessant zu wissen ist auch, dass man eine Klasse in einem Programm nicht direkt verwenden kann. Wenn Sie jetzt ein wenig verunsichert sind und sich die Frage stellen, warum man dann in C# Probleme in Klassen kapselt und was die ganze objektorientierte Programmierung fr einen Sinn ergibt, kann ich Sie beruhigen. Mir ist es auch nicht anders ergangen, als ich zum ersten Mal von Klassen und objektorientierter Programmierung gehrt habe. Stellen Sie sich einen Professor vor, der in der ersten Vorlesungsstunde seine Skripte verteilt. Hunderte von Studenten warten wissbegierig und lernbereit darauf, ihr persnliches Skript zu erhalten. Es ist klar, dass der Professor nicht hunderte Male dieses Skript geschrieben hat, sondern Kopien davon angefertigt hat. Das Original besitzt nur der Professor, der in seinen Vorlesungen den Lernstoff gem Skript vermittelt und die Studenten darauf hinweist, was wichtig ist und was nicht. Die Studenten arbeiten mit ihrem persnlichen Skript und markieren zum Beispiel mit einem Textmarker wichtige Textpassagen und schreiben sich Notizen in ihr Skript. Dieses kleine Vorlesungsbeispiel verhlt sich hnlich wie eine Klasse. Den Arbeitsspeicher eines Computers kann man sich ganz entfernt als Vorlesungssaal des Professors vorstellen, in dem die Studenten sitzen. In dem Augenblick, in dem der Professor seine erste Kopie des Originals an einen Studenten verteilt, damit dieser mit der Kopie arbeiten kann, existiert ein Skript, das sich vom Original unterscheidet. Dieses Skript des Studenten nennt man in der objektorientierten Programmierung Instanz.

31


Sie werden sich jetzt fragen, wo diese Unterschiede liegen. Um im nchsten Jahr den neuen Studenten wieder eine Kopie des Skripts aushndigen zu knnen, belsst man das Original so wie es ist im Gegensatz zur Kopie, mit der die Studenten arbeiten und eventuell Textstellen markieren sowie Notizen hinzufgen. Eine Klasse ist vergleichbar mit dem Original des Skripts. Wenn man also mit dem Inhalt des Skripts arbeiten mchte, bekommt man eine Kopie des Originals; der Platz, den der Student im Hrsaal belegt, ist vergleichbar mit dem Speicherplatz, der der Kopie der Klasse im Speicher zugewiesen wird. In der Programmierung nennt man diesen Vorgang Instanzierung oder Instanzbildung von Klassen. Aus diesem Vorgang der Instanzbildung, also der Erstellung einer Kopie des Skripts des Professors, ergibt sich ein Objekt. Man kann sich ein Objekt als arbeitende Kopie vorstellen, in Wirklichkeit ist ein Objekt eine konkrete Darstellung der abstrakten Klassenbeschreibung. Nun drfte Ihnen die Vorstellung nicht mehr allzu schwer fallen, dass nicht mit Klassen gearbeitet wird, sondern mit Objekten dieser Klasse, indem eine Instanz der Klasse gebildet wird. Wenn Sie das nchste Beispiel verstehen, gratuliere ich Ihnen im Voraus, ansonsten lassen Sie sich nicht entmutigen und lesen Sie dieses Teilkapitel noch einmal durch. Ich abstrahiere eine Klasse Student mit den Eigenschaften Haarfarbe und Groesse. Daraus ergibt sich, dass Shinja eine Instanz (Objekt konkrete Darstellung) der Klasse (abstrakte Darstellung) Student ist.Student Shinja = new Student(); Shinja.Haarfarbe = schwarz; Shinja.Groesse = 172;

So ergibt sich, dass die Haarfarbe von Shinja, einem Studenten, schwarz ist und seine Gre 172 cm betrgt. Dieses Beispiel kann ich mit allen Studenten durchfhren und viele Objekte der Klasse Student erzeugen. Das Schlsselwort new erzeugt eine Instanz mit dem Namen Shinja. Der Punkt (.) in Shinja.Haarfarbe bedeutet ganz einfach, dass die Eigenschaft Haarfarbe etwas Untergeordnetes von Shinja ist, in diesem Fall eine Eigenschaft. Der Punkt spielt in der objektorientierten Programmierung eine zentrale Rolle, um Hierarchien anzugeben, entfernt vergleichbar mit dem Trennzeichen \ in Dateisystem-Verzeichnispfaden wie c:\daten\test.

32

Hallo .NET Vom Quelltext zum Programm

1.4


Es ist Tradition, dass das erste Programm, das man schreibt, wenn man mit dem Erlernen einer Programmiersprache beginnt, nichts anderes durchfhrt, als den Begrungstext Hello world! auf die Konsole auszugeben. Bei mir war es nicht anders. Inzwischen hat sich viel getan; so erlaube ich mir, dass ich im Zeitalter von Internet und .NET diese Begrung ein klein wenig verndere. Tippen Sie den im Anschluss abgedruckten Programmcode einfach einmal ab, indem Sie zum Beispiel einen der Windows-Editoren WordPad oder Notepad (letzterer wird von Windows nur als Editor bezeichnet) verwenden. Hierzu klicken Sie auf die START-Schaltflche und anschlieend auf ALLE PROGRAMME. Unter dem Ordner ZUBEHR sollten Sie die beiden Editoren finden. Wenn Sie dort keinen der Editoren finden (was eigentlich nicht vorkommen sollte), klicken Sie unter START/ALLE PROGRAMME/ZUBEHR auf den Eintrag AUSFHREN und ffnen Sie das gleichnamige Dialogfeld. Geben Sie darin den Befehl notepad ein und besttigen Sie Ihre Eingabe mit OK. Ich mchte Sie zu Beginn nicht mit der Entwicklungsumgebung Visual C# konfrontieren, da diese fr den Anfang den Blick auf das Wesentliche erschwert. Wir werden spter noch genauer auf die Entwicklungsumgebung Visual C# zu sprechen kommen. Fr die bungen, die wir im Laufe dieses Buches erstellen werden, legen Sie einen Ordner an, am besten unter dem Namen Beispiele in der obersten Ebene des Laufwerks C:. Fr jeden Tag im Buch empfiehlt sich ein separater Unterordner mit der Nummer des jeweiligen Kapitels. Verwenden Sie z. B. den WindowsExplorer, um die Ordner anzulegen. Die Ordnerstruktur sieht jetzt etwa so aus:

C:\Beispiele\Kapitel01 C:\Beispiele\Kapitel02

usw. Jetzt, nachdem bekannt ist, wo unsere Programme gespeichert werden, schreiben wir unser erstes Programm. ffnen Sie das Programm Notepad und geben Sie folgende Zeilen ohne Zeilennummer und ohne Doppelpunkt ein:

33


Abbildung 1.6: Startmen (unter Vista)

Abbildung 1.7: Aufruf des Notepad-Editors

34


Listing 1.1: HalloDotNet1.cs Hallo. NET die Erste 01: 02: 03: 04: 05: 06: 07: 08: 09: 10: 11: 12: 13: // Erstes Programm namespace Kap1 { using System; public class CHalloEins { public static void Main(string[] args) { Console.WriteLine("Hallo .NET"); } } }

Achten Sie darauf, dass Sie die abschlieenden Strichpunkte (;) z. B. bei using System; nicht vergessen. Dies ist entscheidend! Bei C# muss eine Anweisung immer mit einem Strichpunkt abschlieen. Speichern Sie die Datei in dem eben angelegten Verzeichnis Kapitel 1 unter dem Namen HalloDotNet1.cs. Quelltextdateien haben in der Programmiersprache C# immer die Endung .cs. Starten Sie die Eingabeaufforderung (Konsole) ber das Startmen (je nach Betriebssystem ber PROGRAMME/(MSDOS-)EINGABEAUFFORDERUNG oder START/ALLE PROGRAMME/ZUBEHR/EINGABEAUFFORDERUNG). In Verbindung mit einigen Betriebssystemen knnen Sie hierzu auch im Dialogfeld AUSFHREN (ebenfalls ber START/ALLE PROGRAMME/ZUBEHR aufzurufen) das Kommando cmd eingeben. Wechseln Sie mit dem cd-Befehl in den Ordner, in dem sich das erste Beispielprogramm befindet, und geben Sie folgende Zeile ein:csc HalloDotNet1.cs

Beim Aufruf des C#-Compilers csc knnen unter Umstnden Probleme auftreten, wenn kein Eintrag des Pfades zur Datei csc.exe in den Umgebungsvariablen existiert. Diese Datei befindet sich unter Vista im Unterordner Microsoft.NET\Framework\v3.5 des Windows-Ordners, also z. B. C:\WINDOWS\Microsoft.Net\Framework\v3.5. Die letzte Verzeichnisangabe hngt von der Version des .NET Frameworks ab, etwa: v1.0.3705 fr .NET Framework 1.0, v1.1.4322 fr .NET Framework 1.1, v2.0.50727 fr

35


.NET Framework 2.0, v3.0 fr .NET Framework 3.0 und v3.5 fr .NET Framework 3.5. (Wenn Sie den Compiler gar nicht lokalisieren knnen, installieren Sie zuerst Visual C# und suchen Sie dann ber die Suchfunktion des Windows Explorers nach der csc.exe-Datei.) Um den Pfad aufzunehmen, rufen Sie die SYSTEMSTEUERUNG auf (z. B. ber den START/SYSTEMSTEUERUNG), aktivieren Sie in der klassischen Ansicht den Eintrag SYSTEM/ERWEITERTE SYSTEMEINSTELLUNGEN/ UMGEBUNGSVARIABLEN, whlen Sie die Systemvariable Path, klicken Sie auf BEARBEITEN und ergnzen Sie die Variable um den Pfad zum entsprechenden Ordner (z. B. C:\WINDOWS\Microsoft.Net\Framework\v3.5). Achten Sie darauf, dass die einzelnen Pfaddefinitionen durch Semikola (;) getrennt sind, und besttigen Sie mit OK. Die nderungen wirken sich erst aus, wenn Sie eine neue Eingabeaufforderung ffnen. Nach Aufruf des Compilers sollte in etwa folgende Ausgabe zu sehen sein:Microsoft (R) Visual C# 2008 Compiler version 3.5.21022.8 for Microsoft (R) .NET Framework version 3.5 Copyright (C) Microsoft Corporation. Alle Rechte vorbehalten.

Lassen Sie sich nicht von der etwas spartanischen Ausgabe irritieren. Wie schon erwhnt, kann das .NET Framework genauer gesagt die Common Language Runtime nur IL-Code verarbeiten. Der lesbare Quelltext der Datei HalloDotNet1.cs muss daher zunchst in IL-Code bersetzt, also kompiliert werden. Genau dies ist mit dem obigen Aufruf geschehen. Dass die Ausgabe so knapp ist, liegt einfach daran, dass alles in Ordnung ist und dass keine Fehler aufgetreten sind. Kompiliert man den Beispiel-Quelltext HalloDotNet1.cs, wird der ILCode in Form der Datei HalloDotNet1.exe im selben Ordner abgelegt. Diese Datei wird auch als Assembly (assembliert, zusammengestellt) bezeichnet. Der C#-Compiler erzeugt grundstzlich Dateien, welche den gleichen Dateinamen wie der Quelltext besitzen, aber die Erweiterung .exe (engl. execute ausfhren) aufweisen. Fhrt man die Datei HalloDotNet1.exe aus, indem man den Dateinamen ohne Endung in die Kommandozeile schreibt, also HalloDotNet1, wird folgende Zeile ausgegeben.

36

Hallo .NET der Quelltext

Hallo .NET

Ich gratuliere Ihnen zu Ihrem ersten Programm! Bevor wir weitermachen, gehen Sie noch einmal die oben besprochenen Schritte durch. Hierbei ist es im Moment noch nicht wichtig, was die Anweisungen im Quelltext bedeuten. Vielmehr steht die Vorgehensweise vom vorhandenen Quelltext zur ausfhrbaren Datei im Vordergrund. Nehmen Sie sich die Zeit und betrachten Sie zustzlich die Abbildung 1.5 aus Abschnitt 1.2.5 und sehen Sie sich die erzeugte Datei im Verzeichnis C:\Beispiele\Kapitel01 an.

1.5


In diesem Abschnitt sehen wir uns den Quelltext etwas genauer an.Listing 1.2: HalloDotNet1.cs Bestandteile eines C#-Programms 01: // Erstes Programm 02: namespace Kap1 03: { 04: using System; 05: 06: public class CHalloEins 07: { 08: public static void Main(string[] args) 09: { 10: Console.WriteLine("Hallo .NET"); 11: } 12: } 13: }

Das obige Programm beginnt mit einem Kommentar:// Erstes Programm

Kommentare dienen dazu, erklrenden Text direkt in den Quelltext einzufgen. In C# gibt es zwei Formen von Kommentaren:

Wenn Sie eine einzelne Zeile oder den Rest einer Zeile als Kommentar kennzeichnen mchten, leiten Sie den Kommentar mit der Zeichenfolge // ein.

37


Alles, was hinter der Zeichenfolge // bis zum Ende der Quelltextzeile steht, wird vom Compiler als Kommentar interpretiert.

Mehrzeilige Kommentare beginnen Sie dagegen mit /* und schlieen Sie mit */ ab.

Vom Compiler werden die Kommentare gnzlich ignoriert. Wenn Sie also in ein Programm Kommentare einfgen, dann sind diese nur fr Sie selbst und fr etwaige andere Programmierer bestimmt, die sich mit Ihrem Quelltext auseinander setzen mssen. Fgen Sie vor allem solche Kommentare ein, die Ihnen und anderen Programmierern helfen, den Quelltext und die Ablufe im Programm besser zu verstehen: Kommentieren Sie die Bedeutung aller wichtigen Bestandteile des Codes. Denken Sie dabei daran, dass selbst Abschnitte und Codefragmente, deren Bedeutung whrend der Entwicklung absolut klar sind, zu einem spteren Zeitpunkt Fragen aufwerfen knnen. Daher bietet es sich an, im Zweifelsfall lieber einen Kommentar zu viel als zu wenig zu schreiben. Unter dem einleitenden Kommentar des Beispiels folgen drei Codeblcke:

namespace class Main

Sie sollten sich angewhnen, Programmteile und Blcke im Quelltext sauber zu formatieren. Diese Programmteile und Blcke (ein Block wird durch geschweifte Klammern {} dargestellt) vereinfachen die Lesbarkeit des Quelltextes und die Fehlersuche. Statt einer sinnvollen Untergliederung in mehrere Zeilen knnten Sie auch alles in eine Zeile schreiben:namespace Hallo.Net{using System;public class CHalloEins{public static void Main(string[] args){Console.WriteLine("Hallo .NET");}}}

Sie sehen natrlich sofort, dass die Lesbarkeit darunter leidet und die Zusammengehrigkeit nur mit sehr viel Mhe zu erkennen ist. In Kapitel 3.10.7 wird im Zusammenhang mit den bedingten if-else-Operationen ausfhrlich auf die Stilkonventionen beim Aufsetzen von C#-Programmen eingegangen. Zerlegen wir einmal den Quelltext in seine einzelnen Blcke und beginnen mit der besonderen Methode Main().

38


public static void Main(string[] args) { Console.WriteLine("Hallo .NET"); } public ist ein reserviertes Wort und modifiziert die Methode Main(). Damit ist gemeint, dass die Art des Zugriffs auf die Methode Main() definiert wird. public

heit ffentlich, was bedeutet, dass es keine Einschrnkungen gibt, auf die Methode Main() zuzugreifen.static ist wie public ein reserviertes Wort und modifiziert ebenfalls die Methode Main(). Das Wort static in Verbindung mit einer Methode bedeutet, dass die

Methode aufgerufen werden kann, ohne dass eine Instanz der Klasse im BeispielCHalloEins erzeugt werden muss. void ist ein Datentyp und gibt der Methode Main() zu verstehen, dass sie keinen

Wert zurckliefern muss und darf. Fr die Methode Main() stehen genau zwei Datentypen zur Verfgung: void und int (Ganzzahl). Andere Datentypen knnen nicht als Rckgabewert der Methode Main() verwendet werden und fhren zu einem Fehler bei der Kompilierung. Als Argument also bergabewert der Methode Main() wird der Datentyp string verwendet, der die Parameter aus der Kommandozeile einliest. Sehen wir uns nun die Anweisung der Methode Main() an. Console ist wie unsere Klasse CHalloEins selbst eine Klasse des Namensraums System (zur Bedeutung von Namensrumen gleich mehr). Des Weiteren besitzt die Klasse Console die Methode WriteLine(), die eine Zeile in unserem Fall Hallo .NET in die Konsole schreibt. Der zweite Block definiert die Klasse, indem der Name der Klasse und die Zugriffsart auf die Klasse angegeben werden.public class CHalloEins { . . . }

Das reservierte Wort class gibt an, dass es sich bei diesem Block um eine Klasse handelt und jede Methode und Eigenschaft ein Mitglied dieser Klasse ist.public steht genau wie in der Methode Main() fr ffentlich. So kann auf die Klasse CHalloEins ohne Einschrnkungen zugegriffen werden.

39


Der dritte und letzte Block ist der namespace-Block.namespace Kap1 { using System; . . . } namespace bedeutet Namensraum. Mit Hilfe von Namensrumen umgeht man das

Problem der Mehrfachbenennung von Klassen. So ist es mglich, gleichnamige Klassen in unterschiedlichen Namensrumen zu verwenden. Zustzlich kann man in der Projektierungsphase Namensrume dazu verwenden, Projekte zum Beispiel nach thematischen, funktionalen oder anderen Aspekten einzuteilen, vor allem um berschneidungen bei der Namensvergabe zu vermeiden, wenn in einem Projekt mehrere Entwickler beteiligt sind. Mit dem reservierten Wort using wird ein weiterer Namensraum in den Code eingebunden. Das reservierte Wort using wird oftmals auch als using-Direktive bezeichnet. Fhrt man eine volle Qualifizierung auf die Methode WriteLine() durch, entsteht folgende Zeile (Qualifizierung bedeutet hier, dass der volle Pfad Namensraum.Klasse.Methode angegeben wird):System.Console.WriteLine("Hallo .Net") System ist hier der Namensraum der Klasse Console mit der Methode WriteLine(). Mit dem reservierten Wort using vereinfachen wir somit den Zugriff auf die Methode WriteLine(), da nicht stndig der Namensraum System mit angege-

ben werden muss. Ein kleines, aber akzeptables bel bei der Verwendung der using-Direktive ist, dass Sie in Ihrem Programm die Konsistenz zweier unterschiedlicher Namensrume sicherstellen mssen. Das heit, dass zwei unterschiedliche Namensrume, die durch die using-Direktive in Ihr Programm eingebunden werden, keine Klassen und Methoden mit gleichem Namen aufweisen drfen.

40

Hallo .NET Die Zweite

1.6


Die besondere Methode Main() ist der Einstiegspunkt eines Programms. Hier startet sozusagen das Programm und fhrt dann die in der Methode Main() stehenden Anweisungen aus. Mchten Sie z. B. eine weitere Methode aufrufen, so muss diese in der Methode Main() aufgerufen werden. Somit ist klar, dass ein Programm nur eine Methode Main() besitzen kann. Im Grunde stimmt die Aussage und in der Regel trifft es auch zu, dass ein Programm nur eine Klasse mit einer Methode Main() enthlt. Sie knnen aber ein Programm entwickeln, das aus mehreren Klassen besteht, sodass die Methode Main() doch mehrfach vorkommen kann. Allerdings darf jede Klasse nur einmal eine Methode Main() aufweisen. Woher aber wei der C#-Compiler, welchen Einstiegspunkt er verwenden soll? Ganz einfach, man muss ber eine Compileroption angeben, welche Methode Main() zum Start eines Programms verwendet werden soll. Lassen Sie sich den oberen Absatz noch einmal durch den Kopf gehen: Ein Programm kann mehrere Methoden Main() beinhalten, aber jede Klasse weist nur eine Methode Main() auf. Daraus ergibt sich, dass der Klassenname herangezogen werden muss, um dem Compiler mitzuteilen, welche Main()-Methode gemeint ist. Um dies in der Praxis zu demonstrieren, schreiben Sie ein zweites C#-Programm mit zwei Main()-Methoden. ffnen Sie dazu wieder das Programm Notepad und geben Sie folgende Zeilen ein:Listing 1.3: HalloDotNet2.cs Hallo .NET mit zwei Main-Methoden 01: namespace Kap1 02: { 03: using System; 04: 05: public class CHalloEins 06: { 07: public static void Main(string[] args) 08: { 09: Console.WriteLine("Hallo .NET"); 10: } 11: } 12: 13: public class CHalloZwei

41


14: 15: 16: 17: 18: 19: 20: 21: }

{ public static int Main(string[] args) { Console.WriteLine("Hallo .NET"); return(0); } }

Speichern Sie die Datei unter dem Namen HalloDotNet2.cs. Starten Sie die Eingabeaufforderung, wechseln Sie in das entsprechende Verzeichnis und geben Sie folgende Zeile ein:csc HalloDotNet2.cs

Der C#-Compiler hat erkannt, dass es mehr als einen Einstiegspunkt in unserem Programm gibt, und zeigt daher folgende Fehlermeldung an1:HalloDotNet2.cs(7,26): error CS0017: Das Programm 'HalloDotNet2.exe' hat mehr als einen Einstiegspunkt definiert: 'Kap1.CHalloEins.Main(string[])' HalloDotNet2.cs(15,26): error CS0017: Das Programm 'HalloDotNet2.exe' hat mehr als einen Einstiegspunkt definiert: 'Kap1.CHallozwei.Main(string[])'

So sieht eine standardmige Fehlermeldung des C#-Compilers aus. Zuerst wird der Name der Quelltextdatei angezeigt und in Klammern die Position des Fehlers. Die erste Fehlermeldung bzw. der erste Fehler, der durch den Compiler erkannt wurde, liegt in der 7. Zeile in der 26. Spalte. Eine Spalte im Quelltext ist die tatschliche Zeichenposition in der entsprechenden Zeile. Die Zeilen und Spalten im Quelltext werden immer von 1 aus gezhlt. Bewegen Sie Ihren Cursor zur entsprechenden Fehlerstelle, also in die 7. Zeile und dort in die 26. Spalte. Ihr Cursor msste jetzt in der ersten Klasse CHalloEins bei der Methode Main() stehen und den Buchstaben M markieren. Als Nchstes wird die Fehlernummer angezeigt. In unserem Beispiel ist das beide Male der Fehler CS0017. Nach der Fehlernummer wird der Fehler genau beschrieben. Die Fehlerbeschreibung gibt an, dass mehrere Einstiegspunkte vorhanden sind. Zustzlich werden die beiden Methoden Main() mit den zugehrigen Namensrumen aufgelistet. Sie sehen also, dass man mit den Fehlermeldungen schon sehr viel Informationen geliefert bekommt, was die Fehlerbehebung schon betrchtlich erleichtert.

1

Die Ausgabe kann sich je nach Framework-Version ndern.

42


Fehlermeldungen des C#-Compilers bestehen aus drei Teilen, die jeweils durch einen Doppelpunkt getrennt werden:

Name der Quelltextdatei mit den Koordinaten in Klammern Fehlernummer Beschreibung des Fehlers Die beiden grten Fehlerquellen bei der Programmierung sind im Allgemeinen Syntaxfehler und logische Fehler.

Zur Behebung des Fehlers mssen Sie nun dem C#-Compiler mitteilen, welche Methode Main() in welcher Klasse als Einstiegspunkt verwendet werden soll. Dazu verwenden wir die Compileroption /main:. Allgemein wird die Compileroption /main: folgendermaen verwendet:

csc /main:. oder kurz geschrieben csc /m:.

Wenn wir, wie in unserem Fall, die Klasse CHalloZwei mit ihrer Methode Main()als Einsprungmarke verwenden mchten, mssen wir folgenden Befehl schreiben:csc /m:Kap1.CHalloZwei HalloDotNet2.cs

In unserem Programm heit unser Kap1. Innerhalb von Namensrumen drfen Sie brigens anders als bei den Namen von Klassen und anderen Programmelementen auch den Punkt verwenden. Sie knnten also auch Hallo.NET als Namensraum angeben. Der Parameter und somit die in der Klasse existierende Methode Main() weist den C#-Compiler an, dass er in unserem Fall die Klasse CHalloZwei und deren Methode Main() als Einstiegspunkt verwenden soll. Getrennt mit einem Leerzeichen gibt man die Datei an, die kompiliert werden soll, hier ist es die Datei HalloDotNet2.cs. Wenn Sie die ausfhrbare Datei starten, sollten Sie Folgendes in Ihrer Konsole sehen.

43


Hallo .NET

Probieren Sie nun, die andere Methode Main() also die der Klasse CHalloEins als Einstiegspunkt zu whlen, und fhren Sie die Datei nochmals aus.

1.7

Hallo .NET Gro- oder Kleinschreibung

In der Programmiersprache C# spielt die Gro- und Kleinschreibung eine wichtige Rolle. Ich knnte es mit der Aussage belassen, dass C# zwischen Gro- und Kleinschreibung unterscheidet, d. h. eine so genannte case-sensitive Sprache ist. Es ist aber sehr wichtig zu sehen, wie mchtig ein Buchstabe sein kann, je nachdem, ob er klein oder gro geschrieben wird. Nehmen wir an, dass ein Buchhaltungssystem entwickelt wird und mehrere Programmierer daran beteiligt sind. Dabei knnte sich der unglckliche Fall ergeben, dass ein Programmierer eine Methode MWSt(), der andere eine Methode MwSt() im gleichen Namensraum entwickelt. Die Methode MWSt() knnte den Preis inklusive Mehrwertsteuer ermitteln und die Methode MwSt() nur die Mehrwertsteuer eines Preises. Da die Namen in puncto Gro- und Kleinschreibung nicht identisch sind, handelt es sich tatschlich um unterschiedliche Methoden. Es ist klar, dass hier eine Konfusion vorprogrammiert ist und man bei Berechnungen, wenn man diesen feinen Unterschied beim Methodenaufruf nicht beachtet, schnell zu einem Ergebnis kommen kann, das man eigentlich nicht haben mchte. Da sich der vorhergehende Abschnitt mit der Methode Main() beschftigt hat, werden wir ein Programm schreiben, das die Problematik mit der Gro- und Kleinschreibung in Verbindung mit dieser Methode aufzeigt. Die Auswirkungen sind brigens nicht ganz so gravierend wie bei unserem Gedankenmodell mit dem Buchhaltungssystem. ffnen Sie dazu wieder den Notepad-Editor und geben Sie folgende Zeilen ein:Listing 1.4: HalloDotNet3.cs Hallo .NET mit der Problematik der Gro-/Kleinschreibung 01: namespace Kap1 02: { 03: using System;

44

Hallo .NET Gro- oder Kleinschreibung

04: 05: 06: 07: 08: 09: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: }

public class CHalloEins { public static void Main(string[] args) { Console.WriteLine("Hallo .NET"); } } public class CHalloDrei { public static void main(string[] args) { Console.WriteLine("Hallo .NET klein"); } }

Ihnen ist sicherlich aufgefallen, dass die Klasse CHalloDrei eine Methode main() jetzt klein geschrieben besitzt. Speichern Sie die Datei unter dem Namen HalloDotNet3.cs. Starten Sie die Eingabeaufforderung, wechseln Sie in das Verzeichnis und geben Sie folgendes Kommando ein:csc HalloDotNet3.cs

Auffllig ist, dass der C#-Compiler keine Fehlermeldung ausgibt. Das bedeutet, dass es nur eine Methode gibt, die als Einstiegspunkt verwendet werden kann. Dies ist die Methode Main() beginnend mit einem groen M. Diese Aussage kann man leicht nachweisen, indem wir dem C#-Compiler mitteilen, dass die Methode main() in der Klasse CHalloDrei als Einstiegspunkt verwendet werden soll. Geben Sie folgendes Kommando ein:csc /m:Kap1.CHalloDrei HalloDotNet3.cs

Sie werden folgende Fehlermeldung vom C#-Compiler erhalten2:HalloDotNet3.cs(13,17): error CS1558: 'Kap1.CHalloDrei' hat keine passende Hauptmethode

2

Die Ausgabe kann sich je nach Framework-Version ndern.

45


Der C#-Compiler sucht nach einer Methode Main() in der Klasse CHalloDrei. Wir knnen dem C#-Compiler aber nur eine Methode main() anbieten, die er jedoch als Einstiegspunkt nicht akzeptiert.

1.8

Hallo .NET Die Argumente

Im Allgemeinen kann man jeder Methode Argumente bergeben. In C# stehen sie nach dem Methodennamen in runden Klammern. Wenn eine Methode Argumente besitzt, mssen diese deklariert werden, wie auch alle anderen Elemente in C#. Wenn man von Deklarieren von Argumenten und natrlich auch von Variablen (also Platzhaltern, die (vernderbare) Daten speichern) spricht, bedeutet das nichts anderes, als dass man dem Argument einen Datentyp zuweist. Der Name des Arguments spielt keine groe Rolle, sollte aber natrlich so gehalten sein, dass er sich selbst erklrt, also nicht allzu kryptisch ist. Wie Sie in den vorherigen Beispielen bereits gesehen haben, besitzt die Methode Main() ein Argument:public static void Main(string[] args)

oderpublic static int Main(string[] args)

Die Methode Main() besitzt ein Argument vom Typ string[]. Die eckigen Klammern bedeuten, dass es sich um ein so genanntes Array handelt. (Ein Array speichert mehrere Werte, die ber einen Index erreichbar sind. Auf Arrays und die brigen Datentypen werden wir im spteren Verlauf dieses Buches, speziell am Tag 3 und Tag 7, noch zu sprechen kommen.) Geben Sie folgendes Programm ein:Listing 1.5: HalloDotNet4.cs Das erste Argument 01: namespace Kap1 02: { 03: using System; 04: 05: public class CHalloVier 06: { 07: public static void Main(string[] args)

46

Hallo .NET Die Argumente

08: 09: 10: 11: 12: }

{ Console.WriteLine("Mein erstes Argument: {0}",args[0]); } }

Wie Sie dem obigen Beispiel entnehmen knnen, beginnt die Zhlung in Arrays bei 0. Wir werden spter ausfhrlich ber Arrays sprechen. In diesem Zusammenhang ist nur wichtig, dass Sie, wenn Sie mehrere Argumente beim Aufruf ber die Konsole angeben mchten, diese durch Leerzeichen trennen mssen. Speichern Sie die Datei unter dem Namen HalloDotNet4.cs. Starten Sie die Eingabeaufforderung, wechseln Sie in das entsprechende Verzeichnis und geben Sie folgende Zeile ein:csc HalloDotNet4.cs

Wenn Sie jetzt unser kleines Programm aufrufen, mssen Sie getrennt mit einem Leerzeichen ein beliebiges Wort eingeben, beispielsweise Strasser. Vergessen Sie die Angabe des Arguments, wird Ihr Programm abgebrochen. Ansonsten sollten Sie folgende Ausgabe in Ihrer Konsole sehen:HalloDotNet4 Strasser

Mein erstes Argument: Strasser

Auf einen Punkt in Listing 1.5 mchte ich noch besonders aufmerksam machen: der Ausgabe von Variablen auf die Konsole. Hierzu haben Sie einerseits die Mglichkeit, Variablen direkt auszugebenint i = 3; Console.WriteLine(i);

oder mit Hilfe des Konkatenationsoperators + in einen auszugebenden String einzubauen:int eingabe = 9; int wurzel = 3; Console.WriteLine("Die Wurzel von " + eingabe + " ist" + wurzel);

Eine andere Technik, die viele Programmierer vorziehen und die auch in Listing 1.5 verwendet wird, fgt die Variablenwerte via Paltzhalter in den String ein. Das Beispiel von oben wrde dann etwa wie folgt aussehen:Console.WriteLine("Die Wurzel von {0} ist {1}", eingabe, wurzel);

47

Er

C# 21 Tagen eBook

Documents

Transcript of C# 21 Tagen eBook