.NET Windows Forms in 21 Tagen . Oberflächen programmieren

Chris Paynebersetzung: Michael Matzer

.NET Windows FormsI I I

ent Oberflchen objektorientiert programmieren berfl hen ob rf ADO.NET, ActiveX, Multithreading, Web Services nbi lio ken enl enn Klassenbibliothek des .NET Framework kennenlernen

Markt + Technik Verlag

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. Authorisierte bersetzung der amerikanischen Originalausgabe: Teach Yourself .NET Windows Forms in 21 Days 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 Software-Bezeichnungen, die in diesem Buch erwhnt werden, sind gleichzeitig auch eingetragene Marken oder sollten als solche betrachtet werden. Authorized translation from the English language edition, entiteled SAMS TEACH YOURSELF .NET Windows Forms in 21 DAYS by Chris Payne, published by Pearson Education, Inc. publishing as Sams Publishing, Copyright 2002 All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronis or mechanical, including photocopying, recording or by any Information storage retrieval system, without permisson from Pearson Education, Inc. German language edition published by PEARSON EDUCATION DEUTSCHLAND, Copyright 2002 Umwelthinweis: Dieses Buch wurde auf chlorfrei gebleichtem Papier gedruckt.

10 9 8 7 6 5 4 3 2 1 05 04 03

ISBN 3-8272-6455-3

2003 by Markt+Technik Verlag, ein Imprint der Pearson Education Deutschland GmbH, Martin-Kollar-Strae 1012, D81829 Mnchen/Germany Alle Rechte vorbehalten bersetzung: Michael Matzer, Waldenbruch Lektorat: Rainer fuchs, [email protected] Fachlektorat: Frank Langenau, Chemnitz Herstellung: Philipp Burkart, [email protected] Satz: reemers publishing services gmbh, Krefeld, (www.reemers.de) Einbandgestaltung: Grafikdesign Heinz H. Rauner, Gmund Druck und Verarbeitung: Bercker, Kevelaer Printed in Germany

InhaltsverzeichnisEinleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wer dieses Buch lesen sollte . . . . . . . . . . . . . . . . . . . . . . . . . . . . Vorkenntnisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Software fr die Beispiele. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wie dieses Buch aufgebaut ist . . . . . . . . . . . . . . . . . . . . . . . . . . . Programmcode auf Begleit-CD und US-Website . . . . . . . . . . . . Konventionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Und zu guter Letzt... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 17 18 18 19 20 21 21 23 25 26 27 28 29 30 32 33 34 35 36 37 38 39 41 42 42 42 43 45 46 47

Woche 1 Vorschau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .Tag 1 Mit Windows Forms beginnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.1 Einfhrung in die Windows-Programmierung . . . . . . . . . . . . . . Programmiersprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Win32-Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2 Was ist .NET?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .NET-Kompilierung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Common Language Runtime (CLR). . . . . . . . . . . . . . . . . . Das .NET Framework installieren. . . . . . . . . . . . . . . . . . . . . . . . Entwicklungsumgebungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.3 Was ist .NET Windows Forms? . . . . . . . . . . . . . . . . . . . . . . . . . . Integration mit .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Windows Forms-Steuerelemente. . . . . . . . . . . . . . . . . . . . . . . . . 1.4 Die objektorientierte Vorgehensweise . . . . . . . . . . . . . . . . . . . . . 1.5 So erstellen Sie Ihre erste Anwendung . . . . . . . . . . . . . . . . . . . . 1.6 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.7 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.8 Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . bung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Windows Forms-Anwendungen erstellen . . . . . . . . . . . . . . . . . . . . . . . 2.1 Ein weiterer Blick auf Ihre Anwendung . . . . . . . . . . . . . . . . . . . Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Tag 2

5

Inhaltsverzeichnis

2.2 2.3 2.4 2.5 2.6

Namensrume und Assemblies . . . . . . . . . . . . . . . . . . . . . . . . . . Die Main-Methode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Konstruktoren und Destruktoren. . . . . . . . . . . . . . . . . . . . . . . . . Ein abschlieender Blick auf den Programmcode . . . . . . . . . . . Das Kompilieren von Windows Forms . . . . . . . . . . . . . . . . . . . . Eine vollstndige Anwendung . . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . bung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das objektorientierte Windows-Formular . . . . . . . . . . . . . . . . . . Mit dem Objekt Object arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . Formular-Eigenschaften . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Formular-Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ereignisbehandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Nachrichtenschleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Form-Ereignisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . bungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einfhrung in Windows Forms-Steuerelemente . . . . . . . . . . . . Mens hinzufgen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mens anpassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kontextmens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Symbolleisten, Statusleisten und Bildlaufleisten hinzufgen. . . Symbolleisten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Statusleisten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Bildlaufleisten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . bung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

49 54 58 62 63 67 74 74 75 75 75 77 78 79 82 92 94 94 97 106 107 108 108 109 111 112 114 120 122 125 126 133 136 146 147 148 148 148

Tag 3

Mit Windows Forms arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1

3.2

3.3 3.4 3.5

Tag 4

Mens und Symbolleisten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.1 4.2

4.3

4.4 4.5 4.6

6

Inhaltsverzeichnis

Tag 5

Ereignisse in Windows Forms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1 Was sind Ereignishandler? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ereignisse behandeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mehrfache Ereignisse behandeln . . . . . . . . . . . . . . . . . . . . . . . . 5.2 Delegaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3 Ereignisse und Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ereignishandler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Benutzerdefinierte Ereignisse erstellen . . . . . . . . . . . . . . . . . . . . Steuerelemente sezieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Benutzerdefinierte Delegaten erstellen . . . . . . . . . . . . . . . . . . . . 5.4 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.5 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.6 Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . bung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Windows Forms mit Steuerelementen erweitern . . . . . . . . . . . . . . . . . 6.1 Das Steuerelement Button. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.2 Die Steuerelemente CheckBox und RadioButton . . . . . . . . . . . 6.3 Das Steuerelement ComboBox . . . . . . . . . . . . . . . . . . . . . . . . . . Das Kombinationsfeld instantiieren . . . . . . . . . . . . . . . . . . . . . . Die Anzeige des Steuerelements steuern . . . . . . . . . . . . . . . . . . Die ComboBox verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.4 Das Steuerelement DateTimePicker. . . . . . . . . . . . . . . . . . . . . . 6.5 Das Steuerelement ImageList . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.6 Das Steuerelement ListBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.7 Das Steuerelement PictureBox . . . . . . . . . . . . . . . . . . . . . . . . . . 6.8 Das Steuerelement TabControl . . . . . . . . . . . . . . . . . . . . . . . . . . 6.9 Die Steuerelemente TextBox und RichTextBox . . . . . . . . . . . . . Rich Text . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.10 Das Steuerelement Timer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.11 Das Steuerelement TreeView . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.12 Zustzliche ntzliche Steuerelemente . . . . . . . . . . . . . . . . . . . . 6.13 Das Layout steuern. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.14 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.15 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.16 Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . bung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

151 152 153 156 158 162 162 163 168 169 173 173 174 174 175 177 179 180 183 184 186 187 189 193 195 199 200 206 208 215 218 221 222 228 229 230 230 230

Tag 6

7

Inhaltsverzeichnis

Tag 7

Mit Dialogfeldern arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.1 Informationen holen und anzeigen . . . . . . . . . . . . . . . . . . . . . . . 7.2 Unterschiedliche Arten von Dialogen. . . . . . . . . . . . . . . . . . . . . Modal vs. nichtmodal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Standarddialogfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.3 Dialogfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eigene Dialogfelder erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . Informationen abrufen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.4 Standarddialogfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ein- und Ausgabe von Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . Farben und Schriftarten whlen . . . . . . . . . . . . . . . . . . . . . . . . . Drucken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.5 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.6 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.7 Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . bung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

231 232 234 234 235 235 238 244 248 248 250 253 257 258 259 259 260 261 261 261 262 262 274 279 281 282 283 284 285 287 290 290 293 296 306 307

Woche 1 Rckblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .Projekt 1: Eine Textverarbeitung erstellen. . . . . . . . . . . . . . . . . . ber das Textverarbeitungsprojekt. . . . . . . . . . . . . . . . . . . . . . . . Was Sie bentigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Benutzeroberflche aufbauen. . . . . . . . . . . . . . . . . . . . . . . . Einige ntzliche Dinge mit Pfiff hinzufgen . . . . . . . . . . . . . . .

Woche 2 Vorschau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .Tag 8 Datenbindung in Windows Forms . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.1 8.2 Einfhrung in die Datenbindung . . . . . . . . . . . . . . . . . . . . . . . . Daten aus jeder beliebigen Quelle . . . . . . . . . . . . . . . . . . . . . . . Einfache Datenbindung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine Schaltflche mit Daten verbinden . . . . . . . . . . . . . . . . . . . Das Bearbeiten gebundener Daten . . . . . . . . . . . . . . . . . . . . . . . Formulare mit Daten verbinden . . . . . . . . . . . . . . . . . . . . . . . . . Das Steuerelement DataGrid . . . . . . . . . . . . . . . . . . . . . . . . . . . Ein kurzer Blick auf ADO.NET . . . . . . . . . . . . . . . . . . . . . . . . . Die Interaktion mit einem DataGrid . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

8.3

8.4 8.5

8

Inhaltsverzeichnis

