Visual C# 2008 in 21 Tagen

Visual C# 2008 in 21 Tagen

Visual C# 2008 Schritt für Schritt zum Profi DIRK 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 <http://dnb.ddb.de> abrufbar. Die Informationen in diesem Produkt werden ohne Rücksicht auf einen eventuellen Patentschutz veröffentlicht. Warennamen werden ohne Gewährleistung der freien Verwendbarkeit benutzt. Bei der Zusammenstellung von Texten und Abbildungen wurde mit größter Sorgfalt vorgegangen. Trotzdem können Fehler nicht vollständig ausgeschlossen werden. Verlag, Herausgeber und Autoren können für fehlerhafte Angaben und deren Folgen weder eine juristische Verantwortung noch irgendeine Haftung übernehmen. Für Verbesserungsvorschläge 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 zulässig. Fast alle Hardware- und Softwarebezeichnungen und weitere Stichworte und sonstige Angaben, die in diesem Buch verwendet werden, sind als eingetragene Marken geschützt. Da es nicht möglich ist, in allen Fällen 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-Straße 10 12, D 81829 München/Germany Alle Rechte vorbehalten Lektorat: Brigitte Bauer-Schiewek, bbauer@pearson.de Herstellung: Philipp Burkart, pburkart@pearson.de Korrektur: Martina Gradias Satz: Reemers Publishing Services GmbH, Krefeld, (www.reemers.de) Druck und Verarbeitung: Bercker, Kevelaer Printed in Germany

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

2.4 Der Editor...................................... 66 2.4.1 Dateien laden............................ 66 2.4.2 Eingabehilfen............................ 66 2.4.3 Syntax-Hervorhebung und -kontrolle.......... 67 2.4.4 Automatischer Einzug...................... 67 2.4.5 Anweisungsvervollständigung................ 67 2.4.6 Quickinfo................................ 69 2.5 Der Compiler................................... 70 2.5.1 Compileraufrufe.......................... 70 2.5.2 Das Ausgabefenster........................ 71 2.5.3 Die Projekteinstellungen.................... 72 2.5.4 Die Arbeit mit Projektkonfigurationen......... 73 2.6 Weitere Tools.................................... 74 2.6.1 Die Klassenansicht........................ 74 2.6.2 Der Windows Forms-Designer............... 75 2.6.3 Der Debugger............................ 76 2.7 Zusammenfassung............................... 76 2.8 Fragen und Antworten............................ 77 2.9 Workshop....................................... 77 2.9.1 Quiz.................................... 77 2.9.2 Übungen................................ 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 Schlüsselwörter.................................. 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

3.5 Typumwandlung................................. 104 3.5.1 Fehler bei der expliziten Konvertierung........ 105 3.5.2 Vermeiden von Konvertierungsfehlern......... 107 3.6 Konstanten..................................... 108 3.6.1 Literale Konstanten........................ 108 3.6.2 Symbolische Konstanten.................... 111 3.7 Aufzählungstyp.................................. 112 3.8 Escape-Sequenzen............................... 114 3.9 Anweisungen.................................... 116 3.9.1 Whitespaces.............................. 116 3.9.2 Leeranweisungen.......................... 118 3.9.3 Verbundanweisung und Blöcke.............. 119 3.9.4 Ausdrücke............................... 120 3.10 Operatoren..................................... 121 3.10.1 Zuweisungsoperator........................ 122 3.10.2 Mathematische Operatoren................. 122 3.10.3 Modulo, der Restwertoperator................ 126 3.10.4 Inkrement- und Dekrement-Operatoren........ 127 3.10.5 Zusammengesetzte Operatoren.............. 130 3.10.6 Rangfolge und Klammern................... 132 3.10.7 Vergleichsoperatoren....................... 136 3.10.8 Logische Operatoren....................... 145 3.10.9 Bedingungsoperator........................ 149 3.11 Zusammenfassung............................... 150 3.12 Fragen und Antworten............................ 151 3.13 Workshop....................................... 152 3.13.1 Quiz.................................... 153 3.13.2 Übungen................................ 154 Tag 4 Ein-/Ausgabe und Strings.............................. 155 4.1 Strings und die Ein-/Ausgabe....................... 156 4.2 Formatieren mit Escape-Sequenzen.................. 159 4.3 Zahlen formatieren............................... 161 4.3.1 Standardformatierung von Zahlen............ 161 4.3.2 Formatieren von Gleitkommazahlen.......... 162 4.3.3 Währungsformat.......................... 163 4.3.4 Spezielle Formatierungen................... 164 7