8.6

Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . bung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Was ist ADO.NET? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ADO.NET gegenber ADO . . . . . . . . . . . . . . . . . . . . . . . . . . . . ADO.NET und XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine Datenbank anlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine Access-Datenbank . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine Datenbank in SQL Server 2000 anlegen . . . . . . . . . . . . . . SQL fr die Datenbankabfrage . . . . . . . . . . . . . . . . . . . . . . . . . . Das SELECT-Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das INSERT-Statement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das UPDATE-Statement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das DELETE-Statement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einfhrung in DataSet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Objektmodell von ADO.NET . . . . . . . . . . . . . . . . . . . . . . . Verbindung zur Datenbank aufnehmen und Daten abrufen. . . Daten bearbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Andere ADO.NET-Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Parametrisierte Abfragen und gespeicherte Prozeduren . . . . . . . Das Objekt DataView . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XML im Zusammenhang mit ADO.NET . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . bung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

307 307 308 309 310 311 313 314 314 317 319 319 322 322 323 323 325 326 329 334 338 341 342 345 346 347 347 348 349 350 352 353 361 362 362 365 367 372

Tag 9

ADO.NET einsetzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.1

9.2

9.3

9.4 9.5

9.6

9.7 9.8 9.9 9.10

Tag 10

MDI-Anwendungen erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.1 Einfhrung in die Mehrfachdokumentschnittstelle . . . . . . . . . . MDI-Mens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.2 Eine MDI-Anwendung erstellen . . . . . . . . . . . . . . . . . . . . . . . . . Verschiedene Arten von untergeordneten Fenstern erstellen. . . 10.3 Die Besonderheiten von MDI-Formularen steuern . . . . . . . . . . Mens. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Untergeordnete Fenster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Auf untergeordnete Steuerelemente zugreifen . . . . . . . . . . . . . . 10.4 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

9

Inhaltsverzeichnis

10.5 10.6

Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . bung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einfhrung in Streams. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Dateien und Verzeichnisse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Dateien lesen und schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . Binrdaten lesen und schreiben . . . . . . . . . . . . . . . . . . . . . . . . . Serialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Steuerelement RichTextBox . . . . . . . . . . . . . . . . . . . . . . . . Das Objekt FileSystemWatcher. . . . . . . . . . . . . . . . . . . . . . . . . . Asynchrone Ein-/Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Drucken unter .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . bung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Internetprotokolle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Austauschbare Protokolle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Clients und Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Anforderungen mit WebRequest senden . . . . . . . . . . . . . . . . . . Anfragen mit WebResponse verarbeiten . . . . . . . . . . . . . . . . . . . Protokollspezifische Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . Arbeiten mit dem Internet Explorer . . . . . . . . . . . . . . . . . . . . . . Windows Forms-Steuerelemente in den Internet Explorer einbetten . . . . . . . . . . . . . . . . . . . . . . . . . Internetsicherheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Authentifizierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Berechtigungsklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . bung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

373 374 374 375 377 378 380 388 393 396 400 402 405 406 411 412 413 413 413 415 416 418 419 419 427 428 430 430 433 433 434 435 436 436 436 437

Tag 11

Arbeiten mit der Windows-Ein-/Ausgabe . . . . . . . . . . . . . . . . . . . . . . . 11.1 11.2

11.3 11.4 11.5 11.6 11.7 11.8

Tag 12

Formulare Internet-fhig machen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.1 12.2

12.3

12.4

12.5 12.6 12.7

10

Inhaltsverzeichnis

Tag 13

Grafische Anwendungen mit GDI+ . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.1 Einfhrung in die Grafik und Bildbearbeitung unter Windows Pinsel und Stifte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Rechtecke und Bereiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.2 Das Ereignis Paint . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.3 Text zeichnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4 Grafiken anzeigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.5 Figuren zeichnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Figuren ausfllen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Figuren dauerhaft machen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Figuren umwandeln. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.6 Windows Forms beschneiden . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.7 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.8 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.9 Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . bung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ActiveX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.1 Einfhrung in ActiveX. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.2 ActiveX-Steuerelemente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das ActiveX-Steuerelement Webbrowser . . . . . . . . . . . . . . . . . . Die Typbibliotheken von Microsoft Office . . . . . . . . . . . . . . . . . 14.3 .NET-ActiveX-Steuerelemente erstellen . . . . . . . . . . . . . . . . . . . 14.4 Richtlinien fr das Arbeiten mit ActiveX. . . . . . . . . . . . . . . . . . . 14.5 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.6 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.7 Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . bung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

439 440 442 442 443 446 450 454 460 468 470 471 473 474 475 475 475 477 478 480 482 485 499 500 502 502 503 503 504 505 505 505 507 511

Tag 14

Woche 2 Rckblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .Projekt 2: Die Textverarbeitung erweitern. . . . . . . . . . . . . . . . . . MDI hinzufgen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . E/A hinzufgen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Druckfunktionen hinzufgen . . . . . . . . . . . . . . . . . . . . . . . . . . .

11

Inhaltsverzeichnis

Woche 3 Vorschau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .Tag 15 Webdienste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15.1 Was sind Webdienste? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Simple Object Access Protocol (SOAP). . . . . . . . . . . . . . . . Andere Protokolle fr Webdienste. . . . . . . . . . . . . . . . . . . . . . . . Mit ASP.NET Webdienste erstellen. . . . . . . . . . . . . . . . . . . . . . . Webmethoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Dienstbeschreibung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Webdienste unter ASP.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . Webdienste in Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . Webdienste suchen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Empfehlungen fr den Einsatz von Webdiensten. . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . bung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Was sind Windows-Dienste? . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einen Windows-Dienst erzeugen . . . . . . . . . . . . . . . . . . . . . . . . Dienste zum Zusammenspiel mit Windows bringen . . . . . . . . . Windows-Dienste starten und beenden. . . . . . . . . . . . . . . . . . . . Ihre Dienste berwachen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Schnittstellen fr Windows-Dienste . . . . . . . . . . . . . . . . . . . . . . In Protokolldateien schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . bung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Noch einmal: Mens und die Steuerelemente Listbox, ComboBox und TabControl . . . . . . . . . . . . . . . . . . . . . DrawMode festlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Steuerelemente ListBox und ComboBox erweitern . . . . . . Das Steuerelement TabControl erweitern . . . . . . . . . . . . . . . . .

513 515 516 519 520 520 523 524 526 526 534 535 536 537 538 538 538 539 540 542 549 552 553 555 560 562 563 564 564 564 565 566 568 570 578

15.2

15.3 15.4 15.5 15.6 15.7 15.8

Tag 16

Windows-Dienste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16.1 16.2 16.3

16.4 16.5 16.6 16.7 16.8

Tag 17

Fortgeschrittene Techniken fr Steuerelemente in Windows Forms . 17.1 17.2

12

Inhaltsverzeichnis

17.3 17.4 17.5 17.6

Mens: Eine Frage des Besitzes . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . bung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

581 586 587 588 588 588 589 590 591 592 594 599 605 609 610 611 613 617 618 618 619 619 621 622 626 627 628 635 645 652 653 654 654 654 655 656 659

Tag 18

Benutzerdefinierte Steuerelemente in Windows Forms . . . . . . . . . . . 18.1 Wozu benutzerdefinierte Steuerelemente erzeugen? . . . . . . . . . 18.2 Benutzerdefinierte Steuerelemente . . . . . . . . . . . . . . . . . . . . . . . Rekapitulation der Architektur fr Steuerelemente . . . . . . . . . . Eigenschaften, Methoden und Ereignisse. . . . . . . . . . . . . . . . . . Ihr Steuerelement zeichnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . Alles zusammensetzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18.3 Benutzerdefinierte Steuerelemente in Windows Forms . . . . . . . 18.4 Benutzerdefinierte Steuerelemente aus vorhandenen erzeugen Vorhandene Steuerelemente erweitern. . . . . . . . . . . . . . . . . . . . Benutzersteuerelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18.5 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18.6 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18.7 Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . bung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Multithreading-Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19.1 Einfhrung in Multithreading. . . . . . . . . . . . . . . . . . . . . . . . . . . Probleme mit Threading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Threading-Objekte verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . 19.2 Eine Multithreading-Anwendung erstellen . . . . . . . . . . . . . . . . . Threads miteinander synchronisieren . . . . . . . . . . . . . . . . . . . . . Threadpooling einsetzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19.3 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19.4 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19.5 Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . bung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Windows Forms konfigurieren und bereitstellen. . . . . . . . . . . . . . . . . 20.1 Einfhrung in die .NET-Konfiguration. . . . . . . . . . . . . . . . . . . . 20.2 So konfigurieren Sie Ihre Anwendungen . . . . . . . . . . . . . . . . . .

Tag 19

Tag 20

13

Inhaltsverzeichnis

20.3 20.4 20.5 20.6 20.7 20.8

Konfigurationsabschnitte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der Abschnitt . . . . . . . . . . . . . . . . . . . . . . . . . Der Abschnitt . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der Abschnitt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der Abschnitt . . . . . . . . . . . . . . . . . . . Konfigurationswerte abrufen . . . . . . . . . . . . . . . . . . . . . . . . . . . . Lokalisieren Sie Ihre Anwendung . . . . . . . . . . . . . . . . . . . . . . . . Eingabehilfen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der einfache Teil der Arbeit: Bereitstellung . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . bungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

660 662 664 665 666 667 669 676 677 678 679 680 680 680 681 682 689 690 694 696 702 703 704 704 704 705 705 705 722 723 724 809

Tag 21

Debugging und Profiling. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.1 Debuggen in Windows Forms . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.2 JIT-Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Werkzeug DbgClr. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Werkzeug CorDbg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.3 Profiling Ihrer Anwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.4 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.5 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.6 Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . bung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Woche 3 Rckblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .Projekt 3: Das Textprogramm vervollstndigen . . . . . . . . . . . . . . Eine Klasse fr eine neue Seite erzeugen . . . . . . . . . . . . . . . . . . Der weitere Weg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Anhang A. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A.1 Antworten auf die Quizfragen und bungen . . . . . . . . . . . . . . . Stichwortverzeichnis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

14

Inhaltsverzeichnis