4.4 Benutzerdefinierte Formatierung.................... 165 4.4.1 0-Formatierung........................... 166 4.4.2 Kreuz-Formatierung....................... 166 4.4.3 Formatieren von Gruppen.................. 167 4.4.4 Prozent-Formatierung...................... 169 4.4.5 Literale Formatierung...................... 169 4.4.6 Fall-Formatierung......................... 170 4.5 Datums- und Zeitwerte formatieren.................. 171 4.5.1 Datumsformatierung....................... 172 4.5.2 Zeitformatierung.......................... 174 4.5.3 Datums- und Zeitformatierung............... 174 4.5.4 Ausgabe von Aufzählungen.................. 176 4.6 Methoden der Klasse String........................ 178 4.6.1 Vergleichen von Strings.................... 178 4.6.2 Einfügen, Löschen und Ersetzen............. 182 4.6.3 Vorbereiten von Strings..................... 183 4.6.4 Länge eines Strings........................ 185 4.7 Zusammenfassung............................... 185 4.8 Fragen und Antworten............................ 186 4.9 Workshop....................................... 186 4.9.1 Quiz.................................... 186 4.9.2 Übungen................................ 187 Tag 5 Ablaufsteuerung...................................... 189 5.1 Verzweigungen.................................. 190 5.1.1 if-anweisung Review...................... 190 5.1.2 if-else-statement Review................... 192 5.1.3 switch-anweisung......................... 195 5.2 Schleifen....................................... 199 5.2.1 Der Urvater der Schleifen goto Anweisung.... 200 5.2.2 while-schleife............................ 201 5.2.3 do-while-schleife.......................... 204 5.2.4 for-schleife............................... 206 5.2.5 foreach-schleife........................... 210 5.3 Sprunganweisungen.............................. 210 5.3.1 break-anweisung.......................... 211 5.3.2 continue-anweisung....................... 212 5.4 Zusammenfassung............................... 213 8

5.5 Fragen und Antworten............................ 214 5.6 Workshop....................................... 214 5.6.1 Quiz.................................... 214 5.6.2 Übungen................................ 215 Tag 6 Methoden, Parameter und Gültigkeit von Variablen........ 217 6.1 Definition und Aufruf............................. 218 6.2 Parameter einer Methode.......................... 221 6.2.1 Parameter definieren....................... 221 6.2.2 Arten von Parametern...................... 223 6.2.3 Variable Parameterlisten.................... 227 6.3 Gültigkeitsbereich von Variablen.................... 232 6.3.1 Lokale Datenobjekte....................... 232 6.3.2 Globale Datenobjekte...................... 234 6.3.3 Global, lokal hinter den Kulissen............ 235 6.4 Rekursive Methoden.............................. 238 6.5 Überladen von statischen Methoden................. 242 6.6 Zusammenfassung............................... 246 6.7 Fragen und Antworten............................ 247 6.8 Workshop....................................... 247 6.8.1 Quiz.................................... 247 6.8.2 Übungen................................ 248 Tag 7 Arrays............................................... 251 7.1 Datenverwaltung mit Arrays........................ 252 7.1.1 Arrays definieren.......................... 253 7.1.2 Auf Array-Elemente zugreifen................ 254 7.1.3 Arrays initialisieren........................ 255 7.1.4 Arrays in Schleifen durchlaufen.............. 255 7.2 Array-Programmierung leicht gemacht............... 258 7.2.1 Arrays von Objekten....................... 258 7.2.2 Array-Länge bestimmen..................... 259 7.2.3 Arrayteile löschen......................... 261 7.2.4 Arrays kopieren........................... 261 7.2.5 Arrays sortieren........................... 263 7.2.6 Arrays als Parameter........................ 267 7.3 Zusammengesetzte Arrays......................... 267 7.3.1 Mehrdimensionale Arrays................... 267 7.3.2 Arrays aus Arrays.......................... 271 9

7.4 Zusammenfassung............................... 274 7.5 Fragen und Antworten............................ 275 7.6 Workshop....................................... 275 7.6.1 Quiz.................................... 276 7.6.2 Übungen................................ 276 Woche 1 im Rückblick................................. 276 Wochenvorschau..................................... 283 Tag 8 Grundkurs OOP I. Die Klasse......................... 287 8.1 Klassen und objektorientierte Programmierung (OOP).. 289 8.1.1 Der Grundgedanke der objektorientierten Programmierung.......................... 289 8.1.2 Objekte und Klassen....................... 293 8.1.3 Beispiel.................................. 295 8.1.4 Vorteile der objektorientierten Programmierung. 299 8.2 Eigene Klassen.................................. 300 8.2.1 Klassen definieren......................... 301 8.2.2 Felder.................................. 302 8.2.3 Methoden............................... 303 8.2.4 Der Konstruktor.......................... 306 8.2.5 Zugriffsspezifizierer........................ 307 8.2.6 Instanzbildung............................ 312 8.2.7 Mit Objekten programmieren................ 313 8.3 Wert- und Referenztypen.......................... 318 8.3.1 Was passiert bei der Instanzbildung?.......... 318 8.3.2 Wert- und Referenztypen................... 319 8.3.3 Heap und Stack........................... 321 8.3.4 Warum Referenzen?....................... 322 8.3.5 Boxing.................................. 323 8.4 Klassen-Design.................................. 325 8.4.1 Was ist eine»gute«klasse?................. 325 8.4.2 Nicht verzweifeln!......................... 326 8.4.3 Auswahl der Klassenelemente................ 327 8.4.4 Einsatz des Konstruktors.................... 328 8.4.5 Zugriffsrechte und öffentliche Schnittstelle..... 329 8.4.6 Klassen als Funktionensammlungen........... 334 8.4.7 Klassen versus Strukturen................... 334 10

8.5 Alles Klasse..................................... 336 8.6 Zusammenfassung............................... 337 8.7 Fragen und Antworten............................ 338 8.8 Workshop....................................... 339 8.8.1 Quiz.................................... 339 8.8.2 Übungen................................ 340 Tag 9 Grundkurs OOP II. Die einzelnen Klassenelemente....................... 341 9.1 Felder.......................................... 343 9.1.1 Initialisierung............................. 343 9.1.2 Objektvariablen als Felder................... 344 9.1.3 Konstante Felder.......................... 345 9.1.4 Statische Felder........................... 346 9.1.5 Variablenterminologie...................... 348 9.2 Methoden...................................... 349 9.2.1 this..................................... 349 9.2.2 Statische Methoden........................ 353 9.3 Eigenschaften................................... 356 9.4 Der Konstruktor................................. 362 9.4.1 Klassen ohne selbst definierten Konstruktor..... 362 9.4.2 Der Standardkonstruktor.................... 365 9.4.3 Überladene Konstruktoren.................. 368 9.5 Destruktoren.................................... 371 9.6 Typdefinitionen.................................. 375 9.7 Indexer......................................... 377 9.8 Delegaten...................................... 381 9.8.1 Delegaten einrichten....................... 382 9.8.2 Methoden mit Delegaten verbinden........... 384 9.9 Ereignisse...................................... 386 9.9.1 Problembeschreibung...................... 386 9.9.2 Ereignisse veröffentlichen................... 387 9.9.3 Ereignisse abonnieren...................... 390 9.10 Zusammenfassung............................... 393 9.11 Fragen und Antworten............................ 394 9.12 Workshop....................................... 395 9.12.1 Quiz.................................... 396 9.12.2 Übungen................................ 396 11

Tag 10 Vererbung........................................... 399 10.1 Das Prinzip der Vererbung......................... 401 10.1.1 Der grundlegende Mechanismus............. 401 10.1.2 Der Sinn der Vererbung.................... 403 10.1.3 Einige wichtige Fakten..................... 404 10.2 Wie greift man auf geerbte Elemente zu?............. 405 10.2.1 Geerbte Elemente bilden Unterobjekte........ 406 10.2.2 Drei Zugriffsebenen....................... 408 10.3 Wie initialisiert man geerbte Elemente?.............. 415 10.3.1 Konstruktor und Basisklassenkonstruktor....... 415 10.3.2 Expliziter Aufruf eines Basisklassenkonstruktors.. 419 10.4 Überladen und verdecken.......................... 422 10.4.1 Überladung.............................. 422 10.4.2 Verdeckung.............................. 423 10.5 Vererbung kennt weder Programm- noch Sprachgrenzen 430 10.5.1 Ableitung von Bibliotheksklassen............. 430 10.5.2 Ableitung von Visual Basic.NET-Klassen...... 438 10.6 Vererbung und objektorientiertes Design............. 441 10.6.1 Wann ist Vererbung gerechtfertigt?........... 441 10.6.2 Vererbung versus Einbettung................ 443 10.6.3 Verschachtelte Klassen..................... 444 10.6.4 Klassenhierarchien........................ 445 10.6.5 Es gibt eine oberste Basisklasse: System.Object.. 446 10.7 Zusammenfassung............................... 447 10.8 Fragen und Antworten............................ 448 10.9 Workshop....................................... 449 10.9.1 Quiz.................................... 449 10.9.2 Übungen................................ 450 Tag 11 Polymorphie und Schnittstellen......................... 453 11.1 Was bedeutet Polymorphie?........................ 454 11.2 Polymorphie basiert auf Überschreibung.............. 458 11.2.1 Methoden überschreiben................... 459 11.2.2 Statische und dynamische Bindung........... 461 11.2.3 Regeln für die Überschreibung............... 464 11.2.4 Überladen, verdecken und überschreiben...... 465 11.3 Abstrakte Klassen................................. 466 12