Inhaltsverzeichnis der Begleit-CDBonuskapitel 1: Steuerelemente in Windows Forms. . . . . . . . . . . . . . 1.1 Die Klasse Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2 Die Steuerelemente Button, CheckBox und RadioButton. . . . . Das Steuerelement Button. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Steuerelement CheckBox. . . . . . . . . . . . . . . . . . . . . . . . . . . Das Steuerelement RadioButton . . . . . . . . . . . . . . . . . . . . . . . . . 1.3 Die Steuerelemente ComboBox, ListBox und CheckedListBox Das Steuerelement ComboBox . . . . . . . . . . . . . . . . . . . . . . . . . . Das Steuerelement ListBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Steuerelement CheckedListBox. . . . . . . . . . . . . . . . . . . . . . 1.4 Standarddialogfeld-Steuerelemente. . . . . . . . . . . . . . . . . . . . . . . Das Steuerelement ColorDialog . . . . . . . . . . . . . . . . . . . . . . . . . Dateidialogfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5 Mens. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ContextMenu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . MainMenu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . MenuItem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.6 Das Steuerelement DataGrid . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.7 DateTimePicker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.8 Bildlauffhige Steuerelemente . . . . . . . . . . . . . . . . . . . . . . . . . . DomainUpDown . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Form . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . NumericUpDown . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Panel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . PrintPreviewDialog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . PropertyGrid. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . TabPage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.9 ErrorProvider . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.10 GroupBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.11 Bildlaufleisten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . HScrollBar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . VScrollBar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.12 ImageList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.13 Label-Steuerelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.14 ListView . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.15 PictureBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 2 11 11 12 13 13 14 16 18 19 20 20 25 25 26 26 28 32 33 35 36 39 39 40 40 42 42 43 44 45 45 45 46 47 50

15

Inhaltsverzeichnis

1.16 1.17 1.18 1.19

1.20 1.21 1.22 1.23 1.24 1.25 1.26

PrintDocument . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . PrintPreviewControl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ProgressBar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Textfeld-Steuerelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . RichTextBox. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . TextBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Steuerelemente der Statusleiste. . . . . . . . . . . . . . . . . . . . . . . . . . TabControl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Timer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Steuerelemente der Symbolleiste . . . . . . . . . . . . . . . . . . . . . . . . ToolTip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . TrackBar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . TreeView-Steuerelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

50 51 52 53 55 57 58 59 61 61 63 64 65 71 72 72 73 75 77 79 81 85 86 87 88 88 90 92 93 94 96

Bonuskapitel 2: Steuerelemente in ADO.NET: Eigenschaften und Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1 Die DataSet- und verwandte Klassen . . . . . . . . . . . . . . . . . . . . . Constraint und ConstraintCollection . . . . . . . . . . . . . . . . . . . . . DataColumn und DataColumnCollection. . . . . . . . . . . . . . . . . 2.2 DataRelation und DataRelationCollection . . . . . . . . . . . . . . . . 2.3 DataRow und DataRowCollection . . . . . . . . . . . . . . . . . . . . . . . DataSet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . DataTable und DataTableCollection . . . . . . . . . . . . . . . . . . . . . DataView . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4 Verwaltete Provider . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . OleDbCommand. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . OleDBCommandBuilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . OleDbConnection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . OleDbDataAdapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . OleDbdataReader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . OleDbError und OleDbErrorCollection . . . . . . . . . . . . . . . . . . OleDbParameter und OleDbParameterCollection . . . . . . . . . . OleDbTransaction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

16

EinleitungWillkommen bei .NET Windows Forms in 21 Tagen! Dieses Buch wird Sie Schritt fr Schritt von den Grundlagen in Microsoft .NET Windows Forms zu recht fortgeschrittenen Themen fhren. Whrend der nchsten 21 Tage erwartet Sie ein sehr informatives und aufregendes Abenteuer. Die Windows Forms-Technologie ist Bestandteil der .NET-Initiative Microsofts. Sie erlaubt Ihnen auf sehr einfache Weise leistungsfhige Windows-Anwendungen zu erstellen, wobei Sie fast jede beliebige Programmiersprache verwenden knnen, die Sie kennen. Vom einfachen Taschenrechner bis hin zu Datenbank-gesttzten multithreaded Webdiensten knnen Sie praktisch alles erstellen (wenn Sie von Multithreading oder Datenbankzugriffen keine Ahnung haben, dann lesen Sie am besten weiter). Einfach ausgedrckt: Wenn Sie knftig Windows-Anwendungen entwickeln wollen, werden Sie Windows Forms benutzen. Whrend Sie sich durch die Lektionen dieses Buches arbeiten, werden Sie entdecken, auf welch einfache Art und Weise sich diese Aufgaben bewltigen lassen. Sie werden nicht nur Beispiele sehen und lernen, wie Sie diese und andere Anwendungen erzeugen, sondern werden auch ein Verstndnis dafr entwickeln, das Sie in die Lage versetzt, bei jedem knftigen Windows-Programmierprojekt, das Sie vielleicht anpacken wollen, zuversichtlich an dieses Unterfangen heranzugehen.

Wer dieses Buch lesen sollteEs ist der Zweck dieses Buches, Einsteiger in Sachen Windows Forms mit dieser leistungsfhigen Technologie vertraut zu machen. Einsteiger ist jedoch ein recht allgemeiner Begriff. Ganz konkret sollten Sie dieses Buch verwenden, wenn Sie lernen wollen, wie Sie Windows-Anwendungen in .NET erstellen knnen, ganz gleich, ob Sie bereits Erfahrung mit ihrer Erstellung in einer anderen Umgebung haben oder nicht. Da aber Microsofts Zukunft auf .NET fut, wird jeder Windows-Anwendungsentwickler frher oder spter auf Windows Forms umsteigen mssen. Selbst wenn Sie Windows Forms bereits kennen, wird Ihnen dieses Buch ein unschtzbares Hilfsmittel sein, das dazu beitrgt, vergessenes Grundlagenwissen aufzufrischen und Sie auf fortgeschrittenere Projekte vorzubereiten. Wer bereits mit anderen Methoden der Anwendungsentwicklung fr Windows vertraut ist, wird Windows Forms als Erleichterung empfinden, da es bislang lstige Arbeitsschritte wie

Einleitung

etwa Speicherverwaltung zu einem Kinderspiel macht. Sie werden sehen, dass viele der Kenntnisse, die Sie bereits erworben haben, sich auch weiterhin in diesem neuen Rahmenwerk anwenden lassen. Und schlielich: Wenn Sie einfach nur neugierig auf das .NET Framework sind, dient Ihnen dieses Buch als ausgezeichnete Einfhrung und fhrt Sie durch viele der zentralen Themen, die sich auf die Anwendungsentwicklung beziehen.

VorkenntnisseDie einzigen absolut erforderlichen Voraussetzungen sind Grundkenntnisse im Umgang mit dem Betriebssystem Windows, von der Bedienung der Eingabeaufforderung bis zum Arbeiten mit Anwendungsfenstern. Die Kenntnis einer .NET-Programmiersprache wie C# oder VB .NET wird sich als uerst hilfreich erweisen, ist aber keine Voraussetzung. Dieses Buch fhrt Sie rasch in die Grundlagen dieser beiden Programmiersprachen ein und stellt jedes neue Thema vor, bevor diese Sprachen verwendet werden. Wenn Sie dem Code und Text folgen knnen und sowohl C# als auch VB .NET sind einfach zu lesen dann werden Sie keine Probleme haben. Kenntnisse des .NET Frameworks sind nicht erforderlich. Dieses Buch befasst sich grndlich mit dem Framework und wird ntigenfalls auf weitere Ressourcen verweisen.

Software fr die BeispieleDie einzige Software, die Sie neben Windows NT 4.0 mit Service Pack (SP) 6, Windows 2000 oder Windows XP bentigen, ist das .NET Framework und der Windows-Editor (NotePad). Das .NET Framework ist notwendig, um Windows Forms-Anwendungen erstellen zu knnen, und lsst sich kostenlos von Microsofts Website http://www.microsoft.com/net herunterladen. Auerdem finden Sie das .NET Framework SDK auf der Begleit-CD. Um Anwendungen zu schreiben, brauchen Sie lediglich ein Textprogramm, das einfache Textdateien (zum Beispiel mit der Endung .txt) erstellen kann. Der Windows-Editor eignet sich fr diesen Zweck hervorragend. Wenn Ihnen ein anderes Textprogramm wie etwa Word, WordPad oder gar FrontPage eher behagt, dann knnen Sie selbstverstndlich auch dieses benutzen. Visual Studio .NET wird hier nicht bentigt. In der Tat wird es im ganzen Buch recht selten verwendet. Whrend es zutrifft, dass Visual Studio .NET eine Menge ausgezeichneter Funktionen fr die Anwendungsentwicklung bereitstellt, sind wir doch der Meinung, dass

18

Wie dieses Buch aufgebaut ist

es am besten ist, die Aufgaben zu Fu zu bewltigen, bevor man sie von einer solchen Entwicklungsumgebung erledigen lsst. Auf lange Sicht werden Sie dafr dankbar sein. Um schlielich die Datenbank-bezogenen Beispiele verwenden zu knnen, bentigen Sie irgendeine Form von Datenbanksystem, das zu OLE DB konform ist, beispielsweise Microsoft Access oder SQL Server. Ohne diese Werkzeuge werden Sie die diesbezglichen Beispiele nicht nutzen knnen.

Wie dieses Buch aufgebaut istDas Buch ist als Serie von Lernabschnitten, als Tutorial, aufgebaut, so dass jeder Tag auf dem vorhergehenden aufbaut. Es ist sinnvoll, Schritt fr Schritt vorzugehen, wenn auch nicht zwingend. Nach der Errterung des Themas folgen jeweils ein paar Beispiele, die von Analysen begleitet werden. Jedes Kapitel endet mit Antworten auf hufig gestellte Fragen, einem kurzen Quiz und einer bung. Diese Bestandteile sind sorgfltig ausgewhlt, so dass sie Ihr Wissen erweitern und Ihre Erfahrung mit der Technologie vertiefen knnen. Das Buch ist in drei logische Abschnitte aufgeteilt, von denen sich jeder ber eine Woche erstreckt, sowie in einen Block aus drei Anhngen:

Die erste Woche werden Sie damit verbringen, die Grundlagen von .NET und Windows Forms zu erlernen. Sie werden verstehen, was zur Erstellung einer Windows Forms-Anwendung gehrt, werden herausfinden, wie man dabei vorgeht und mit den Steuerelementen umgehen lernen, die Ihre Anwendung mit Funktionen versehen. Die feste Grundlage, die Sie in dieser Woche aufbauen, hilft Ihnen in den nchsten zwei Wochen. Whrend der gesamten zweiten Woche befassen Sie sich mit Technologien, die den Funktionsumfang Ihrer Windows Forms-Anwendung erweitern, angefangen mit ActiveX bis hin zu ADO.NET. Sie sind nicht unbedingt ein Teil von Windows Forms, aber Sie werden sie hchstwahrscheinlich bei der Anwendungsentwicklung bentigen. In der dritten Woche reichen die Windows Forms-Themen schon ein gutes Stck tiefer. Sie lernen, wie Sie Ihre Anwendungen vollstndig anpassen, angefangen vom Aufbau leistungsfhiger (und vermarktbarer) Steuerelemente bis hin zur Konfiguration von Installationsoptionen und Sprachen. Sie werden sich einige Techniken aneignen, mit denen Sie die Leistung Ihrer Anwendungen betrchtlich erhhen knnen: von Multithreading bis hin zu Profiling.

19

Einleitung

Am Ende jeder Woche werden Sie ein wenig Zeit auf das Rekapitulieren der Lektionen verwenden und daraufhin das Wissen dieser Woche auf ein echtes Projekt anwenden. Sie werden ein Textverarbeitungsprogramm hnlich wie Microsoft Word von Anfang an aufbauen, indem Sie es durch neu erlernte Funktionen und Technologien erweitern. Die Rekapitulation jeder Woche beruht auf den entsprechenden Lektionen. Diese Projekte bieten Ihnen die Gelegenheit, Ihre Kenntnisse, die Sie whrend dieser Woche erworben haben, anzuwenden und zu festigen.

Schlielich erhalten Sie mit den Anhngen eine vollstndige Referenz fr die in dem vorliegenden Buch behandelten Themen. Um Antworten auf die Quizfragen zu erhalten, knnen Sie hier nachschlagen. Damit knnen Sie auch Ihr Wissen ber die im Buch vorgestellten Steuerelemente und Objekte auffrischen.

Programmcode auf Begleit-CD und US-WebsiteAuf der Begleit-CD finden Sie den vollstndigen Code fr alle Beispiele des Buches in der amerikanischen Originalversion. Die im Buch wiedergegebenen Listings unterscheiden sich hiervon nur darin, dass Beschriftungen von sichtbaren Elementen der Benutzeroberflche sowie die Kommentare ins Deutsche bersetzt wurden. Bei eventuellen Problemen mit der Lokalisierung Ihres eigenen Codes knnen Sie so durch Vergleich mit dem Originalcode die Fehlerursachen schnell einkreisen. Den Code fr dieses Buch knnen Sie auch von der Sams Publishing-Website herunterladen: http://www.samspublishing.com/. Geben Sie die ISBN in das Suchfeld ein (0672323206 ohne Bindestriche!) und klicken Sie auf SEARCH. Sobald der Buchtitel angezeigt wird, klicken Sie darauf und gehen auf eine Seite, wo Sie den Code herunterladen knnen. Auf dieser Website finden Sie gegebenenfalls auch aktualisierte bzw. fehlerbereinigte Versionen der Codebeispiele. Weitere Ressourcen finden Sie auf meiner Homepage http://www.clpayne.com. Hier finden Sie Links zu entsprechenden Informationen wie etwa Artikeln und Quellcode.

20

Konventionen

KonventionenIm Buch werden die folgenden typographischen Konventionen verwendet:

Codezeilen, Befehle, Anweisungen, Variablen und jeglicher Text, den Sie entweder eingeben oder der auf dem Bildschirm erscheint, werden in Schreibmaschinenschrift angezeigt. Benutzereingaben werden hufig in Fettschrift dargestellt. Platzhalter in Syntaxbeschreibungen werden kursiv gedruckt. Ersetzen Sie den Platzhalter durch den tatschlichen Dateinamen, Parameter oder das Element, das Sie verwenden mchten. Manchmal sind Codezeilen zu lang, als dass sie auf eine einzelne Zeile auf der Seite passen. An der fehlenden Zeilennummer knnen Sie erkennen, wenn eine Codezeile noch zur darber liegenden Zeile gehrt. Die Analyseabschnitte nach Codelistings besprechen den Code im Detail. Hier finden Sie heraus, was ein bestimmtes Stck Code bewirkt und wie es funktioniert, sowie hufig eine Betrachtung Zeile fr Zeile.

Ferner enthlt dieses Buch Hinweise, Tipps und Warnungen, die Ihnen dabei helfen sollen, wichtige oder hilfreiche Informationen schneller auszumachen. Einige stellen ntzliche Hilfestellungen zum effizienteren Arbeiten dar. Auerdem finden Sie ntzliche Gegenberstellungen der Art Tun Sie dies/Tun Sie dies nicht. Hier finden Sie Vorschlge ber den richtigen Weg, eine Aufgabe zu lsen (und Warnungen vor dem falschen).

Und zu guter Letzt...Ich hoffe, Sie haben viel Spa beim Erlernen dieser interessanten Technologie. Sie wird es Ihnen ermglichen, mit Windows viele verblffende Dinge, die auf dem heutigen Markt sehr gefragt sind, anzustellen. Als Leser dieses Buches sind Sie fr Autor, bersetzer, Fachlektor und Verlag der wichtigste Kritiker und Kommentator. Bitte teilen Sie uns mit, was Sie an diesem Buch positiv finden, was wir besser machen knnten oder was Ihnen sonst am Herzen liegt. Wenden Sie sich bitte an den Lektor Rainer Fuchs, [email protected], der Ihnen weiterhilft oder Ihre Anfrage weiterleitet.

21

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

Mit Windows Forms beginnen Windows Forms-Anwendungen erstellen Mit Windows Forms arbeiten Mens und Symbolleisten Ereignisse in Windows Forms Windows Forms mit Steuerelementen erweitern Mit Dialogfeldern arbeiten

25 45 77 111 151 177 231

W O C H E


Datenbindung in Windows Forms ADO.NET einsetzen MDI-Anwendungen erstellen Arbeiten mit der Windows-Ein-/Ausgabe Formulare Internet-fhig machen Grafische Anwendungen mit GDI+ ActiveX

281 309 349 377 415 439 477

W O C H E


Webdienste Windows-Dienste Fortgeschrittene Techniken fr Steuerelemente in Windows Forms Benutzerdefinierte Steuerelemente in Windows Forms Multithreading-Anwendungen Windows Forms konfigurieren und bereitstellen Debugging und Profiling

515 539 565 589 621 655 681

W O C H E

Woche 1: Die GrundlagenAuf Ihrer Reise durch Windows Forms erlernen Sie in der ersten Woche die Grundlagen. Die ersten sieben Lektionen vermitteln Ihnen ein festes Fundament, so dass Sie in den Wochen 2 und 3 fortgeschrittenere Themen angehen knnen. Tag 1 mit dem Titel Mit Windows Forms beginnen stellt Ihnen das .NET Framework, Windows Forms und die Windows-Programmierung vor. Sie werden in dieser Lektion auch Ihre erste Anwendung sehen. An Tag 2 mit dem Titel Windows Forms-Anwendungen erstellen werden Sie anfangen, Ihre erste eigene Windows-Anwendung zu erzeugen und mehr darber erfahren, wie Sie diese Anwendung kompilieren und ausfhren. Tag 3 mit dem Titel Mit Windows Forms arbeiten ist eine sehr wichtige Lektion. Sie erfahren alles ber das Objekt Form, den Hauptbestandteil jeder Windows Forms-Anwendung. Sie werden erstmals auch einen Blick darauf werfen, wie Sie Ereignisse behandeln, d.h. wie Sie Ihre Anwendung auf Benutzereingaben reagieren lassen. An Tag 4 mit dem Titel Mens und Symbolleisten werden Sie von vielen der Steuerelemente im Windows Forms-Framework erfahren, die Ihnen das Leben als Entwickler sehr erleichtern. Tag 5, Ereignisse in Windows Forms, lehrt Sie, wie Sie auf verschiedene Geschehnisse in Ihrer Anwendung, wie etwa Mausklicks auf Schaltflchen oder Mens, reagieren knnen. An Tag 6, der den Titel Windows Forms mit Steuerelementen erweitern trgt, werden Sie Ihr Repertoire an Windows Forms-Steuerelementen betrchtlich aufbessern: Sie lernen alle wichtigen Steuerelemente kennen, die an Tag 4 nicht behandelt wurden. Tag 7, Mit Dialogfeldern arbeiten, bringt Ihnen schlielich alles ber eine besondere Art von Windows Forms bei. Es gibt eine ganze Reihe von Dialogfeldtypen, die in der Windows-Programmierung sehr ntzlich sind. Am Ende der Woche werden Sie das Gelernte rekapitulieren und es dazu verwenden, eine funktionierende Anwendung zu erzeugen. Lassen Sie uns ohne weiteren Verzug anfangen!