11.4 Basisklassen-Arrays............................... 468 11.5 Basisklassenparameter............................. 471 11.6 Typidentifizierung zur Laufzeit (RTTI).............. 474 11.6.1 Typidentifizierung für Objekte............... 477 11.6.2 Typidentifizierung für Klassen............... 478 11.7 Schnittstellen (Interfaces).......................... 480 11.7.1 Was sind Schnittstellen?.................... 481 11.7.2 Schnittstellen definieren.................... 484 11.7.3 Schnittstellen implementieren............... 485 11.7.4 Schnittstellenmethoden aufrufen............. 487 11.7.5 Mehrere Schnittstellen implementieren....... 490 11.8 Zusammenfassung............................... 494 11.9 Fragen und Antworten............................ 495 11.10 Workshop....................................... 496 11.10.1 Quiz.................................... 496 11.10.2 Übungen................................ 496 Tag 12 Nützliche.NET-Klassen............................... 499 12.1 Objekte kopieren................................. 500 12.1.1 Flaches Kopieren mit MemberwiseClone()..... 503 12.1.2 Tiefes Kopieren (und ICloneable)............ 508 12.2 Objekte vergleichen.............................. 512 12.2.1 Gleichheit feststellen...................... 512 12.2.2 Größenvergleiche......................... 520 12.3 Objekte ausgeben................................ 523 12.4 Objekte mit Operatoren bearbeiten.................. 524 12.4.1 Binäre Operatoren überladen................ 525 12.4.2 Unäre Operatoren überladen................ 525 12.4.3 Nicht überladbare Operatoren............... 528 12.5 Datum und Uhrzeit.............................. 529 12.5.1 Datum und Uhrzeit ermitteln................ 529 12.5.2 Datums- und Zeitangaben manipulieren....... 530 12.5.3 Datums- und Zeitangaben ausgeben.......... 531 12.5.4 Zeitspannen messen....................... 533 12.6 Zeitgeber....................................... 534 12.7 Zufallszahlen.................................... 536 13

12.8 Die Auflistungsklassen (Container).................. 538 12.8.1 Historisches.............................. 539 12.8.2 Die Auflistungen im Vergleich............... 539 12.8.3 ArrayList................................. 541 12.8.4 List<T>................................. 543 12.8.5 Dictionary<TKey, TValue>................. 546 12.8.6 Stack<T>................................ 547 12.9 Streams........................................ 549 12.10 Textdateien..................................... 550 12.10.1 In Textdateien schreiben.................... 551 12.10.2 Aus Textdateien lesen...................... 554 12.11 Binärdateien.................................... 558 12.11.1 In Binärdateien schreiben................... 563 12.11.2 Aus Binärdateien lesen..................... 565 12.12 Zusammenfassung............................... 567 12.13 Fragen und Antworten............................ 567 12.14 Workshop....................................... 569 12.14.1 Quiz.................................... 569 12.14.2 Übungen................................ 570 Tag 13 GUI-Programmierung: Fenster und Steuerelemente........ 573 13.1 Die erste GUI-Anwendung......................... 574 13.1.1 Ein einfaches Codegerüst................... 575 13.1.2 Kompilierung von GUI-Anwendungen........ 577 13.1.3 Windows, Fenster und Hauptfenster.......... 578 13.2 Das Fenster konfigurieren.......................... 579 13.2.1 Größe und Position........................ 580 13.2.2 Titelleiste................................ 580 13.2.3 Rahmen und Funktionalität................. 581 13.2.4 Farben und Hintergrundbilder............... 582 13.3 Auf Ereignisse reagieren........................... 586 13.3.1 Die Message Loop......................... 586 13.3.2 Meldungen und Ereignisbehandlung.......... 587 13.3.3 Mausklicke im Fenster abfangen............. 588 13.4 Das Fenster mit Steuerelementen bestücken........... 592 13.4.1 Programmieren mit Steuerelementen......... 592 13.4.2 Textfelder................................ 593 14