24

Mit Windows Forms beginnen

1


Willkommen zu Tag 1, Ihrem ersten Schritt in die Welt von Windows Forms! Windows Forms als Bestandteil von Microsoft .NET ist eine neue Technologie, die es Ihnen erlaubt, Windows-Anwendungen auf schnelle und einfache Weise zu erstellen. Heute fangen Sie damit an, worum es bei Windows Forms und .NET geht, und Sie werfen einen Blick auf echten Code. Heute

entdecken Sie, was Windows-Programmierung fr Entwickler bedeutet, erfahren Sie, was .NET und Windows Forms sind, finden Sie etwas ber die Vorteile heraus, die Ihnen .NET und Windows Forms bieten, erkunden Sie, wie die Common Language Runtime und die Microsoft Intermediate Language funktionieren, lernen Sie, wie Sie das .NET Framework installieren, untersuchen Sie eine einfache Windows Forms-Anwendung.

1.1

Einfhrung in die Windows-Programmierung

Das Wichtigste zuerst: Was ist ein Windows-Programm? Vielleicht sollten wir noch einen weiteren Schritt zurck tun und fragen: Was ist Microsoft Windows? Da Sie nun mal auf dem Weg sind, ein Entwickler zu werden, mssen Sie Windows mit anderen Augen betrachten. Wenn Sie bereits ein Programmierer sind, dann haben Sie bereits gelernt, ein Betriebssystem zu steuern. Aus der Sichtweise eines Normalbenutzers ist Microsoft Windows ein Betriebssystem, das den Computer zum Laufen bringt. Es gestattet ihm Dokumente zu erstellen und zu speichern, Berechnungen auszufhren, im Internet zu surfen, Dateien auszudrucken und so weiter. Wenn Sie dieses Buch lesen, dann behagt Ihnen diese Beschreibung hchstwahrscheinlich nicht, denn Sie wollen mehr wissen: wie alles unter der Motorhaube funktioniert und wie Sie Windows dazu bringen knnen, bestimmte Dinge fr Sie zu erledigen. Unter seinem nett anzusehenden ueren ist Microsoft Windows genau wie jedes beliebige andere Betriebssystem eine Umgebung fr bersetzer und zuweilen auch selbst ein bersetzer. Windows und seine Anwendungen nehmen vom Benutzer eine Eingabe entgegen und bersetzen sie in etwas, das ein Computerprozessor verstehen kann nmlich Einsen und Nullen und umgekehrt. Abbildung 1.1 gibt dieses mehrschichtige Paradigma wieder. Windows selbst wei nicht, wie es jede Eingabe bersetzen soll, und das ist der Punkt, an dem Windows-Anwendungen in Aktion treten.

26

Einfhrung in die Windows-Programmierung

Benutzereingabe

Microsoft Windows

CPU

0101101 1001..

Abbildung 1.1: Windows fungiert als bersetzer zwischen dem Benutzer und dem Hauptprozessor.

Ein Windows-Programm wird von einem Entwickler geschrieben und sagt Windows, was es tun soll, um auf eine Eingabe zu reagieren. Diese Eingabe knnte in einem Tastendruck bestehen, einem Mausklick oder auch einfach in einem Programmstart. Durch Verwendung einer Programmiersprache einer Sammlung von Schlsselwrtern, Anweisungen, Begriffen und so weiter, die fr den Computer von besonderer Bedeutung sind schreibt ein Programmierer Befehle fr das Betriebssystem, so dass es wei, wie es Eingaben in Maschinensprache zu bersetzen hat. Was ist also ein Windows-Programm? Es ist ein Befehlssatz, der Windows mitteilt, was es tun und wie es auf eine Benutzereingabe reagieren soll. Als Entwickler werden Sie solche Instruktionen schreiben vertrauen Sie mir, es ist einfacher, als Sie glauben. Wir werden diesen Vorgang nher unter die Lupe nehmen, wenn Sie Ihre ersten Anwendungen heute und morgen auf die Beine stellen.

ProgrammiersprachenWie bereits erwhnt, ist eine Programmiersprache das, womit ein Programmierer das Betriebssystem instruiert. Sie enthlt bestimmte Schlsselbegriffe und eine Syntax. Auch wenn diese Elemente fr den Laien wenig Sinn ergeben mgen, entsprechen sie einer wohldefinierten Logik. Selbst ohne Erfahrung auf diesem Gebiet haben Sie wahrscheinlich schon einmal von einigen Programmiersprachen gehrt: C, C++, C# (sih scharp ausgesprochen), Visual Basic, Pascal, Java und so weiter. Warum so viele? Jede Sprache geht das Thema ein wenig anders an und stellt dem Entwickler andere Wahlmglichkeiten bereit; ihre Anwendungen hneln gesprochenen Sprachen sehr. Beispielsweise kennt ein Eskimo (Inuit) zehn Ausdrucksweisen fr den Begriff Schnee, wohingegen die englische Sprache nur wenige besitzt. In hnlicher Weise verfgt C++ ber verschiedene Mglichkeiten, Funktionszeiger auszudrcken, whrend Visual Basic nur wenige oder keine besitzt. Das bedeutet nun nicht, dass eine der beiden Sprachen mangelhaft ist, sondern dass die zwei sich aus unterschiedlichen Wurzeln entwickelt haben. Darber hinaus verwenden die meisten Sprachen (mit den Ausnahmen, die Sie im Abschnitt Was ist .NET? kennen lernen werden) unterschiedliche Paradigmen, um Windows-Anwendungen zu erstellen. C- und C++-Programme verwenden hufig die

27


Microsoft Foundation Classes (MFC), wohingegen Visual Basic seinen eigenen Formulardesigner besitzt. Das fhrte dazu, dass das Erlernen einer neuen Sprache hufig auch bedeutete, eine neue Methode zur Erstellung von Windows-Anwendungen zu erlernen (was inzwischen in .NET nicht mehr der Fall ist; mehr darber spter). Programmiersprachen werden in der Regel nicht vom Betriebssystem verstanden. Vielmehr bersetzt ein Zwischenprogramm namens Compiler die Programmiersprache in Maschinensprache, also in etwas, was das Betriebssystem versteht. Man knnte theoretisch ebenfalls in Maschinensprache schreiben, doch die meisten Menschen verstehen Binrbefehle nicht. Beispielsweise drfte die Zeichenfolge 010101111 nach Unsinn aussehen, ergibt aber fr den Computer tatschlich einen Sinn. Die Sprachen, die Sie in diesem Buch benutzen werden, sind C# und Visual Basic .NET (VB .NET) die erste, weil sie speziell fr den Einsatz in der .NET-Umgebung entworfen wurde, und die zweite, weil die meisten Anfnger diese leicht erlernbare Sprache verwenden. Es ist meistens einfach, die eine in die jeweils andere zu bersetzen. Beispielsweise zeigt das folgende Stck Code zwei Befehlszeilen: eine in C# und die andere in Visual Basic .NET; beide tun das Gleiche.C# System.Console.WriteLine("Hello World!"); VB .NET System.Console.WriteLine("Hello World!")

In diesem Fall besteht der einzige Unterschied im Semikolon am Schluss der ersten Befehlszeile. Im ganzen Buch werden Ihnen Codebeispiele in beiden Sprachen angeboten, so dass Sie das bevorzugte Beispiel whlen knnen. Ich halte es fr eine gute Idee, wenn Sie entweder C# oder VB .NET vor dem Lesen dieses Buches kennen. Sie bekommen zwar einiges dieser Sprachen durch das Lesen mit, aber Ihnen wrden viele Elemente entgehen, die Sie sonst beim separaten Erlernen dieser Programmiersprachen erhalten wrden.

Win32-ProgrammierungMan hrt hufig den Begriff Win32, mit dem Entwickler um sich werfen. Win32Anwendungen sind einfach Anwendungen, die fr eine 32-Bit-Version von Windows (also Windows 95, 98, ME, 2000 und XP) erstellt wurden. ltere Versionen von Windows verwendeten 16 Bit und werden daher als Win16 bezeichnet. Der bergang von 16 zu 32 Bit stellt Ihnen viel mehr Verarbeitungsleistung zur Verfgung und gestattet Ihnen mehr Kontrolle ber den Computer. Win16-Programme laufen auf einem Win32-Betriebssystem, das gilt aber nicht umgekehrt wegen beschrnkter Verarbeitungsleistung und fehlender Abwrtskompatibilitt.

28

Was ist .NET?

Sehr einfach ausgedrckt sind also 32 Bit besser als 16 Bit, weil Sie damit mehr in der gleichen Zeit verarbeiten knnen. Fr einen Computerprozessor heit 32 Bit, dass er auf 32 Bit lange Daten im Speicher zugreifen und sie verarbeiten kann, was wesentlich mehr Platz bedeutet als 16 Bit. In der heutigen EDV-Welt sind die meisten Anwendungen, die Sie sehen, Win32 genau wie alle Anwendungen, die Sie in diesem Buch erstellen werden. Win16-Programme bezeichnet man als Legacy- oder Vermchtnis-Programme, weil sie noch aus der Frhzeit der modernen Computerei stammen (also bis ca. 1995). Viele Entwickler halten nichts von Legacy-Anwendungen, weil diese Programme meist recht alt sind und ihnen die modernen Verarbeitungstechniken fehlen.

1.2

Was ist .NET?