13.4.3 Schaltflächen............................. 596 13.4.4 Weitere Steuerelemente.................... 599 13.5 GUI-Anwendungen mit Visual C#................... 602 13.5.1 Projekte für GUI-Anwendungen.............. 603 13.5.2 Das Codegerüst........................... 603 13.5.3 Oberflächenerstellung im Windows Forms-Designer........................... 607 13.6 Zusammenfassung............................... 612 13.7 Fragen und Antworten............................ 612 13.8 Workshop....................................... 613 13.8.1 Quiz.................................... 613 13.8.2 Übungen................................ 613 Tag 14 GUI-Programmierung: Menüs, Dialoge, Grafik............ 615 14.1 Grafik......................................... 616 14.1.1 Grafik-Grundlagen........................ 616 14.1.2 Text ausgeben............................ 618 14.1.3 Zeichnen................................ 621 14.2 Menüs......................................... 623 14.2.1 Eigene Menüs aufbauen.................... 623 14.2.2 Menübefehle konfigurieren................. 628 14.2.3 Beenden-Befehle.......................... 629 14.2.4 Menüs mit Visual C#...................... 629 14.3 Dialogfenster.................................... 630 14.3.1 Dialogfenster einrichten.................... 630 14.3.2 Dialogfenster anzeigen..................... 634 14.3.3 Vordefinierte Dialoge...................... 637 14.4 Zusammenfassung............................... 640 14.5 Fragen und Antworten............................ 640 14.6 Workshop....................................... 641 14.6.1 Quiz.................................... 641 14.6.2 Übungen................................ 642 Woche 2 im Rückblick................................. 642 Wochenvorschau..................................... 657 Tag 15 Ausnahmebehandlung................................. 659 15.1 Einfache Fehlerbehandlung........................ 660 15.2 Ausnahmen abfangen mit try und catch............... 662 15

15.3 Mit Fehlerinformationen arbeiten................... 664 15.4 1 catch, 2 catch,.................................. 666 15.4.1 try-catch-finally........................... 668 15.4.2 Lokal, Global try-catch-finally.............. 671 15.5 Eigene Ausnahmen auslösen....................... 674 15.5.1 Eigene Exception-Klasse definieren........... 676 Tag 16 Attribute............................................ 681 16.1 Einführung..................................... 682 16.2 Benutzerdefinierte Attribute verwenden............... 684 16.3 Benutzerdefinierte Attribute erstellen................. 685 16.4 Benutzerdefinierte Attribute anwenden............... 687 16.5 Benutzerdefinierte Attribute ausgeben................ 688 Tag 17 Von der Klasse zur Komponente......................... 691 17.1 Eine einfache Komponente erstellen................. 692 17.1.1 Erste Schritte............................. 692 17.1.2 Eine Methode einbinden................... 695 17.1.3 Eine Eigenschaft einbinden................. 697 17.1.4 Weiteren Code hinzufügen.................. 699 17.1.5 Erstellen der Komponente.................. 702 17.2 Der Client Das Testprogramm.................... 702 17.2.1 Das Konsolenprogramm.................... 703 17.2.2 Referenzieren............................. 705 17.2.3 Der Client-Code.......................... 706 Tag 18 Einführung in die Thread-Programmierung............... 711 18.1 Der Prozess..................................... 712 18.2 Multitasking.................................... 713 18.2.1 Multithreading............................ 713 18.2.2 Singlethread und Multithread................ 713 18.3 Thread-Programmierung.......................... 714 18.3.1 Multithreading mit Thread.Sleep............. 716 Tag 19 XML Web Services in.net............................ 721 19.1 Vorbereitungen.................................. 722 19.1.1 Läuft der IIS?............................. 722 19.1.2 Laufen ASP.NET-Anwendungen?............ 724 19.2 XML veni, vidi, vici............................. 727 16