.NET ist Microsofts Initiative, eine neue Generation von Windows-Anwendungen aus der Taufe zu heben. .NET vereinfacht viele der hinderlichen Aspekte in der Windows-Programmierung zu einer einfachen Architektur und integriert dabei das Internet eng in alle Anwendungen. Whrend .NET ein Konzept ist, bringt das .NET Framework es zum Laufen. Sie werden das Framework bei der Arbeit mit Windows Forms ausgiebig nutzen. Einfach ausgedrckt ist das .NET Framework eine Architektur, auf deren Grundlage sowohl Internet- als auch Desktop-basierte Anwendungen erstellt und ausgefhrt werden knnen. Fr die Arbeitsweise von Windows stellt es eine vllig neue Welt dar, indem es ein standardisiertes System bereitstellt, das alle Anwendungen nutzen knnen, anstelle der vielen unterschiedlichen Frameworks, die heute verfgbar sind. .NET stellt fr diese Anwendungen auch eine neue Umgebung bereit, in der sie ablaufen knnen. Das ist effizienter, sicherer und leistungsfhiger. Kurz und gut: Mit Hilfe von .NET knnen Sie Anwendungen leichter als je zuvor erstellen. Eines der Hauptziele von .NET besteht darin, Anwendungen oder Anwendungskomponenten ber das Internet als Dienste (Services) bereitzustellen. Ein Dienst ist eine Anwendung, die ber das Web zur Verfgung steht und sich direkt oder von anderen Anwendungen nutzen lsst. Diese Dienste wren fr jeden verfgbar, der sie braucht; man whlt sich einfach ins Web ein und stellt die Verbindung zum Dienst her. Stellen Sie sich vor, Sie htten nicht solche Software wie Microsoft Word auf Ihrem Computer zu installieren. Statt dessen gehen Sie online und nutzen es von der Microsoft-Website aus, genauso, als befnde es sich auf Ihrem Computer. Abbildung 1.2 illustriert dieses Konzept.

29


Ihr Computer

Befehle senden

Dienst

Internet

gelieferte Daten senden

Abbildung 1.2: Ein Webdienst ist eine Anwendung oder Komponente, die ber das Internet zum Gebrauch bereitsteht.

Dieses Paradigma erspart sowohl Endanwendern als auch Entwicklern Kopfschmerzen. Die Endanwender mssen sich keine Sorgen machen, ob ihre Installation klappen wird oder ob sie ihre Anwendung pflegen, also aktualisieren mssen. Der Entwickler muss sich nicht sorgen wegen Installationsproblemen oder der Pflege mehrerer Programmversionen auf mglicherweise Tausenden von Anwendercomputern. Er erstellt das Programm einfach und stellt es ber das Internet zur Verfgung, so dass Anwender vorbeischauen knnen und es einsetzen, wann sie es bentigen. Wenn der Entwickler eine neue Version erstellt, stellen die Benutzer eine Verbindung nur deshalb her, um die neuen Funktionen zu nutzen. In den nchsten Abschnitten erfahren Sie mehr ber die Komponenten von .NET und wie sie zusammenwirken, um Ihre Arbeit als Entwickler zu vereinfachen. Es mag zwar zunchst etwas trocken zu lesen sein, doch Sie werden diese Grundlage brauchen, bevor Sie anfangen, eigene Anwendungen zu erstellen.

.NET-KompilierungEine nicht auf .NET basierende Anwendung funktioniert folgendermaen: Sie wird von einem Entwickler in einer Programmiersprache geschrieben und dann zu einer ausfhrbaren Anwendung kompiliert (das ist ein sehr wichtiges Konzept). Das Betriebssystem stellt die Umgebung fr die Ausfhrung der Anwendung bereit und bietet ihr je nach Bedarf Zugriff auf seine Ressourcen. In einem Multitasking-Betriebssystem wie Windows lassen sich mehrere Anwendungen gleichzeitig ausfhren, denn jede Anwendung hat ihre eigenen Betriebssystemressourcen (Speicher usw.). Normalerweise respektiert jede Anwendung die Ressourcen der anderen, so dass keine Konflikte auftreten. Jede Anwendung hat sich auch selbst zu pflegen; das heit sie wird ausgefhrt und rumt sozusagen hinter sich wieder auf, wobei sie Ressourcen wieder freigibt, sobald sie nicht mehr gebraucht werden. Das ist im Allgemeinen eine gute Arbeitsweise. Anwendungen sind blicherweise mit sich selbst beschftigt und kmmern sich nicht darum, was andere Anwendungen so treiben. So knnte Anwendung A beispielsweise abstrzen, whrend Anwendung B weiterluft, weil die beiden sich keine Ressourcen teilen. Das Betriebssystem braucht nur minimale Ressourcen zu investieren, um die Anwendung aufrechtzuerhalten (von der Prozessorleistung einmal abgesehen). Dieses Modell hat jedoch auch ein paar Nachteile. Das Betriebssystem muss die meisten Anwendungen bei sich registrieren, damit es Einstellungen pflegen, Ressourcengrenzen

30

Was ist .NET?

bestimmen und es den Programmen erlauben kann, mit sich und anderen Anwendungen zu interagieren, wenn es ntig ist. Das kann zu einem recht komplizierten Registrierungsvorgang fhren, was wiederum umfangreiche Installationsprozeduren erfordert. Da jede Anwendung ihre eigenen Ressourcen zu verwalten hat, ist es zudem dem Entwickler berlassen, diese Ressourcen sauber zu handhaben. Man muss mitunter lstigen Code schreiben, nur um dafr zu sorgen, dass Ressourcen sauber geholt und wieder freigegeben werden, so dass es zu keinen Konflikten kommt. Die Common Language Runtime (CLR: etwa Laufzeitversion in einer gemeinsamen Sprache) ist die .NET-Form eines Managers oder Verwalters. Die CLR verwaltet alle Aspekte derjenigen Anwendungen, die in .NET laufen. Aufgrund dessen werden die Dinge in .NET ein wenig anders gehandhabt als bislang. Wenn Sie eine .NET-Anwendung erstellen, wird sie nicht zu einem direkt ausfhrbaren Programm kompiliert. Vielmehr wird Ihr Quellcode in etwas bersetzt, was als Microsoft Intermediate Language (MSIL) bezeichnet wird und im Grunde nur eine andere Methode ist, Ihren Code darzustellen. Wenn Sie spter Ihr Programm ausfhren, wird es von einem Just-In-Time (JIT) -Compiler in Maschinencode bersetzt, welcher wiederum von der CLR ausgefhrt wird. Dieser zweistufige Vorgang ist zwar langsamer als der einstufige vor der Einfhrung von .NET, aber nicht so viel, wie Sie jetzt annehmen wrden. Der JIT kann die MSIL sehr leicht verstehen. Daher lsst sie sich effizienter kompilieren als eine traditionelle Sprache. Und zum anderen bietet dieser Vorgang einen groen Vorteil gegenber der ersten Methode: nmlich plattformbergreifende Kompatibilitt. Maschinensprachen hngen von der jeweils verwendeten Maschine ab. Computer, die mit Windows und Intel-x86-Prozessoren arbeiten, sprechen andere Sprachen als solche mit Unix. Wenn man eine Anwendung auf eine andere Plattform portieren wollte, bedeutete es daher, mindestens den Quellcode neu zu kompilieren, damit er auf der neuen Plattform lief. Meistens erforderte es aber das Neu- oder Umschreiben des Codes. MSIL ist jedoch stets MSIL, ganz gleich, auf welcher Plattform sie sich befindet. Etwas, das in MSIL auf Windows funktioniert, wird auch in MSIL auf Unix funktionieren. Es ist lediglich jeweils ein entsprechender JIT-Compiler erforderlich, der den abschlieenden Schritt des Kompilierens in Maschinensprache ausfhrt; aber darum haben Sie sich in der Regel nicht zu sorgen. Groe Unternehmen wie Microsoft bieten hchstwahrscheinlich so einen Compiler fr jede Plattform, bevor Sie eine Anwendung portieren mssen. Ein weiterer Vorteil des .NET-Paradigmas gegenber dem herkmmlichen besteht darin, dass MSIL spezielle Attribute enthlt, die als Metadaten bezeichnet werden und die es einem Programmcode erlauben, sich selbst gegenber dem Betriebssystem zu beschreiben. Man erinnere sich daran, dass traditionelle Anwendungen sich oft selbst in einer zentralen Registrierdatenbank anmelden mussten, damit das Betriebssystem sie berwachen konnte. Das ist nun nicht mehr ntig, denn alle wichtigen Informationen liegen der Anwendung bei. Zu

31


solchen Informationen knnte gehren, nach welchen Abhngigkeiten man suchen soll, wo Sicherheitsanforderungen zu finden sind, Versionsnummern, Autoren usw. Die Bndelung solcher Informationen ist sehr hilfreich, wie Sie sehen werden, wenn Sie mit dem Codeschreiben anfangen. Nicht jede Programmiersprache oder jeder Compiler kann MSIL und Metadaten erzeugen. Daher hat Microsoft eine neue Klasse von Compilern geschaffen, die das .NET Framework untersttzt. Dadurch knnen alle Ihre bevorzugten Programmiersprachen .NET untersttzen. Mit der knftigen Verbreitung von .NET drfen Sie weitere Compiler von anderen Unternehmen erwarten. Lassen Sie uns nun mal darauf achten, was nach dem Kompilieren passiert: Das Programm wird ausgefhrt.

Die Common Language Runtime (CLR)Die CLR bildet das Zentrum des .NET Frameworks. Stellen Sie sie sich wie den Hauptprozessor fr Ihre Anwendungen vor; sie behandelt die gesamte Ausfhrung und Verwaltung Ihrer Anwendungen. Sie hat zwar eine Menge Funktionen, doch Sie brauchen vorerst nur einige davon zu kennen. Zunchst einmal steuert die CLR den Ressourcenbedarf Ihrer Anwendung. Sie teilt deren Komponenten Speicher und Prozessorzeit zu und nimmt sie nach der Nutzung wieder zurck. Dieser Vorgang wird als Garbage Collection (Mllbeseitigung) bezeichnet, also als Speicherbereinigung. Entwickler mit einer gewissen Erfahrung, besonders in C und C++, werden sich an all die lstigen Routinen erinnern, die man schreiben musste, um Speicherressourcen zu verwalten. Diese Prozedur ist zum Glck nicht mehr ntig. Als zweiten Aspekt stellt die CLR eine vereinheitlichte Architektur bereit. Ganz gleich, welche Programmiersprache Sie nutzen, knnen Sie sich immer auf das gleiche Framework beziehen. C++-Anwendungen knnen leicht Komponenten nutzen, die in VB .NET erstellt wurden, und umgekehrt. Drittens verwendet die CLR Metadaten, die zusammen mit der jeweiligen MSIL erzeugt wurden, um eine saubere Ausfhrung zu gewhrleisten. Ein Aspekt der Metadaten ist beispielsweise, dass sie Informationen ber die Umgebung enthalten, also ber Komponenten, Versionen usw., die verwendet wurden, um Ihre Anwendung zu erstellen. Die CLR kann diese Daten untersuchen, und wenn das aktuelle System nicht die gleichen notwendigen Ressourcen besitzt, kann die CLR diese Komponenten automatisch aktualisieren. Code, der fr die CLR geschrieben wird, ist als verwalteter Code (Managed Code) bekannt: CLR verwaltet jeden Aspekt seiner Ausfhrung. Code, der nicht fr die CLR bestimmt ist (also Pr-.NET-Anwendungen), wird als nichtverwalteter Code (Non-Managed Code)

32

Was ist .NET?

bezeichnet. Von jetzt ab verwenden wir diese Begriffe. Nichtverwalteter Code lsst sich weiterhin in der CLR ausfhren, aber dafr mssen spezielle Vorkehrungen getroffen werden (darauf kommen wir am Tag 14 zu sprechen). Abbildung 1.3 zeigt die Pfade, denen verwalteter und nichtverwalteter Code in der CLR folgen.Verwalteter Code mit MSIL Die CLR Ressourcen zuweisen JIT Kompilierung Metadaten untersuchen Sicherheitsprfungen Nichtverwalteter Code Import in .NET Ausfhrung Garbage Collection (Mllbeseitigung)

Abbildung 1.3: Die CLR verwaltet die komplette Ausfhrung von verwaltetem Code und sorgt so fr Sicherheit, Kompatibilitt und richtige Funktionsweise.

Das .NET Framework installierenBevor Sie die CLR einsetzen und Windows Forms schreiben knnen, mssen Sie zunchst das .NET Framework Software Development Kit (SDK) installieren. Das SDK gibt es kostenlos auf www.microsoft.com/net, aber beachten Sie, dass es ber 100 Mbyte gro ist und das Herunterladen mit einem 56K-Modem ber sechs Stunden dauern kann. Sie knnen es auch auf CD-ROM bei Microsoft bestellen (VisualStudio.NET liegt es bei). Das .NET Framework SDK erfordert Windows NT 4.0 mit Service Pack (SP) 6, Windows 2000 oder Windows XP, um richtig zu laufen. Wenn Sie ein anderes Betriebssystem besitzen, haben Sie Pech: Es gelingt Ihnen vielleicht, ein paar Beispiele zum Laufen zu bringen, aber Microsoft bietet Ihnen keinen Support, wenn das nicht gehen sollte. Sobald Sie ein Exemplar des SDKs haben, fhren Sie das Setup-Programm aus (Abbildung 1.4). Klicken Sie auf WEITER, um die Installation zu starten, und akzeptieren Sie die Lizenzvereinbarung. Klicken Sie noch dreimal auf WEITER und lehnen Sie sich zurck, whrend sich Ihnen die Tore zur .NET-Welt ffnen (in anderen Worten: whrend das SDK installiert wird). Nach dem Abschluss der Installation erscheint ein Verknpfungssymbol zu einer SDKbersicht auf Ihrem Desktop. Diese Webseite hat Verknpfungen, um die .NET-Musterbeispiele einzurichten (falls Sie sie in einem vorhergehenden Schritt installiert haben) wie auch Verknpfungen zu weiterer Dokumentation.

33


Abbildung 1.4: Der Installationsvorgang fr das .NET Framework SDK beginnt mit dem Setup-Bildschirm.

EntwicklungsumgebungenIn einer Entwicklungsumgebung verrichten Sie alle Ihre Arbeiten, wie etwa Anwendungserstellung und Eingeben von Code. Fr die Entwicklung mit Windows Forms brauchen Sie jedoch lediglich ein Textprogramm, um Code zu schreiben. Zustzlich zum Textprogramm bieten viele Entwicklungsumgebungen ausgetftelte Benutzeroberflchen, die fortgeschrittene Fhigkeiten fr die Verwaltung von Code und Projekten besitzen. Diese Funktionen sind hufig ntzlich, aber nicht Bedingung. Der gesamte Quellcode in diesem Buch (und auf der entsprechenden Webseite www.samspublishing.com) liegt in einfachem Text vor. Das bedeutet, dass Sie einen Texteditor wie den Windows-Editor (NotePad) als Ihre Entwicklungsumgebung nutzen knnen. (Die von Ihnen erzeugten Dateien werden zwar die Erweiterungen .cs oder .vb tragen, aber dennoch aus einfachem Text bestehen.) Auch Visual Studio .NET ist ein ausgezeichneter Editor fr die Anwendungen, die Sie erstellen. Es zeichnet Ihren Code in Farbe aus und stellt kontextabhngige Funktionen bereit, so etwa kleine Popup-Felder, die fr Sie Stze vervollstndigen. Darber hinaus stellt Visual Studio .NET zahlreiche Assistenten zur Verfgung, die Ihnen beim Erstellen von Windows Forms-Anwendungen beistehen. Obwohl es zahlreiche fr Entwickler wertvolle Funktionen in Visual Studio .NET gibt, wird sich dieses Buch nicht darauf konzentrieren. Vielmehr beschftigt es sich mit der Windows Forms-Technologie. Schlielich besteht die beste Methode, das Programmieren von Windows Forms zu erlernen, darin, sie selbst zu erstellen, und nicht, sie von einer grafischen Entwicklungsumgebung fr Sie erstellen zu lassen. Sobald Sie darin versiert sind, selbst Quellcode zu schreiben, werden Sie die Leistungsmerkmale von Visual Studio .NET umso mehr zu schtzen wissen. Fr dieses Buch brauchen Sie lediglich Notepad.

34

Was ist .NET Windows Forms?

In diesem Buch legen wir fr jede Tageslektion einen neuen Ordner an, damit sich alle Dinge leicht wiederfinden lassen. Zum Beispiel werden die Dateien von Tag 2 im Ordner c:\winforms\day2 abgelegt. Wenn Sie also fr die Beispiele in diesem Buch (oder aus dem Download von der Sams-Website) selbst Code schreiben, erstellen Sie diese Ordner und legen die Anwendungsdateien darin ab. Wenn Sie sich an dieses Bezeichnungsschema halten, knnen Sie dem weiteren Vorgehen leicht folgen.

1.3


Sie fragen sich vielleicht, ob die berschrift nicht besser Was sind Windows Forms? lauten sollte. Nein, denn Windows Forms ist keine Sammlung von Formularen bzw. Masken, die man in Windows benutzt, sondern eine einzige Technologie, die Ihnen beim Entwerfen von Windows-Anwendungen hilft. Sie ist Microsofts neue Plattform fr die Entwicklung von Windows-Anwendungen, die auf dem .NET Framework basieren. Ein Blick auf die beiden Wrter Windows Forms: Sie kennen ja Windows bereits als Betriebssystem, das Benutzereingaben entgegennimmt und entsprechende Arbeiten ausfhrt. Ein Formular (form) ist genauso wie seine Papierversion etwas, das man mit Informationen ausfllt, um damit etwas Bestimmtes zu erreichen. Ein Papierformular lsst sich beispielsweise dazu verwenden, einen Pass zu beantragen, eine Prfung zu absolvieren oder sich zu bewerben. Ein digitales Formular wird blicherweise eingesetzt, um Informationen einzugeben oder um mit einer Anwendung zu interagieren. Wenn Sie schon einmal das Internet benutzt haben, haben Sie bereits etliche digitale Formulare zu Gesicht bekommen. Viele Webseiten fragen auf diese Weise Informationen vom Benutzer ab, um ihn beispielsweise fr eine Dienstleistung zu registrieren. Wahrscheinlich haben Sie bereits Dutzende, wenn nicht Hunderte solcher Formulare ausgefllt. Abbildung 1.5 zeigt ein solches Formular. Der Vorteil eines digitalen Formulars gegenber einem Papierformular besteht darin, dass das digitale mit Ihnen interagieren kann. Sobald Sie Informationen eintragen, kann das Formular die Eingabe verarbeiten oder Ihnen weitere Auswahlmglichkeiten anbieten. Genau auf dieser Idee fut die Windows Forms-Technologie. Sie verwendet digitale Formulare (die ebenfalls Windows Forms genannt werden), um Daten zu sammeln. Ein Windows Form ist ein Bildschirmfenster, mit dem der Benutzer interagiert. Es lsst sich fr das Sammeln oder Anzeigen von Daten verwenden, fr die Ausgabe von Alarmmeldungen usw. (Bitte beachten Sie, dass wir im Folgenden den Begriff sowohl fr die Technologie als auch fr das eigentliche Windows Forms-Fenster (= Formular) verwenden. Das ist zulssig, denn die Technologie besteht hauptschlich aus diesen Fenstern.)

35


Abbildung 1.5: Ein typisches Webformular enthlt Textfelder und eine Schaltflche.