19.3 SOAP Simple Object Access Protocol............... 730 19.4 Hello Webservice................................ 731 19.4.1 Erstellen eines Webservice.................. 732 19.4.2 Implementieren eines Webservice............ 736 19.4.3 Verwenden eines Webservice................ 740 Tag 20 Testen und Debuggen................................. 745 20.1 Grundlagen des Debuggens........................ 746 20.2 Debug, Trace und die defensive Programmierung...... 750 20.2.1 Bedingte Methoden........................ 751 20.2.2 Assert-Anweisung.......................... 753 20.3 Direktiven und die defensive Programmierung......... 756 20.3.1 Codesteuerung mit #define, #undef und #if, #endif................................ 756 20.3.2 #warning- und #line-direktive und der Vorteil von Direktiven............................ 760 20.3.3 #region #endregion....................... 765 20.4 Der Visual C#-Debugger.......................... 766 20.4.1 Vorbereitung des Programms für das Debuggen. 767 20.4.2 Programm in Debugger laden und starten...... 768 20.4.3 Programm anhalten....................... 768 20.4.4 Programm schrittweise ausführen............. 769 20.4.5 Die Debug-Fenster........................ 770 20.4.6 Weitere Debug-Möglichkeiten............... 772 Tag 21 Vermischtes.......................................... 775 21.1 Ausführung der Beispielprogramme.................. 776 21.1.1 Programmerstellung mit dem csc-compiler..... 776 21.1.2 Programmerstellung mit Visual C#........... 779 21.2 Programme aus mehreren Dateien.................. 781 21.2.1 Wie verteilt man Code auf mehrere Dateien?... 781 21.2.2 Wie kompiliert man Programme aus mehreren Dateien?................................. 782 21.3 Namensräume.................................. 782 21.3.1 Übersicht................................ 782 21.4 CSC-Compileroptionen.......................... 789 21.4.1 Syntax und Regeln des C#-Compilers in der Befehlszeile.............................. 790 17

21.4.2 Compileroptionen nach Kategorie sortiert...... 790 21.4.3 Compilerfehler CS0001 bis CS9999.......... 794 21.5 Lösungen zu den Übungen........................ 794 21.5.1 Tag 1................................... 794 21.5.2 Tag 2................................... 795 21.5.3 Tag 3................................... 797 21.5.4 Tag 4................................... 801 21.5.5 Tag 5................................... 803 21.5.6 Tag 6................................... 805 21.5.7 Tag 7................................... 808 21.5.8 Tag 8................................... 812 21.5.9 Tag 9................................... 816 21.5.10 Tag 10.................................. 822 21.5.11 Tag 11.................................. 828 21.5.12 Tag 12.................................. 834 21.5.13 Tag 13.................................. 844 21.5.14 Tag 14.................................. 850 21.6 Unicode-Zeichen................................ 854 21.7 Glossar......................................... 857 Stichwortverzeichnis.................................. 867 18

Tag 1 Erste Schritte in C# 21 Tag 2 Die Visual C#-Umgebung 51 Tag 3 Variablen und Operatoren 79 Tag 4 Ein-/Ausgabe und Strings 155 Tag 5 Ablaufsteuerung 189 Tag 6 Methoden, Parameter und Gültigkeit von Variablen 217 Tag 7 Arrays 251 Tag 8 Grundkurs OOP I. Die Klasse 287 Tag 9 Grundkurs OOP II. Die einzelnen Klassenelemente 341 Tag 10 Vererbung 399 Tag 11 Polymorphie und Schnittstellen 453 Tag 12 Nützliche.NET-Klassen 499 Tag 13 GUI-Programmierung: Fenster und Steuerelemente 573 Tag 14 GUI-Programmierung: Menüs, Dialoge, Grafik 615 Tag 15 Ausnahmebehandlung 659 Tag 16 Attribute 681 Tag 17 Von der Klasse zur Komponente 691 Tag 18 Einführung in die Thread-Programmierung 711 Tag 19 XML Web Services in.net 721 Tag 20 Testen und Debuggen 745 Tag 21 Vermischtes 775 W O C H E W O C H E W O C H E Wochenvorschau

Vorschau auf die erste Woche Willkommen 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# läuft. Der erste Tag beschäftigt sich mit dieser Umgebung, dem.net Framework. Sie lernen, wie Sie Programme in dieser Umgebung kompilieren und ausführen, 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 Schlüsselwörter. 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, Währung usw. beeinflusst werden kann. Der fünfte Tag hat die Ablaufsteuerung zum Thema. Hier lernen Sie, wie man den Programmfluss steuert und Anweisungen mehrfach ausführt. 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 löscht, sortiert und ändert. 20