Diese Beschreibung knnte den Eindruck erwecken, dass ein Windows Form nicht sonderlich funktionsreich sei, doch in Wirklichkeit stellt es eine Menge Leistung und Flexibilitt bereit. Weil die Windows Forms-Technologie auf dem .NET Framework beruht, steht ihr eine umfangreiche Bibliothek von ntzlichen Objekten und Methoden zur Verfgung, die es einem Windows Forms-Fenster gestatten, so ziemlich alles auszufhren, was Sie wnschen. Daher mag ein Windows Form einfach nur eine Schnittstelle sein, um so mit dem Benutzer zu interagieren, doch die Technologie hinter dem Formular liefert die entsprechende Leistungsfhigkeit.

Integration mit .NET.NET und die CLR bieten Ihnen eine Flle von Funktionen, um die Anwendungsentwicklung viel einfacher zu machen. Wie bereits angesprochen, stellt die Garbage Collection sicher, dass alle unbenutzten oder brig gebliebenen Ressourcen, die Ihre Anwendung nicht mehr braucht, auf angemessene Weise behandelt werden und so fr den Gebrauch durch andere Anwendungen freigemacht werden. Die Einbindung in .NET erlaubt es Ihren Windows Forms, die umfangreiche Klassenbibliothek des .NET Framework zu nutzen. Diese enthlt fast alle Objekte, die Sie jemals fr Ihre Anwendungen brauchen werden, in vorgefertigter und einsatzbereiter Form. Sie brauchen eine Komponente, die auf Datenbanken zugreift? .NET stellt Ihnen mehrere zur

36


Auswahl. Wie wr's mit XML-Dateien? Die hat .NET ebenfalls. Das Erlernen der Windows Forms-Programmierung besteht also zum Teil aus dem Aufbau eines mglichst groen Repertoires solcher Objekte. Das ist der Faktor, der die Experten von den Neulingen unterscheidet. Und das Beste dabei: Dieses Framework steht Ihnen zur Verfgung, gleichgltig, welche Programmiersprache Sie whlen. Apropos Datenbankzugriff: Mit Windows Forms verfgen Sie ber die Leistungsfhigkeit von ADO.NET, der nchsten Generation von ActiveX Data Objects (= ADO). Diese Weiterentwicklung fhrt viele Leistungsmerkmale ein, die die Reichweite und Flexibilitt Ihrer Anwendung erhhen. Sie knnen auf vorhandene Datenquellen zugreifen oder eigene erzeugen, knnen unverbundene Datenstze nutzen, XML-Dateien lesen und schreiben und anderes. Mehr ber diese Leistungsmerkmale erfahren Sie an Tag 9. In das .NET Framework sind auch leistungsfhige Sicherheitsmerkmale integriert. Diese gestatten es dem Betriebssystem bereits dann zu erkennen, wie sicher Ihre Anwendung ist, wenn diese noch gar nicht ausgefhrt worden ist. Es kann auch unbefugte Benutzer davon abhalten, auf Ihre Anwendungen zuzugreifen, ebenso wie es autorisierte Benutzer daran hindert, unautorisierte Anwendungen wie etwa Computerviren auszufhren. Auch das Konfigurieren und Installieren Ihrer Anwendungen ist ein Kinderspiel. Die Konfiguration erfordert hufig lediglich das Erstellen einer einzigen Textdatei mit der Endung .config. Implementierung bedeutet lediglich das berspielen Ihrer Dateien auf den Zielcomputer; die Notwendigkeit, Ihre Anwendungen zu registrieren und zu installieren, entfllt. All dies ist dank CLR und Metadaten mglich. Wie der Zusatz .NET andeutet, ist Windows Forms eng mit dem Internet und Web Services integriert. Web Services sind Komponenten von online laufenden Anwendungen, mit denen Sie eine Verbindung herstellen knnen, um so deren Funktionsumfang zu nutzen. Daher brauchen Sie diese Funktionen nicht mehr selbst zu erstellen. GDI+ (Graphical Device Interface: Schnittstelle zu Grafikgerten) erlaubt Ihnen, die grafischen Funktionen von Windows zu nutzen, um Ihre Anwendungen fr die visuelle Interaktion fit zu machen. So knnen Sie mit GDI+ beispielsweise Anwendungen einfrben, Grafiken laden und bearbeiten und sogar Fenster transparent machen. Mehr zu GDI+ finden Sie an Tag 13. Wir werden alle diese Funktionen in den nchsten 20 Tagen behandeln, so dass Sie nach dem Durcharbeiten dieses Buches ein Experte in der Windows Forms-Programmierung sind.

Windows Forms-SteuerelementeEine Windows Form ist fr sich allein nicht sonderlich interaktiv. Wie Sie spter an diesem Tag sehen werden, ist die Zahl der Mglichkeiten dessen, was ein Benutzer mit einem Formular tun kann, recht begrenzt. Windows Forms-Steuerelemente die es alle in der

37


Klassenbibliothek des .NET Framework gibt knnen Ihrer Anwendung erheblich mehr Dynamik verleihen, indem sie Ihnen interaktive Objekte bereitstellen, wie zum Beispiel Schaltflchen, Textfelder, Mens und Statusleisten. Alle Windows Forms-Steuerelemente (Controls) arbeiten in einer gemeinsamen Architektur das macht das Erlernen neuer Steuerelemente so einfach. Jedes Steuerelement lsst sich durch seine Eigenschaften vollstndig steuern. Sollte es noch keine Steuerelemente geben, die Ihnen zusagen, so knnen Sie leicht Ihre eigenen erstellen. Die meisten verbreiteten HTML-Steuerelemente haben in Windows Forms ein Gegenstck. Ab morgen werfen Sie einen Blick auf einige Steuerelemente, umfassender gehen wir ab Tag 4 auf dieses Thema ein.

1.4

Die objektorientierte Vorgehensweise

Das .NET Framework ist vollstndig objektorientiert. Und was bedeutet das? Objektorientierte Programmierung (OOP) ist ein Programmierparadigma, das eine logische Mglichkeit zur Anwendungsentwicklung bietet; es verknpft Programmierbegriffe mit der Realitt. In echter OOP ist alles ein Objekt, genauso wie alles, mit dem Sie tglich interagieren, ein Objekt ist. Ihr Auto, Ihre Kaffeemaschine, Ihr Stuhl alle sind Objekte. Jedes Objekt verfgt ber Eigenschaften, die es definieren. Ihre Auto etwa hat eine Farbe, gefahrene Kilometer, die Eigenschaft Hersteller und so weiter. Mit all diesen Eigenschaften lsst sich ein Objekt auf eindeutige Weise beschreiben. Meistens haben Sie in der OOP mit Objekten zu tun. Ein Windows Form ist ein Objekt, ebenso wie eine ASP.NET-Seite. Objekte verfgen auch ber Methoden bzw. Aktionen oder Verhaltensweisen. Ihr Auto hat Methoden anzuspringen, zu bremsen, anzuhalten usw. Ein Windows Form hat Methoden zu starten, zu schlieen, in der Gre verndert zu werden, die Farbe zu ndern und viele weitere Verhaltensweisen. Abbildung 1.6 zeigt Beispiele von Objekten und einige ihrer Eigenschaften und Methoden. Darber hinaus findet man oft Objekte, die auf dem gleichen grundlegenden Konzept basieren. Sowohl Pkws als auch Lastwagen sind Motorfahrzeuge, wenn auch im Detail verschieden. Manchmal gibt es Objekte, die auf einem anderen Objekt basieren; so etwa stammt der neue VW Kfer vom ursprnglichen Kfer ab. Dies sind Prinzipien (nmlich Schnittstellen bzw. Vererbung), die sich auch in der OOP wiederfinden. Sie bieten Ihnen die Flexibilitt, um Ihre vorhandenen Objekte zu erweitern, wenn sie nicht genau Ihre Wnsche erfllen.

38

So erstellen Sie Ihre erste Anwendung

Auto-ObjektEigenschaften: Farbe, Hersteller Methoden: Start, Tr ffnen

Scheinwerfer-ObjektEigenschaften: Helligkeit, Farbe Methoden: ein-/ausschalten

Rad-ObjektEigenschaften: Gre, Luftdruck Methoden: Abrieb des Gummis

Abbildung 1.6: Ein Auto weist viele Eigenschaften und Methoden auf, wie auch Unterobjekte, die ihrerseits ber Eigenschaften und Methoden verfgen.

Windows Forms basiert auf Prinzipien der OOP: Jeder Teil einer Windows Forms-Anwendung ist ein Objekt, vom sichtbaren Fenster bis hin zu den anklickbaren Schaltflchen, den ausfllbaren Textfeldern und sogar bis zur Tageszeit, zu der Sie die Anwendung nutzen. Selbst wenn Sie noch nie OOP eingesetzt haben, drfte Ihnen dies einleuchten. Solange Sie sich alles als ein selbststndiges Objekt vorstellen, werden Sie schnell lernen. Da alles in .NET ein Objekt ist, werden Sie, nachdem Sie den Umgang mit einem Objekt kennen, Bescheid wissen, wie Sie dieses Wissen auf alle brigen Objekte bertragen. Das macht Ihr Leben als Entwickler leichter. Wir werden uns diesem Thema an Tag 3 widmen, nachdem Sie ein paar Beispiele fr Objekte in Windows Forms gesehen haben.

1.5

So erstellen Sie Ihre erste Anwendung

Hchste Zeit, sich ein bisschen in Code zu vertiefen! Geben Sie den Code aus Listing 1.1 in Ihren Editor ein und speichern Sie ihn als Datei c:\winforms\day1\helloworld.vb. Denken Sie daran, im Dialogfeld SPEICHERN UNTER den Eintrag Alle Dateie

.NET Windows Forms in 21 Tagen . Oberflächen programmieren

Documents

Transcript of .NET Windows Forms in 21 Tagen . Oberflächen programmieren