Windows Forms in 21 Tagen - Oberflächen Programmieren

Chris Payne
bersetzung: Michael Matzer
.NET Windows Forms

I 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 <http://dnb.ddb.de> 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, rfuchs@pearson.de Fachlektorat: Frank Langenau, Chemnitz Herstellung: Philipp Burkart, pburkart@pearson.de Satz: reemers publishing services gmbh, Krefeld, (www.reemers.de) Einbandgestaltung: Grafikdesign Heinz H. Rauner, Gmund Druck und Verarbeitung: Bercker, Kevelaer Printed in Germany
Inhaltsverzeichnis
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 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
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
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
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
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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
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 <configSections> . . . . . . . . . . . . . . . . . . . . . . . . . Der Abschnitt <appSettings>. . . . . . . . . . . . . . . . . . . . . . . . . . . . Der Abschnitt <startup> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der Abschnitt <system.windows.forms> . . . . . . . . . . . . . . . . . . . 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-CD

Bonuskapitel 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
Einleitung
Willkommen 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 sollte

Es 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.
Vorkenntnisse
Die 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 Beispiele

Die 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 ist

Das 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-Website

Auf 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
Konventionen
Im 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, rainer.fuchs@mut.de, 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 Grundlagen

Auf 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
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.
Programmiersprachen
Wie 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-Programmierung
Man 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-Kompilierung
Eine 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 installieren

Bevor 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.
Entwicklungsumgebungen
In 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-Steuerelemente
Eine 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-Objekt
Eigenschaften: Farbe, Hersteller Methoden: Start, Tr ffnen
Scheinwerfer-Objekt
Eigenschaften: Helligkeit, Farbe Methoden: ein-/ausschalten
Rad-Objekt
Eigenschaften: 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 Dateien im Feld DATEITYP auszuwhlen und nicht TXT-Dateien. Sonst wird nmlich Ihre Datei als helloworld.vb.txt gespeichert! Listing 1.1: Ihre erste Visual Basic .NET Windows Forms-Anwendung!
1: 2: 3: 4: 5: 6: 7: Imports System Imports System.Windows.Forms Public Class HelloWorld : Inherits Form Public Shared Sub Main() Application.Run(New HelloWorld)
39
8: 9: 10: 11: 12: 13: 14:
End Sub Public Sub New() Me.Text = "Hallo Welt!" End Sub End Class
Keine Sorge, wenn Sie diesen Code nicht verstehen sollten. Sie erfahren morgen, was dies bedeutet (wir untersuchen morgen auch C#-Code). Ein kurzer berblick soll vorerst gengen: Die Zeilen 2 und 3 verwenden eine spezielle Syntax, um Ihrer Anwendung zu gestatten, die Namensrume oder Objektgruppen (aus der .NET-Klassenbibliothek) System und System.Windows.Forms zu nutzen. Das Schlsselwort Imports referenziert diese Namensrume zwecks einfacherer Verwendung. In Zeile 4 deklarieren Sie Ihre Klasse bzw. Ihr Objekt. Die Zeilen 6-8 stellen den Startpunkt fr Ihre Anwendung dar und die Zeilen 10-12 sind ein so genannter Konstruktor. In Zeile 14 schlieen Sie Ihre Klasse ab. Ein Groteil dieses Codes konfiguriert Ihre Anwendung. Die einzige echte Ausfhrungsanweisung finden Sie in Zeile 11, die aussieht, als ob sie irgendwo in der Anwendung den Gru Hallo Welt! anzeigen wrde. Der nchste Schritt besteht darin, Ihre Anwendung zu MSIL zu kompilieren. ffnen Sie ein Fenster mit einer Befehlseingabeaufforderung (START / (ALLE) PROGRAMME / ZUBEHR / EINGABEAUFFORDERUNG) und navigieren Sie zu dem Ordner, in welchem Sie diese Datei gespeichert haben. Geben Sie den folgenden Befehl in das Fenster ein und drcken Sie ():
vbc /t:winexe /r:System.dll /r: System.Windows.Forms.dll helloworld.vb
Kmmern Sie sich hier noch nicht um die Syntax. Es gengt, dass Sie wissen, dass dieser Befehl eine Visual Basic .NET-Anwendung zu einer ausfhrbaren MSIL-Datei kompiliert. Sie sollten folgende Ausgabe sehen:
C:\winforms\day1>vbc /t:winexe /r:system.dll [ic:ccc] /r: system.windows.forms.dll helloworld.vb Microsoft (R) VisualBasic.NET Compiler version 7.00.9254 for Microsoft (R) .NET CLR version 1.00.2914.16 Copyright (C) Microsoft Corp 2001. All rights reserved. C:\winforms\day1>
Falls keine Fehlermeldungen angezeigt werden, steht Ihre Anwendung zur Ausfhrung bereit. (Falls Sie helloworld.exe nicht finden, suchen Sie die Datei mit Ihrer Suchfunktion.) Geben Sie an der Eingabeaufforderung helloworld ein; es sollte dann ein Fenster wie in Abbildung 1.7 zu sehen sein.
40
Zusammenfassung
Abbildung 1.7: Hier sehen Sie Ihre erste Windows Forms-Anwendung namens Hallo Welt!
Diese Anwendung ist zwar noch nicht reich an Funktionen, beachten Sie aber bitte die Titelleiste Hallo Welt!. Herzlichen Glckwunsch zur Fertigstellung Ihrer ersten, wenn auch bescheidenen Windows Forms-Anwendung!
1.6
Zusammenfassung
Um Sie mit dem .NET Framework und Windows Forms bekannt zu machen, war dies heute nur eine kurze Lektion. Man muss zuerst ber diese grundlegenden Themen sprechen, so dass der Code spter einen Sinn ergibt, wenn man ihn sich genauer ansieht. Heute haben Sie gelernt, wie das Betriebssystem mit Ihren Anwendungen und Benutzereingaben zusammenarbeitet. Das .NET Framework ist eine neue Architektur, um damit Windows-Anwendungen zu erstellen. Damit knnen Sie unter Verwendung jeder beliebigen Programmiersprache eine Anwendung erstellen, wohlgemerkt: stets auf der gleichen standardisierten Architektur. Mit der Common Language Runtime (CLR) lassen sich Ihre Anwendungen zu Microsoft Intermediate Language (MSIL) kompilieren statt direkt zu einer ausfhrbaren Datei. MSIL enthlt Metadaten, die wiederum der CLR Informationen ber Ihre Anwendung, darunter Versionsnummer und Sicherheitsangaben, zur Verfgung stellen. Die Metadaten befreien Sie von der Notwendigkeit, Ihre Anwendung bei einem Betriebssystem anzumelden. Windows Forms ist als Teil von .NET ein Framework (Gerst) fr die Erstellung von Windows-Anwendungen, die die CLR nutzen. Sein Vorteil gegenber herkmmlicher Windows-Programmierung liegt in der vereinheitlichten, objektorientierten Architektur, die die Klassenbibliothek des .NET Frameworks nutzen kann. Von Ihrer ersten Windows Forms-Anwendung haben Sie gelernt, dass der Quellcode eine einfache Textdatei ist und sich im Editor erstellen lsst. Er muss zu MSIL kompiliert werden, bevor man ihn verwenden kann; Sie haben das getan, indem Sie einen Compiler an der Eingabeaufforderung benutzten.
41
1.7
F
Fragen und Antworten
Kann ich wirklich jede gewnschte Programmiersprache benutzen, um Windows Forms zu erstellen? A In der Theorie schon, aber in der Praxis nicht ganz. Sie brauchen einen Compiler, der Ihren Code in MSIL umwandelt und Metadaten ausgibt. Die einzigen Sprachen, die dies zur Zeit beherrschen, sind C++, C# und Visual Basic .NET, obwohl die Untersttzung fr viele weitere Sprachen gerade entwickelt wird.
Was versteht man unter ASP.NET? A ASP.NET ist eine weitere Facette von .NET. Es erlaubt Ihnen, interaktive Webseiten und Web Services zu erstellen. ASP.NET ist Windows Forms sehr hnlich beide haben die gleichen Begriffe und Frameworks gemeinsam , doch ASP.NET wird verwendet, um Internetanwendungen zu schreiben, whrend Windows Forms fr Windows-Anwendungen eingesetzt wird.
1.8
Workshop
Dieser Workshop soll Ihnen helfen, sich besser an die heute behandelten Begriffe zu erinnern. Es hilft Ihnen sehr, die Antworten vollstndig zu verstehen, bevor Sie weiterlesen. Die Antworten zu den Quizfragen und den bungen finden Sie in Anhang A.
Quiz
1. Wahr oder falsch? Windows Forms ist Win32-Programmierung. 2. Wahr oder falsch? Metadaten enthalten Angaben darber, in welcher Umgebung eine Anwendung erstellt wurde. 3. Auf welche Weise ermglicht MSIL plattformbergreifende Funktionsweise? 4. Wie nennt man die Weiterentwicklung von ActiveX Data Objects? 5. Wahr oder falsch? Man kann Windows Forms-Anwendungen mit jedem beliebigen Texteditor erstellen. 6. Was ist ein Windows Forms-Steuerelement? 7. Was bewirkt das Imports-Statement?
42
Workshop
bung
Was wrde der folgende Code bewirken, sobald er kompiliert und ausgefhrt wrde?
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: Imports System Imports System.Windows.Forms Public Class MyApp : Inherits Form Public Shared Sub Main() Application.Run(New MyApp) End Sub Public Sub New() Me.Height = 100 Me.Width = 50 End Sub End Class
43
Windows FormsAnwendungen erstellen
Windows Forms-Anwendungen erstellen
Nachdem Sie die Grundlagen verstanden haben, ist es nun an der Zeit, sich kopfber in die Erstellung von Windows Forms-Anwendungen zu strzen. In der heutigen Lektion werfen Sie einen weiteren Blick auf die gestrige Anwendung und konzentrieren sich dabei auf die verschiedenen Elemente einer Windows Forms-Anwendung. Sie betrachten die Erstellung von Windows Forms mit C#, derjenigen Sprache, die viele Entwickler fr Windows Forms bevorzugen. Sie untersuchen die Unterschiede im Code, den VB .NET und C# produzieren. Am Ende der heutigen Lektion werden Sie die eine Sprache leicht in die andere bersetzen knnen. Heute lernen Sie,

was Klassen, Assemblies und Namensrume sind, wie Vererbung funktioniert, auf welche Weise man die Main-Methode einsetzt, was Konstruktoren und Destruktoren sind, wie Sie Quellcode kompilieren, in welcher Weise Sie alles zusammensetzen, um eine Anwendung zu erhalten.
2.1
Ein weiterer Blick auf Ihre Anwendung
Bitte erinnern Sie sich an die gestrige Zusammenfassung. Alles Weitere baut darauf auf. Nun lassen Sie uns den gestrigen Code betrachten, den Sie in Listing 2.1 finden. Listing 2.2 zeigt den gleichen Code in C#. Weil alle Windows Forms-Anwendungen das gleiche .NET Framework verwenden, sind die Quellcodes in Visual Basic .NET und C# fast identisch, abgesehen von ein paar syntaktischen Unterschieden. Alle Konzepte in dem einen Quellcode beziehen sich auch auf den anderen. Listing 2.1: Ihre erste Visual Basic .NET-Windows Forms-Anwendung
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: Imports System Imports System.Windows.Forms Public Class HelloWorld : Inherits Form Public Shared Sub Main() Application.Run(New HelloWorld) End Sub Public Sub New() Me.Text = "Hello World!"
46
12: 13: 14:
End Sub End Class
Listing 2.2: Ihre erste C#-Windows Forms-Anwendung

1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: using System; using System.Windows.Forms; public class HelloWorld : Form { public static void Main() { Application.Run(new HelloWorld()); } public HelloWorld() { this.Text = "Hello World!"; } }
Beachten Sie, dass C# auf Gro-/Kleinschreibung achtet, so dass der Code genau so wie in Listing 2.2 geschrieben sein muss, sonst erhalten Sie Fehlermeldungen. Wir gehen hier nicht nher auf den Code ein, aber Ihnen werden einige hnlichkeiten auffallen. Es finden sich Namensrume, Klassen, Methoden und eine Main-Methode in beiden Listings. In den folgenden Abschnitten gehen wir auf diese einzelnen Begriffe ein.
Klassen
Wenn Sie noch keine OOP-Sprache verwendet haben, drfte Ihnen der obenstehende Code merkwrdig erscheinen. Lassen Sie uns zunchst Zeile 4 in beiden Listings betrachten, denn sie enthlt die wichtigsten Konzepte. Diese Zeile deklariert unsere Klasse namens HelloWorld. Eine Klasse ist im Wesentlichen die Definition eines Objekts. In der Klasse bestimmen Sie die individuellen Eigenschaften sowie die Funktionen, die andere Objekte vielleicht einmal nutzen. Stellen Sie sich eine Klasse wie eine Blaupause oder einen Bauplan fr ein Haus vor. Die Blaupause selbst ist nicht gerade reich an Funktionen; man kann kaum etwas damit tun. Sie legt jedoch alles fest, was das Haus bentigt: wohin die Tren und die Lampen kommen, die Zimmergre, die Leitungen und das ganze brige Innenleben eines Hauses. Ein Bauleiter benutzt die Blaupause bzw. einen Bauplan, um das tatschliche Haus zu
47
erbauen, das ein gebrauchsfertiges Objekt darstellt: Sie knnen die Tren ffnen und schlieen, die Wandfarbe ansehen (und ndern) usw. hnlich wie eine Blaupause legt eine Klasse das ganze Innenleben eines Objekts fest. In unserem Fall entsprche der Bauleiter der CLR, denn sie untersucht die Blaupausen und wandelt sie zu etwas Brauchbarem um: zu einem Objekt oder einer Anwendung. Somit knnen die Benutzer Ihres Objekts Methoden ausfhren, die Sie festgelegt haben, und verfgbare Eigenschaften untersuchen. Kurz und gut: Sie erstellen eine Klasse, die von der CLR in etwas Ntzliches umgewandelt wird. Der jeweilige Benutzer des Objekts braucht sich nicht darum zu kmmern, wie das Innere definiert ist, sondern benutzt es einfach genau wie ein Hausbewohner im Allgemeinen nicht wissen muss, wie die Klimaanlage funktioniert, solange sie nur zuverlssig ihren Dienst versieht. Diese Abstraktion von Komplexitt wird als Kapselung bezeichnet. Mit Hilfe von Klassen kapseln Sie die Einzelheiten und Implementierungsdetails, so dass sich der Benutzer nicht darum zu kmmern braucht. Abbildung 2.1 illustriert den Begriff der Kapselung.
Public Class Hello end class
1. Was der Benutzer nicht zu sehen bekommt
2. Die CLR erzeugt das Objekt
Object
3. Was der Benutzer sieht und verwendet
Abbildung 2.1: Die CLR kapselt Ihre Klassenbauplne in einem Objekt.
Wenn Ihnen diese Vorstellung immer noch nebuls vorkommt, sorgen Sie sich nicht. Wenn wir diese und andere Klassen untersuchen, werden Sie rasch ein grundlegendes Verstndnis entwickeln. Die Wrter Klasse und Objekt werden oft synonym verwendet. Solange Sie den Unterschied kennen eine Klasse legt die innere Funktionsweise eines Objekts fest , ist das in Ordnung. Zurck zu Zeile 4: Wir mssen noch zwei Teile untersuchen. Das Schlsselwort Public bedeutet, dass diese Klasse fr andere Klassen zugnglich ist. Wenn Sie umgekehrt das Schlsselwort Private benutzen, kann keine andere Klasse diese Klasse sehen oder benutzen. Wenn sie nicht ffentlich wre, knnte sie Ihre Anwendung nicht nutzen. Es lassen sich hier ein paar weitere Schlsselwrter verwenden, so etwa Protected oder Friend, aber wir werden diese zu gegebener Zeit betrachten.
48
Der letzte Bestandteil von Zeile 4, nmlich Inherits Form, ist etwas Besonderes fr objektorientierte Programme (die C#-Version verwendet das Schlsselwort Inherits nicht, sondern einfach einen Doppelpunkt). Alles in .NET ist ein Objekt (oder eine Klasse). Daher gibt es auch eine Klasse namens Form. Sie ist die Basisklasse fr alle Windows FormsAnwendungen: Sie enthlt Funktionen, die es gestatten, dass ein Formular angezeigt, geschlossen, bewegt und skaliert werden kann. Daher muss jede von Ihnen erstellte Windows Forms-Anwendung auf diese Form-Klasse zugreifen. Das Schlsselwort Inherits teilt der CLR mit, dass alle Eigenschaften und Methoden in dieser Form-Klasse automatisch Ihrer Klasse HelloWorld hinzugefgt werden sollen. Das bedeutet, die Klasse HelloWorld erbt sie von der Klasse Form. Ebenso wie Sie Ihre blauen oder braunen Augen von Ihren Eltern geerbt haben, erbt die HelloWorld-Klasse von ihrer Elternklasse Form die Fhigkeit, ein Fenster am Bildschirm anzuzeigen. Die Form-Klasse erbt ihrerseits von einer anderen Klasse namens ContainerControl, welche von der Klasse Control erbt, welche ihrerseits von der Klasse Component erbt und so weiter und so fort. Allen liegt die Object-Klasse zu Grunde, die Urahnin aller .NET-Klassen. Sie enthlt Eigenschaften, die alle anderen Klassen gemeinsam nutzen. Wenn Sie also wissen, wie Sie mit einem Objekt interagieren, knnen Sie demzufolge auch mit allen seinen Abkmmlingen interagieren. Jeder Abkmmling erbt Merkmale von allen seinen Vorgngern. Vererbung erspart uns eine ganze Menge Codeschreiben bzw. Umschreiben. Vererbung erleichtert auch das Erlernen neuer Klassen. Sofern Sie wissen, wie Sie mit ihren Basisklassen umgehen, verstehen Sie auch mit einer neuen Klasse umzugehen. An Tag 3 werden wir die Klasse Form genauer unter die Lupe nehmen. Da Sie nun ber Klassen Bescheid wissen, sollten Sie auch erfahren, dass auch die Form-Klasse Public ist. Sonst wre Ihre Klasse HelloWorld nicht in der Lage, darauf zuzugreifen. Nur nicht-Private Mitglieder der Form-Klasse werden vererbt. Nicht nur Klassen knnen erben, sondern auch Methoden, und zwar mit der gleichen Syntax. Klassen und Vererbung sind die zwei wichtigsten Konzepte in der OOP. Sobald Sie diese einmal verstanden haben, fllt Ihnen der Rest wesentlich leichter. ber diese Themen erfahren Sie mehr im ganzen restlichen Buch.
Namensrume und Assemblies

Die Zeilen 1 und 2 in Listing 2.1 enthalten ein weiteres wesentliches Element von Windows Forms-Anwendungen: das Schlsselwort Imports (in C# lautet es using, wie Sie in Listing 2.2 sehen). Wie Sie bereits erfahren haben, erlaubt Ihnen dieses Schlsselwort, Sammlungen anderer Klassen in Ihrer Anwendung zu verwenden. Solche Sammlungen werden als Namensrume bezeichnet. Sie dienen dazu, miteinander verwandte Klassen zu gruppieren.
49
In Zeile 1 importiert die Anwendung den Namensraum System. Innerhalb des Namensraumes System befinden sich zahlreiche Objekte und Klassen, die Ihre Anwendung nutzt, selbst wenn Sie es nicht wissen. Beispielsweise sind die gebruchlichen Datentypen Integer und String Bestandteil des Namensraumes System. Wenn Sie also eines dieser Objekte nutzen, ist es gut, den Namensraum System zu importieren (zwar eine gute Idee, aber nicht zwingend). Die Zeile 2 importiert den Namensraum System.Windows.Forms, welcher die Klasse Forms enthlt. Der Forms-Namensraum ist einer von vielen im Windows-Namensraum, und dieser ist wiederum nur einer von vielen im System-Namensraum. Namensrume sind hierarchisch organisiert, um ihre Nutzung intuitiv und einfacher zu machen, insbesondere dann, wenn man schon die OOP-Grundbegriffe versteht. Ein paar der gebruchlicheren Namensrume sind:

System System.Data System.Drawing System.Net System.Security System.Web System.Web.UI System.Web.Services System.Windows System.Windows.Forms System.Xml
Der Umstand, dass Namensrume hierarchisch untereinander angeordnet sind, bedeutet nicht notwendigerweise, dass der eine irgendetwas vom anderen erbt. Namensrume sind im Unterschied zu Klassen lediglich Sammlungen von Objekten aus ihnen werden keine nutzbaren Objekte erstellt. Man verwendet sie lediglich aus organisatorischen Grnden. Natrlich knnen Sie leicht Ihre eigenen Namensrume erstellen. Es mag an diesem Punkt noch nicht ntig sein, aber sobald Sie komplexere Anwendungen erzeugen, die aus mehr als einer Quellcodedatei bestehen, wollen Sie sie vielleicht in einem Namensraum gruppieren. Beispielsweise so:
Namespace MyNamespace Public Class MyClass : Inherits Form 'etwas mehr Code End Class End Namespace
50
Der restliche Code bleibt genau, wie er ist. Sie haben ihn nur mit einem Namensraum umgeben. In diesem Fall wird der Namensraum MyNamespace genannt. Sie knnen ihn auch vorhandenen Namensrumen hinzufgen:
Namespace System.Windows.Forms
Es hngt alles davon ab, wie Sie diese Dinge gruppieren mchten. Wie gesagt, brauchen Sie Namensrume nicht unbedingt zu importieren. Dieses Vorgehen erlaubt Ihnen jedoch, weiter unten in Ihrem Code Kurzbefehle, also Abkrzungen, zu verwenden. Wenn Sie beispielsweise Zeile 2 aus Listing 2.1 entfernen wrden, mssten Sie Zeile 4 von
Public Class HelloWorld: Inherits Form
in
Public Class HelloWorld: Inherits System.Windows.Forms.Form
ndern. Mit anderen Worten: Sie htten dann den gesamten Namensraum-Namen fr die Form-Klasse zu spezifizieren. Das Gleiche gilt fr die Klasse System: Wenn Sie sie nicht importieren, wrden Ihre Datentypen wie System.Integer statt nur wie Integer aussehen.
Ich empfehle Importieren Sie Namensrume mit dem Schlsselwort Imports, wenn Sie Klassen verwenden werden, die in diesem Namensraum enthalten sind; das hilft bei der Organisation und spart Zeit. Bitte beachten Sie Verlassen Sie sich nicht auf die Verwendung des kompletten Namensraum-Namens fr alle Ihre Objekte, selbst wenn Sie meinen, dass Ihnen das hilft, Klassen zu unterscheiden. Dieses Vorgehen blht Ihren Code auf und erschwert es, auf Ihr Objekt in der Hierarchie zu verweisen. Gelegentliche Verwendung ist in Ordnung, aber bertreiben Sie es nicht.
Wenn Sie in Ihrer Anwendung keinen Namensraum festlegen, wird automatisch ein Standardnamensraum auch als Globaler Namensraum bezeichnet erzeugt. Er hat keinen eigentlichen Namen und dient lediglich dazu, die Klassen zu gruppieren, die nicht explizit in einem Namensraum deklariert wurden. Namensrume sind also logische Gruppierungen verwandter Klassen, aber das sagt noch lange nichts ber ihre physische Position aus. Sie knnen diverse Quellcode-Dateien in verschiedenen Teilen Ihrer Festplatte abgelegt haben, aber alle knnen demselben Namensraum angehren. Um mehrere Dateien und Namensrume an einer einzigen Stelle zusammenzufassen, benutzt man Assemblies. Das sind physische Dateien auf Ihrer Festplatte, die die von Ihnen erstellten Klassen enthalten (meist mit der Endung .dll). Sie knnen mehrere Klassen oder Namensrume in einer einzelnen Assembly unterbringen.
51
Beispielsweise werden Sie in Ihrem Ordner c:\winnt\Microsoft.NET\Framework\version\ die Datei system.dll entdecken. Diese Assembly enthlt die Namensrume System, System.CodeDom (und dessen Unternamensrume), System.ComponentModel, System.Net (und dessen Unternamensrume) und noch ein paar andere. Wie man sie verwendet, untersuchen wir etwas spter heute im Abschnitt Das Kompilieren von Windows Forms. Tabelle 2.1 listet die verschiedenen .NET-Assemblies und die darin enthaltenen Namensrume auf.
Assembly
custommarshalers.dll mscorlib.dll
Namensrume
Runtime.InteropServices.CustomMarshalers Collections, Configuration.Assemblies, Diagnostics.SymbolStore, Globalization, IO, IO.IsolatedStorage, Reflection, Reflection.Emit, Resources, alle Runtime.*-Namensrume (auer jenen in CustomMarshalers.dll, System.Runtime.Remoting.dll und System.Runtime.Serialization.Formatters.Soap.dll), Security, Security.Cryptography, Security.Cryptography.X509Certificates, Security.Permissions. Security.Policy, Security.Principal, Text, Threading System, CideDom, CodeDom.Compiler, Collections.Specialized, ComponentModel, ComponentModel.Design, Configuration, Diagnostics, Net, Net.Sockets, Text.RegularExpressions, Timers Configuration.Install
system.dll
system.configuration.install.dll system.data.dll system.design.dll
Data, Data.Common, Data.OleDb, Data.SqlClient, Data.SqlTypes ComponentModel.Design.Serialization, Web.UI.Design, Web.UI.Design.WebControls, Windows.Forms.Design DirectoryServices
system.directoryservices.dll system.drawing.dll
Drawing,Drawing.Drawing2D, Drawing.Imaging, Drawing.Printing, Drawing.Text Drawing.Design
system. drawing.design.dll
system.enterpriseser- EnterpriseServices, System.EnterpriseServices.CompensatingResourcevices.dll Manager system.management.dll Management, Management.Instrumentation system.messaging.dll Messaging
Tabelle 2.1: NET-Assemblies und -Namensrume
52
Assembly
system.runtime. remoting.dll
Namensrume
Runtime.Remoting.Channels, Runtime.Remoting.Channels.Http, Runtime.Remoting.Channels.Tcp, Runtime.Remoting.MetadataServices system.Runtime.Serialization.Formatters.Soap.dll
Runtime.Serialization.Formatters.Soap
system.security.dll system.serviceprocess.dll system.web.dll Security.Cryptography.Xml ServiceProcess
Web, Web.Caching, Web.Configuration, Web.Hosting, Web.Mail, Web.Security, Web.SessionState, Web.UI, Web.UI.HtmlControls, Web.UI.WebControls Web.Services, Web.Services.Configuration, Web.Services.Description, Web.Services.Discovery, Web.Services.Protocols Windows Forms
system.web.services.dll system.windows.forms.dll system.xml.dll
Xml, Xml.Schema, Xml.Serialization, Xml.Path, Xml.Xsl
(Soweit nicht anders spezifiziert, sind alle Namensrume Sub-Namensrume des Namensraums System.) Tabelle 2.1: NET-Assemblies und -Namensrume (Forts.)
Es gibt eine Menge Namensrume in Tabelle 2.1, von denen Sie manche in diesem Buch nie verwenden werden. Hufig mssen Sie aber wissen, zu welchen Assemblies sie gehren, um Ihre Anwendungen kompilieren zu knnen. Wenn Sie mit lteren Methoden der Windows-Programmierung vertraut sind, drften Sie die .dll-Endung wiedererkennen, die fr Dynamically Linked Libraries steht diese DLLs sind Assemblies hnlich. Sie stellten Objekte bereit, die von anderen Anwendungen genutzt werden konnten. DLL-Dateien werden sowohl in .NET als auch in Pr-.NET gebraucht. Denken Sie aber daran, dass .NET-DLL-Dateien in MSIL geschrieben und vllig objektorientiert sind. Pr-.NET-DLLs sind weder das eine noch das andere und leider gibt es keine Methode, um den Unterschied schon auf den ersten Blick zu erkennen. Assemblies benutzt man nicht nur fr das Gruppieren von Namensrumen. Sie sind eine wichtige Komponente des .NET Frameworks, da sie die Grenzen zwischen Anwendungen darstellen, mit denen die CLR die Gltigkeitsbereiche Sicherheit, Versionierung und Metadaten erzwingt. Beim Entwickeln mit Windows Forms werden Sie Assemblies sehr hufig verwenden.
53
Die Main-Methode
Sehen wir uns noch einmal die Zeilen 6, 7 und 8 in Listing 2.1 an:
6: 7: 8: Public Shared Sub Main() Application.Run(New HelloWorld) End Sub
Wenn Sie wissen, was Methoden sind, haben Sie diesen Code bereits zur Hlfte verstanden. Eine Methode ist ein Codestck, das eine Funktion ausfhrt; sie bewirkt etwas. Code, der irgendeine Funktion ausfhrt, von der einfachsten Addition bis zu den kompliziertesten Threading-Routinen, muss immer in einer Methode untergebracht werden. In Visual Basic .NET gibt es zwei Methodentypen: Sub und Function. Sub macht etwas und endet dann. Function hingegen bewirkt etwas und sendet dann Daten an diejenige Instanz zurck, die die Methode aufgerufen hat. (Nichts hindert Sie, eine Function ohne Rckgabewert aufzusetzen; aber das Umgekehrte geht nicht: Eine Sub-Methode kann keine Daten zurckgeben.) In C# hingegen ist eine Methode eine Methode. Es wird keine Unterscheidung danach gemacht, ob die Methode Daten liefert oder nicht. Sie mssen in C# jedoch den Datentyp der zurckzugebenden Daten spezifizieren oder void, wenn keine Daten zurckgegeben werden. Beispielsweise sagt die Zeile
6: public static void Main() {
in Listing 2.2 aus, dass diese Methode nichts liefert, wohingegen die folgende Codezeile einen Integer zurckgibt:
6: public static int Main() {
Sie knnen automatisch ein paar Schlsse ziehen: Sie deklarieren eine void-Funktion (sub in VB .NET), sie wird Main genannt und ist public (Public in VB .NET), was bedeutet, dass andere Klassen darauf zugreifen knnen. Das Schlsselwort static (bzw. Shared) ist hingegen etwas Neues. Um es zu verstehen, mssen wir wieder zurckgehen zu Objekten und Klassen.
Objektinstanzen
Aus einer einzelnen Klasse (oder Blaupause) lassen sich mehrere Objekte dieser Klasse erzeugen. Jedes einzelne Objekt bezeichnet man als eine Instanz. Das Auto-Objekt eine wirkliche, physische, gebrauchsfertige Sache wre eine Instanz des Auto-Konzepts oder der Klasse. Man kann also ein Objekt haben, aber viele Instanzen: einen Mercedes SLK, einen VW Kfer oder einen Opel Tigra all dies sind Instanzen eines Autos. Sie gleichen einander nicht ganz, aber sie alle haben das grundlegende Konzept eines Autos gemeinsam.
54
Abbildung 2.2 zeigt zwei Instanzen des Objekts Standuhr. Beachten Sie, dass sie nicht die gleiche Zeit anzeigen, doch irgendwie wei man, dass beide Standuhren sind. Somit kann man viele Instanzen eines Objekts haben, von denen jede unterschiedliche Eigenschaften besitzt.
Standuhr A: 1:27
Standuhr B: 9:54
Abbildung 2.2: Zwei Instanzen eines Standuhr-Objekts knnen unterschiedliche Eigenschaften besitzen.
Das Gleiche lsst sich ber OOP und Objekte sagen. Die Klasse definiert den theoretischen Begriff eines Objekts HelloWorld, erzeugt aber keine Instanzen. Es ist anderen Objekten berlassen, diese Instanzen zu erzeugen, wenn sie gebraucht werden (gleich mehr darber). Wenn Sie vor einer Methode das Schlsselwort Shared oder static verwenden, bedeutet dies, dass die Methode oder Eigenschaft allen Instanzen dieses Objekts zur Verfgung steht und fr alle Instanzen gleich ist. Beispielsweise sind alle Autos aus Blech gefertigt und der Einfachheit halber sagen wir, dass das Blech das gleiche fr jedes Auto ist. Dies wre eine static-Eigenschaft: Die Metallart ndert sich nicht von Auto zu Auto. Alle Autos nutzen auerdem das Konzept der Farbe gemeinsam, haben aber nicht alle die gleiche Farbe; dies wre dann nicht static. Die Schlsselwrter sind selbsterklrend: Einzelwerte oder einzelne Methoden knnen Shared sein (in VB .NET), wenn alle Objekte sie gemeinsam nutzen (jedes Objekt hat nicht seine eigene Kopie), oder static (in C#), was bedeutet, dass sie sich nicht von einer Instanz zur nchsten ndern. Die Begriffe Shared und static sind im .NET Framework recht gebruchlich. Daher ist es sehr wichtig, dass Sie ein solides Grundverstndnis dafr erwerben. Fr den Moment mag es gengen zu wissen, dass Ihre Main-Methode stets entweder static oder Shared sein muss.
Das Eingangstor zum Code

Die Main-Methode ist auch als Einsprungspunkt zu einer Anwendung bekannt: Bei jedem Start Ihrer Anwendung wird die Main-Methode stets als erstes ausgefhrt. Verfgt Ihr Programm ber keine Main-Methode, wird es einfach nichts tun (man bekommt eine Fehler-
55
meldung wohl schon lange, bevor man es ausfhren will). Die Main-Methode wird auch als letztes ausgefhrt. Wenn Ihr Code mit der Ausfhrung fertig ist, kehrt er stets zu dieser Methode zurck. Der Main-Methode kommt also eine hohe Bedeutung zu. Entweder lsst sich der gesamte Programmcode in der Main-Methode unterbringen oder Main kann andere Methoden aufrufen. Von Main aus knnen Sie bestimmen, welches Formular anzuzeigen ist (viele Anwendungen knnen mehr als ein Windows Form-Objekt enthalten), Variablen festlegen, die von der restlichen Anwendung verwendet werden, oder beliebige weitere Vorbereitungsschritte ausfhren. In unserer Main-Methode wird eine einzige Codezeile ausgefhrt:
Application.Run(New HelloWorld)
Diese Zeile ruft die Run-Methode des Application-Objekts (einen Teil des Namensraums System.Windows.Forms) auf. Die Run-Methode befiehlt dem Programm, in eine Nachrichtenschleife einzutreten. Das ist im Grunde die Art und Weise eines Programms, auf Eingaben vom Benutzer zu warten. Der Eintritt in eine Nachrichtenschleife ist vom Standpunkt des Benutzers aus fast immer der Startpunkt einer Anwendung. Morgen werden Sie mehr ber Nachrichtenschleifen erfahren. Sie bergeben der Run-Methode eine Instanz Ihres Objekts HelloWorld. (Bitte beachten Sie, dass wir von einer Klasse zu einem Objekt bergegangen sind: Das New-Schlsselwort erstellt eine Objektinstanz.) Das weist die Run-Methode an, Ihr Formular auf dem Bildschirm fr den Dialog mit dem Benutzer anzuzeigen. Moment mal! Warum mssen wir eine Instanz der HelloWorld-Klasse an die Run-Methode bergeben? Drfte das nicht zu einer Endlosschleife fhren? Schlielich wird die MainMethode erneut ausgefhrt, bergibt eine neue Instanz und so weiter. Nicht ganz. Um dies zu verstehen, mssen Sie zwischen einer Klasse und einer Anwendung unterscheiden. Wenn eine neue Instanz einer Klasse erzeugt wird, passiert nichts (es sei denn, man htte einen Konstruktor erzeugt, aber so weit sind wir noch nicht). Wenn eine Anwendung startet, sucht sie zuerst nach einer Main-Methode, ganz gleich, wo sie diese findet oder ob sie sich in einer Klasse befindet, solange es sie nur gibt und sie in einer Klasse untergebracht ist. Main wird nur ein einziges Mal ausgefhrt, wenn Ihre Anwendung gestartet wird, und danach nicht mehr. Anders ausgedrckt, wird Main bei jeder Anwendungsausfhrung gestartet, aber nicht immer dann, wenn eine Klasse erzeugt wird. Obwohl die Main-Methode ganz normal aussieht, fhrt jeder Versuch, sie von einem anderen Punkt in Ihrem Programm aus aufzurufen, zu einer Fehlermeldung, wie sie in Abbildung 2.3 zu sehen ist.
56
Abbildung 2.3: Eine Fehlermeldung erfolgt, wenn man versucht, die Main-Methode im Code auszufhren.
Obwohl nun Zeile 7 in Listing 2.1

eine neue Instanz der Klasse HelloWorld erzeugt, wird die Main-Methode nicht erneut ausgefhrt. Um die Trennung zwischen der HelloWorld-Klasse und der Main-Methode noch weiter zu unterstreichen, knnten Sie die Main-Methode in eine vllig andere Klasse stecken, und sie wrde weiterhin funktionieren, wie Sie in Listing 2.3 sehen. Kurz und gut, Sie brauchen fr eine Anwendung eine Main-Methode, die sich in einer Klasse befinden muss doch diese Klasse knnen Sie willkrlich auswhlen. Listing 2.3: Die Main-Methode lsst sich in jeder Klasse unterbringen
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: Imports System Imports System.Windows.Forms Public Class HelloWorld : Inherits Form Public Sub New() Me.Text = "HelloWorld!" End Sub End Class Public Class MyMainClass Public Shared Sub Main() Application.Run(New HelloWorld) End Sub End Class
Listing 2.3 ergibt wahrscheinlich etwas mehr Sinn, denn es zeigt ganz deutlich, dass die Main-Methode und die Windows Form-Klasse zwei vllig verschiedene Einheiten sind. Die Run-Methode in Zeile 12 erzeugt eine neue Instanz Ihrer Windows Form-Klasse (HelloWorld) und bewirkt, dass sie auf dem Bildschirm angezeigt wird.
57
Die Methode New (oder HelloWorld in C#) im Schlussteil von Listing 2.3 wird als Konstruktor bezeichnet. Das ist eine Methode, die ausgefhrt wird, sobald eine neue Instanz einer Klasse erzeugt wird. Sie hat eine Partner-Methode namens Destruktor. Wir sprechen im nchsten Abschnitt ber diese zwei Methoden.
Konstruktoren und Destruktoren

Einen Konstruktor benutzt man normalerweise, um die Instanz zu initialisieren, erforderliche Variablen anzulegen und so weiter. In Visual Basic .NET hat ein Konstruktor stets den Namen New, wie die Zeilen 10 bis 12 in Listing 2.3 zeigen:
10: 11: 12: Public Sub New() Me.Text = "HelloWorld!" End Sub
Das ist sinnvoll. Erinnern Sie sich an Zeile 7 aus Listing 2.1, wie Sie New klassenname verwendet haben:
Dieser Befehl ruft die New-Methode auf. In C# nimmt der Konstruktor denselben Namen wie die Klasse selbst an, so wie in den folgenden Zeilen aus Listing 2.2:
Public HelloWorld() This Text = 'Hello World!" }
Die Me-Variable in Listing 2.1

11: Me.Text = "Hello World!"
und die this-Variable in Listing 2.2

11: thisText = "Hello World!";
sind spezielle Schlsselwrter, die auf das Objekt verweisen, in dem sich der Code jeweils befindet. In diesem Fall verweisen sie auf das Windows Form-Objekt HelloWorld. Auf diese Weise lsst sich leicht auf das umschlieende Objekt verweisen. Zeile 11 in Listing 2.1 und 2.2 weist die Zeichenfolge Hello World! der Eigenschaft Text in der HelloWorld-Klasse zu, welche, wie wir gesehen haben, die Titelzeile auf dem Windows Form festlegt. Umgekehrt wird ein Destruktor immer dann aufgerufen, wenn ein Objekt der Klasse zu entsorgen ist. In Visual Basic .NET wird dies bewerkstelligt, indem das Objekt mit nothing gleichgesetzt wird:
objHelloWorld = new HelloWorld() objHelloWorld = nothing
58
In C# erfolgt dies durch Gleichsetzung der Klasse mit null:

HelloWorld objHelloWorld = newHelloWorld(); objHelloWorld = null;
In VB .NET kann man jedoch keinen eigenen Destruktor erzeugen: Immer wenn Sie Ihr Objekt mit nothing gleichsetzen, bernimmt VB .NET die Entsorgung fr Sie. C# erlaubt es, Ihren eigenen Destruktor zu bestimmen, der durch den gleichen Namen wie der Konstruktor, aber mit einer Tilde davor deklariert wird:
~HelloWorld() { 'etwas verarbeiten }
Konstruktoren erben
In OOP gilt die Regel, dass der Konstruktor einer Klasse stets den Konstruktor seiner bergeordneten Klasse (Basisklasse) aufrufen muss. Beispielsweise erbt die Klasse HelloWorld von der Form-Klasse. Daher muss Ihre Klasse den Konstruktor der Form-Klasse aufrufen. Dieser wiederum muss den Konstruktor seiner bergeordneten Klasse aufrufen, nmlich den von ContainerControl, und so weiter, bis Sie die Wurzel des Stammbaums erreicht haben: Object. Werfen wir einen Blick darauf, warum dies notwendig ist. Sie erinnern sich, dass, sobald ein Objekt von einem anderen (seinem bergeordneten Objekt) erbt, es auch alle Eigenschaften und Methoden des anderen erbt. Manche davon knnen von bestimmten Variablen abhngen, die es zu initialisieren gilt. Stellen Sie sich beispielsweise eine Klasse vor, die eine Farbe-Eigenschaft erbt, die den Hintergrund des Formulars bestimmt. Dieser Eigenschaft muss ein echter Wert zugewiesen werden, bevor man sie verwenden kann, sonst erhlt man eine Fehlermeldung (schlielich lsst sich die Hintergrundfarbe nicht auf nichts setzen). Die Farbe-Eigenschaft wrde im Konstruktor Ihrer bergeordneten Klasse initialisiert werden. Daher mssen Sie den Konstruktor der Basisklasse aufrufen, damit die Farbe-Eigenschaft eine Bedeutung erhlt. Diese Abhngigkeit von Basisklassen besagt zweierlei. Erstens hngen viele Klassen, die von anderen erben, von ihren Basisklassen ab, um so Informationen zu erhalten. Und zweitens bedeutet es, dass Sie in Ihrem Konstruktor weniger Initialisierungscode schreiben mssen, weil schon vieles in den Konstruktoren der Ihrer Klasse bergeordneten Klassen erledigt worden ist. Der Aufruf des Konstruktors der Basisklasse ist in Ihrem Konstruktor als allererstes zu erledigen. In VB .NET erfolgt dies durch den Aufruf der Methode MyBase.New, in C#, indem Sie Ihren Konstruktor zum Ausfhren der Methode base() veranlassen:
'VB .NET Public Sub New() MyBase.New End Sub
59
'C# public HelloWorld(): base() { }
In all dem Code, den Sie heute geschrieben haben (Listings 2.1 bis 2.3), fehlen diese Aufrufe, doch warum erhalten wir dann keine Fehlermeldungen? Wenn Sie in Ihrer Klasse nur einen Konstruktor haben (mehr ber multiple Konstruktoren im nchsten Abschnitt), ruft die CLR automatisch den Konstruktor der Basisklasse auf. Daher knnen Sie diese Zeilen weglassen.
Konstruktoren berladen
Manchmal mchten Sie mehr als einen Konstruktor haben. Ein ntzliches Beispiel dafr bestnde darin, dass Sie dem Benutzer erlauben mchten, auf mehr als eine Weise zu initialisieren: so etwa eine, die einen Wert fr eine Variable erfordert, und eine, die keinen Wert erfordert. Sie knnen dies durch einen Vorgang namens berladen erledigen. Zum besseren Verstndnis dieses Konzepts schauen wir uns den Code an, wie er in Listing 2.4 abgedruckt ist. Listing 2.4: Konstruktoren in C# berladen
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: using System; using System.Windows.Forms; public class HelloWorld : Form { public static void Main() { Application.Run(new HelloWorld()); } public HelloWorld(): this("Hello World!") {} public HelloWorld(string strText): base() { thisText = strText; } }
Lassen Sie uns zunchst in Zeile 12 springen. Hier sehen wir einen Konstruktor, der einen string-Wert als Parameter bernimmt. Die Text-Eigenschaft des Formulars wird in Zeile 13 auf diesen Parameter eingestellt. Schlielich ruft dieser Konstruktor mit der base()-Methode den Konstruktor der Basisklasse auf. Soweit also nichts Neues.
60
In Zeile 10 stoen wir auf etwas, das wie ein weiterer Konstruktor aussieht. Doch dieser bernimmt keine Parameter und verfgt ber keinen Initialisierungscode. Schauen Sie aber mal auf den Code nach dem Doppelpunkt. Er ruft this auf, von dem wir wissen, dass es eine Referenz auf das aktuelle Objekt ist, und bergibt ihm die Zeichenfolge Hello World!. Was bewirkt dies? Zeile 10 besagt, dass im Fall des Aufrufs dieses Konstruktors statt dessen der Konstruktor in Zeile 12 aufgerufen und ihm als Parameter die Zeichenfolge Hello World! bergeben werden soll. Die Ausfhrung geht dann zu den Zeilen 12 und 13 ber, die Text-Eigenschaft wird auf Hello World! gesetzt. Im Grunde sagen Sie also, dass der Parameter strText optional ist: Wenn kein Parameter angegeben ist, verwendet der Konstruktor die Standardzeichenfolge Hello World!. Zeile 7, die einen Konstruktor aufruft, knnte also entweder so
Application.Run(new HelloWorld());
oder so
Application.Run(new HelloWorld("I love NY"));
aussehen. Dies ruft den jeweils passenden Konstruktor auf, je nachdem, ob Parameter bergeben wurden. Der Konstruktor in Zeile 10 knnte sogar seine eigenen Initialisierungsroutinen ausfhren und braucht den Konstruktor in Zeile 12 nicht aufzurufen, wenn man nicht will. In VB .NET sieht die Syntax etwas anders aus, wie man in Listing 2.5 sehen kann. Listing 2.5: Konstruktoren in VB .NET berladen
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: Imports System Imports System.Windows.Forms Public Class HelloWorld : Inherits Form Public Shared Sub Main() Application.Run(New HelloWorld) End Sub Public Sub New() Me.New("Hello World!") End Sub Public Sub New(strText as String) Me.Text = strText End Sub End Class
61
In Zeile 11 verwenden Sie das Schlsselwort Me und rufen die New-Methode auf, wobei Sie eine Standardzeichenfolge bereitstellen. Die dem Listing 2.5 zugrunde liegenden Konzepte sind die gleichen wie in Listing 2.4. Beachten Sie, dass Sie keineswegs einen Konstruktor erzeugen mssen. Wenn Sie keinen erzeugen, dann erzeugt VB .NET (oder C#) einen fr Sie. Dieser automatisch generierte Konstruktor ruft nur den Konstruktor der Basisklasse auf. Konstruktoren sind nicht die einzigen Methoden, die Sie berladen knnen. Doch in VB .NET mssen Sie das Schlsselwort Overloads vor jede Methode stellen, die berladen wird (Konstruktoren natrlich ausgenommen), und zwar vor dem Schlsselwort Public.
Ein abschlieender Blick auf den Programmcode

Nach der Untersuchung aller Codebestandteile lassen Sie uns rekapitulieren. Listing 2.1 ist erneut in Listing 2.6 zu sehen. Listing 2.6: Ihre erste Windows Forms-Anwendung in VB .NET
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: Imports System Imports System.Windows.Forms Public Class HelloWorld : Inherits Form Public Shared Sub Main() Application.Run(New HelloWorld) End Sub Public Sub New(strText as String) Me.Text = strText End Sub End Class
Die Zeilen 1 und 2 bestimmen die Namensrume, die in Ihre Anwendung importiert werden. Die Mitglieder dieser Namensrume stehen Ihrer Anwendung in Form ihrer Kurznamen (also Form anstelle von System.Windows.Forms.Form) zur Verfgung. Zeile 4 deklariert Ihre Klasse und die Tatsache, dass sie von der Form-Klasse erbt, der Basisklasse fr alle Windows Forms-Anwendungen. Zeile 6 startet die MainMethode, den Einsprungspunkt Ihrer Anwendung. Sie ruft die Run-Methode
62
Das Kompilieren von Windows Forms
auf, welche das Formular zur Darstellung auf dem Bildschirm und zum Warten auf Benutzereingaben veranlasst. Sie bergeben eine neue Instanz Ihrer Klasse, um ihr mitzuteilen, welches Formular angezeigt werden soll. Die Zeilen 10 bis 12 bilden einen Konstruktor fr die HelloWorld-Klasse. In Zeile 11 weisen Sie lediglich der Text-Eigenschaft in Ihrem Formular die Zeichenfolge Hello World! zu. Das ndert die Titelzeile Ihrer Anwendung. Sobald Sie einmal die Grundlagen verstanden haben, knnen Sie erkennen, wie einfach dieser Quellcode war. Jetzt kennen Sie alle Komponenten, die fr die Erstellung von Windows Forms notwendig sind, und knnen anfangen, Ihre eigene Windows Forms-Anwendung zu erstellen!
2.2
Der nchste Schritt bei der Anwendungserstellung besteht im Kompilieren Ihres Quellcodes zu MSIL. Die Vorgehensweise variiert je nach der verwendeten Programmiersprache, doch sie ist stets recht hnlich. Die einfachste Kompiliermethode besteht in der Verwendung von Visual Studio .NET. VS .NET ist eine integrierte Entwicklungsumgebung (IDE), die Ihnen die Erstellung beliebiger Anwendungstypen an einem zentralen Ort erlaubt, ganz gleich welche Programmiersprache Sie benutzen. Lassen Sie uns einen kleinen Rundgang durch diese Entwicklungsumgebung machen und betrachten, wie man hier Code schreiben und kompilieren kann. ffnen Sie VS .NET und starten ein neues Projekt, indem Sie NEU/PROJEKT aus dem DATEI-Men auswhlen. Das Dialogfeld NEUES PROJEKT (Abbildung 2.4) erscheint.
Abbildung 2.4: Das Dialogfeld NEUES PROJEKT stellt Ihnen eine VB .NET- oder C#-Anwendung zur Auswahl.
63
Whlen Sie mit Hilfe dieses Dialogs eine Anzahl verschiedener Optionen sowohl fr C# als auch fr Visual Basic .NET. Klicken Sie in der linken Fensterhlfte auf VISUAL BASICPROJEKTE und in der rechten auf WINDOWS-ANWENDUNG. Whlen Sie einen passenden Namen und einen Speicherplatz fr dieses Projekt und klicken Sie auf OK.
PEN-EXPLORER
Sobald VS .NET mit der Verarbeitung fertig ist, zeigt es ein neues Projekt im PROJEKTMAP(obere rechte Ecke der VS .NET-Anwendung) an, mit diversen Dateien darunter (siehe Abbildung 2.5).
Zunchst finden Sie einen Ordner namens VERWEISE, der alle Namensrume anzeigt, die Ihre Anwendung verwenden wird; beachten Sie bitte, dass sich innerhalb des Ordners (auf das Plus-Zeichen klicken, um ihn aufzuklappen) bereits einige Namensrume befinden, die fr Sie vorgegeben sind. Wenn Sie mit den Statements using oder Imports einen Namensraum haben wollen, der sich nicht hier befindet, mssen Sie den Namensraum hinzufgen, indem Sie mit der rechten Maustaste auf den Ordner klicken und VERWEIS HINZUFGEN auswhlen. Daraufhin erscheint ein Dialogfenster, das Ihnen bei der Auswahl einer Assembly hilft. Die nchste ist die Datei AssemblyInfo.vb, die verwendet wird, um Informationen ber Ihre Assembly bereitzustellen. Schlielich findet sich noch eine Datei namens Form1.vb, worin Ihr Code abgelegt wird. ffnen Sie diese Datei mit einem rechten Mausklick und der Auswahl CODE ANZEIGEN. Ihr Fenster sollte nun hnlich aussehen wie in Abbildung 2.5.
Abbildung 2.5: Ihre leere Windows Forms-Anwendung wird im Projektmappen-Explorer angezeigt.
In VS .NET wird ein einfach zu bedienender Quellcode-Editor mitgeliefert. Er gruppiert hnliche Dinge wie etwa Klassen, und er erlaubt Ihnen, sie auszublenden (indem Sie auf das Minus-Symbol links daneben klicken), um so die Arbeitsumgebung bersichtlicher zu
64
machen. Beachten Sie auch, dass VS .NET etwas Code fr Sie erzeugt hat, den Sie in dem Code-Bereich im Windows Forms-Designer finden. Diesen Code werden wir hier nicht besprechen, aber wenn Sie mal durchblttern, dann werden Sie zumindest eine Methode wiedererkennen: den Konstruktor der Klasse. Mit dem restlichen Code integriert VS .NET Ihre Anwendung in die Entwicklungsumgebung. (Das soll nicht bedeuten, dass Sie den Code nicht lschen knnten, wenn Sie wollen.) Sie knnen nun Ihren Code an beliebiger Stelle zwischen den Zeilen Public Class und End Class einfgen. Sie knnen auch den Namen der Klasse bearbeiten. Das Eigenschaftenfenster unten rechts gestattet Ihnen die nderung des gespeicherten Dateinamens, des Autorennamens und anderer Attribute. Sobald Sie den Code geschrieben haben, whlen Sie im Men ERSTELLEN den Befehl ERSTELLEN, um Ihre Anwendung zu erzeugen. Befinden sich Fehler im Code, werden sie in einem Ausgabe-Fenster angezeigt. Luft alles erfolgreich ab, dann erzeugt VS .NET eine .EXE-Datei (der Dateiname hngt vom gewhlten Projektnamen ab), die Sie wie jede beliebige Anwendung ausfhren knnen. VS .NET enthlt zahlreiche Funktionen, die hier nicht vorgestellt werden. Erforschen Sie die Entwicklungsumgebung weiter und schreiben Sie Ihren Code. Wenn Sie lieber nicht mit VS .NET arbeiten wollen oder keinen Zugang dazu haben, knnen Sie Ihren Code mit dem jeweils ntigen Befehlszeilen-Compiler kompilieren. Das ist ein einfaches Programm, das einige Parameter bernimmt (darunter Ihre QuellcodeDatei) und eine kompilierte EXE-Datei ausspuckt. Der ntige Compilerbefehl ist entweder vbc.exe (fr Quellcode in Visual Basic .NET) oder csc.exe (fr Quellcode in C#). Fr beide Methoden ist die Syntax dieselbe, daher betrachten wir hier nur die erste:
vbc optionen quellcodedatei
In seiner einfachsten Form sieht Ihr Befehl wie folgt aus:

vbc helloworld.vb
Tabelle 2.2 fhrt die gebruchlichen Befehlszeilenoptionen auf, die Sie nutzen knnen. Geben Sie vbc /? oder csc /? In der Befehlszeile ein, um alle Optionen anzusehen.
Option @
/bugreport
Beschreibung Spezifiziert eine Textdatei, die die fr den Befehl zu verwendenden Optionen enthlt. Sie mssen einen Dateinamen angeben: @dateiname. Erzeugt eine Fehlerberichtsdatei. Sie mssen einen Dateinamen angeben: /bugreport:dateiname.
Tabelle 2.2: Gebruchliche Befehlszeilen-Optionen fr den Compiler
65
Option
/debug
Beschreibung Gibt diverse Informationen aus. Verwenden Sie: /debug+ um Informationen auszugeben
/debug- um keine Informationen auszugeben /debug:full um alle Debugging-Informationen auszugeben (Voreinstellung)
/debug:pdbonly um lediglich die pdb-Symboldatei zu erstellen

/main
Gibt die Klasse an, die die Main-Methode enthlt. Verwenden Sie /m als Kurzform. Unterdrckt das Microsoft-Logo. Verwenden Sie binary oder text, um anzugeben, wie alle Zeichenfolgenvergleiche in Ihrem Code durchgefhrt werden sollen. Erfordert die explizite Deklaration aller Variablen vor dem Einsatz. Verwenden Sie /optionexplicit+ oder /optionexplicit-. Erzwingt strikte Befolgung der Sprachsemantik. Verwenden Sie /optionstrict+ oder /optionstrict-. Gibt die Ausgabestandort und den Namen Ihrer kompilierten MSIL-Datei an. Gibt zu referenzierende Assemblies in Ihrer Anwendung an (jene, die durch die Schlsselwrter using oder Imports spezifiziert wurden). Verwenden Sie /r als Kurzform. Gibt den Typ der zu generierenden Ausgabedatei an. Verwenden Sie /t als Kurzform. Setzen Sie ein: /t:exe fr eine ausfhrbare Konsolen-Anwendung;
/t:library fr eine DLL; /t:winexe fr eine ausfhrbare Windows-Anwendung;
/nologo /optioncompare
/optionexplicit
/optionstrict
/out /reference
/target
/t:modul fr ein Modul.

/win32icon /win32resource
Gibt das zu verwendende Symbol (.ico-Datei) fr das Anwendungssymbol an. Gibt die zu verwendenden Ressourcen-Dateien (.res-Dateien) an.
Tabelle 2.2: Gebruchliche Befehlszeilen-Optionen fr den Compiler (Forts.)
Fr unsere Anwendung verwenden wir normalerweise nur zwei Optionen: /target (Kurzform /t) und /reference (Kurzform /r). Um beispielsweise die Anwendung HelloWorld zu kompilieren, sollte das Ziel winexe sein, und wir mssen Referenzen auf die Assemblies hinzufgen, die gebraucht werden (je nach den Namensrumen, die wir importiert
66
Eine vollstndige Anwendung
haben). Wenn wir auf unseren Quellcode und die Tabelle 2.1 zurckblicken, sehen Sie, dass wir die Namensrume System und System.Windows.Forms verwenden. Sie befinden sich jeweils in den Assemblies system.dll und system.windows.forms.dll. Daher sieht unsere Befehlszeile schlielich so aus:
vbc /t:winexe /r:system.dll /r:system.windows.forms.dll HelloWorld.vb
Der Compiler erlaubt es Ihnen auch, mehrere Referenzen in einer einzigen Liste zu kombinieren. Ein Beispiel:
vbc /t:winexe /r:system.dll,system.windows.forms.dll HelloWorld.vb
Die Assembly mscorlib.dll aus Tabelle 2.1 steht automatisch allen Anwendungen zur Verfgung: Sie ist die grundlegende Assembly fr .NET. Aus diesem Grund brauchen Sie keinen expliziten Verweis dafr einzufgen. Von Ihrer Eingabeaufforderung aus veranlasst wrde der Befehl die in Abbildung 2.6 sichtbare Ausgabe erzeugen.
Abbildung 2.6: Eine erfolgreiche Kompilierung fhrt zu diesem Ergebnis.
Welchen Weg Sie auch whlen, die Kompilierung ist ein notwendiger Schritt zu Ihrer Windows Forms-Anwendung. Im restlichen Buch verwenden wir die Befehlszeilenmethode, falls nicht anders festgelegt. Anhand der Befehle knnen Sie leicht bestimmen, welche Referenzen Sie Ihrem VS .NET-Projekt hinzufgen mssen.
2.3
Da Sie nun mit allen Bestandteilen einer Windows Forms-Anwendung ausgestattet sind, knnen Sie mit dem Aufbau einer Applikation beginnen, die etwas ntzlicher als das Hello World-Programm ist. Im folgenden Abschnitt werden wir einen einfachen Taschenrechner erstellen, den Sie dann an Tag 5 und 6 erweitern.
67
Um einen Taschenrechner zu erstellen, brauchen Sie mindestens drei Dinge (neben Windows Forms):

eine Stelle, an der der Benutzer eine Zahl bzw. Zahlen eingeben kann, eine Stelle, an der er das Ergebnis sehen kann (mglicherweise an der gleichen Stelle), eine oder mehrere Schaltflchen, die es ihm erlauben, mathematische Operationen auszufhren. Der Einfachheit halber beschrnken wir uns hierbei auf die Addition.
Diese Komponenten werden von Windows Forms-Steuerelementen (Controls) bereitgestellt: interaktiven Elementen der Benutzeroberflche (englisch User Interface, abgekrzt UI). Ab Tag 4 werden wir diese Steuerelemente genauer unter die Lupe nehmen, so dass wir uns hier nicht allzu lange damit aufhalten mssen. Zunchst wollen wir einmal den grundlegenden Rahmen fr Ihre Anwendung erstellen. Dazu gehren alle Bestandteile, ber die Sie heute etwas erfahren haben. Werfen Sie einen Blick auf Listing 2.7 (der komplette C#-Code wird spter gezeigt). Listing 2.7: Das Fundament fr die Taschenrechner-Anwendung
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: Imports System Imports System.Windows.Forms Namespace TYWinforms.Day2 Public Class Calculator Public Shared Sub Main() Application.Run(New Calculator) End Sub Public Sub New() End Sub End Class End Namespace
Speichern Sie diesen Code unter dem Dateinamen Listing 2.7.vb. Im Listing gibt es nichts Neues zu entdecken. Es ist sogar fast identisch mit Listing 2.1, nur dass in Zeile 4 eine Namensraum-Deklaration auftaucht. Diese teilt der CLR mit, dass diese Klasse zum Namensraum TYWinforms.Day2 gehrt.
68
Die Calculator-Klasse wird in Zeile 6 deklariert, sie erbt von der Klasse System.Windows.Forms.Form. Die Zeilen 8 bis 10 enthalten die Main-Methode, die einfach die Run-Methode aufruft und eine neue Instanz der aktuellen Klasse als Parameter bergibt. Die Zeilen 12 bis 14 enthalten eine Konstruktor-Methode, die momentan noch leer ist in Krze fgen wir den entsprechenden Code hinzu. In dieser Anwendung bentigen wir vier Windows Forms-Steuerelemente: zwei Textfelder (TextBox) fr die Zahleneingabe, ein Bezeichnungsfeld (Label) fr die Ergebnisanzeige und eine Schaltflche (Button) fr die Erledigung der Addition. Alle diese Steuerelemente gehren dem Namensraum System.Windows.Forms an, so dass Sie sie genau wie die FormKlasse verwenden knnen. Geben Sie in Zeile 7 Ihrer Listing 2.7.vb-Datei folgenden Code ein:
Private Private Private Private WithEvents btnAdd as Button tNumber1 as TextBox tNumber2 as TextBox lblAnswer as Label
Dieser Abschnitt deklariert vier Variablen als Steuerelemente. Das Schlsselwort WithEvents bedeutet im Grunde, dass ein bestimmtes Steuerelement Aktionen ausfhren kann. Listing 2.8 zeigt die vollstndige Konstruktor-Methode. Listing 2.8: Ihre Anwendung initialisieren
12: 13: 12: 13: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: Public Sub New() Me.btnAddYour Application Public Sub New() Me.btnAddInitializing Your Application Public Sub New() Me.btnAdd = New Button Me.tbNumber1 = New TextBox Me.tbNumber2 = New TextBox Me.lblAnswer = New Label tbNumber1.Location = New Point(0,0) tbNumber2.Location = New Point(100,0) btnAdd.Location = New Point(0,25) btnAdd.Text = "addieren" AddHandler btnAdd.Click, new EventHandler(AddressOf Add) lblAnswer.Location = New Point(0,75) Me.Controls.Add(btnAdd)
69
28: 29: 30: 31:
Me.Controls.Add(tbNumber1) Me.Controls.Add(tbNumber2) Me.Controls.Add(lblAnswer) End Sub
Fgen Sie diesen Code Ihrer Datei Listing 2.7.vb hinzu. Wir gehen auch hier noch nicht auf die Spezifika der einzelnen Steuerelemente ein, sondern kmmern uns nur um die Grundlagen. Die Zeilen 13 bis 16 erzeugen neue Instanzen jedes Steuerelements. Sie fragen sich vielleicht, warum die Zeilen 13 bis 16 ntig sind, wo wir doch die Variablen schon zuvor deklariert haben. Der Grund: Im vorhergehenden Codestck erzeugten wir Variablen, gaben ihnen Namen und teilten der CLR mit, um welche Variablentypen es sich handelt. Wir haben jedoch diesen Variablen keinerlei Werte zugewiesen. Das erledigen die Zeilen 13 bis 16: Sie weisen den Variablen Objekte zu (wie durch die Gleichheitszeichen angezeigt wird). Das Erzeugen eines Objekts sei es ein Steuerelement, ein Formular oder ein anderes Objekt ist ein zweistufiger Vorgang: Deklaration der Variablen und Zuweisung eines Wertes. Es ist jedoch mglich, beide Schritte in einer einzigen Zeile auszufhren:
Dim btnAdd as Button = New Button
Oder sogar noch einfacher:

Dim btnAdd as New Button
Wir werden ab jetzt diese Kurzform verwenden. Die Zeilen 18, 19, 21 und 25 machen alle das Gleiche: Sie legen die Positionen (Locations) fr die Steuerelemente in unserem Windows Form fest. Die Eigenschaft Location bernimmt einen einzelnen Parameter des Typs Point, der die Stelle beschreibt, wo das Steuerelement platziert werden soll. Der Konstruktor fr Point bernimmt wiederum zwei Parameter (eine x- und eine y-Koordinate). Man kann zwar Steuerelemente bereinander legen, aber das ist meist nicht sonderlich ntzlich. Wir gehen morgen auf dieses Thema ein. Sie sollten bereits wissen, was Zeile 22 bewirkt: Sie setzt die Text-Eigenschaft der Schaltflche auf den Wert Addieren. Erinnern Sie sich, dass die Text-Eigenschaft des Formulars eine Titelzeile festlegt. Die gleiche Eigenschaft fr einen Button legt den Text fest, der darauf angezeigt wird. Zeile 23 bringt etwas Neues. Was sie genau bedeutet, erfahren wir an Tag 5. Fr den Augenblick gengt es zu wissen, dass diese Zeile der CLR mitteilt, dass die Add-Methode (siehe Listing 2.9) ausgefhrt werden soll, wenn diese Schaltflche angeklickt wird.
70
Die Zeilen 27-30 schlielich fgen Ihrem Formular die einzelnen Steuerelemente hinzu. Dieser Schritt ist notwendig, sonst wrde die CLR nicht wissen, wo sie die Steuerelemente anzeigen soll. Sie wrden nur im Speicher existieren und wertvolle Ressourcen belegen. Listing 2.9 zeigt Ihnen den Schlussteil unseres Codes: die Add-Methode. Fgen Sie diesen Code unter Zeile 31 ein, jedoch vor dem Ende der Klasse. Listing 2.9: Die Zahlen addieren
33: 34: 35: Public Sub Add(ByVal Sender as Object, ByVal e as EventArgs) lblAnswer.Text = CStr(CInt(tbNumber1.Text) + CInt(tbNumber2.Text)) End Sub
Diese Methode nimmt zwei Parameter entgegen, die wir aber fr den Augenblick ignorieren, da sie fr diese einfache Anwendung nicht von groem Nutzen sind. Zeile 34 bernimmt die Werte der zwei Textfelder (unter Nutzung der jeweiligen Text-Eigenschaft), addiert sie und zeigt sie im Bezeichnungsfeld (Label) mit Hilfe von dessen Text-Eigenschaft an. Die Funktionen CStr und CInt wandeln die Benutzereingaben in Zeichenfolgen bzw. Ganzzahlen um. Das ist notwendig, weil die CLR nicht wei, wie sie Benutzereingabewerte interpretieren soll. Beispielsweise knnte das Zeichen 9 als Zahl oder Zeichenfolge interpretiert werden, also mssen wir einen expliziten Datentyp dafr bereitstellen. Zeile 34 fhrt die folgenden Arbeitsschritte aus: 1. holt die Werte aus den zwei Textfeldern, 2. wandelt die Werte mit Hilfe von CInt in Integer um, 3. addiert die zwei Integer, 4. wandelt das Ergebnis in eine Zeichenfolge um, die im Bezeichnungsfeld angezeigt wird (dieser Schritt ist erforderlich, weil die Text-Eigenschaft stets eine Zeichenfolge erwartet und sich gegenber einer Ganzzahl verweigert). Das war's auch schon. Speichern Sie den zusammengefgten Code als calculator.vb in Ihrem Verzeichnis c:\winforms\day2 und kompilieren Sie ihn unter Verwendung von VS .NET oder eines Befehlszeilen-Compilers:
vbc /t:winexe /r:system.dll /r:system.windows.forms.dll /r:system.drawing.dll Calculator.vb
Dieser Befehl verwendet den Compiler von VB .NET, liefert eine ausfhrbare WindowsDatei und referenziert die Assemblies system.dll, system.windows.forms.dll sowie system.drawing.dll (diese wurde mit Hilfe der Tabelle 2.1 bestimmt), um die Anwendung zu kompilieren. Abbildung 2.7 zeigt eine Beispielausgabe.
71
Listing 2.10 zeigt den gleichen Quellcode, nur eben in C#.
Abbildung 2.7: Die Anwendung addiert erfolgreich zwei Zahlen.
Listing 2.10: Ein C#-Taschenrechner

1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: using System; using System.Windows.Forms; using System.Drawing; namespace TYWinforms.Day2 { public class Calculator : Form { private Button btnAdd; private TextBox tbNumber1; pribate TextBox tbNumber2; private Label lblAnswer; public static void Main() { Application.Run(new Calculator()); } public Calculator() { this.btnAdd = new Button(); this.tbNumber1 = new TextBox(); this.tbNumber2 = new TextBox(); this.lblAnswer = new Label(); tbNumber1.Location = new Point(0,0); tbNumber2.Location = new Point(100,0); btnAdd.Location = new Point(0,25);
72
27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41: 42: 43:
btnAdd.Text = "Addieren"; btnAdd.Click += new EventHandler(this.Add); lblAnswer.Location = new Point(0,75); this.Controls.Add(btnAdd); this.Controls.Add(tbNumber1); this.Controls.Add(tbNumber2); this.Controls.Add(lblAnswer); } public void Add(object Sender, EventArgs e) { lblAnswer.Text = Convert.ToString(Convert.ToInt32 (tbNumber1.Text) + Convert.ToInt32(tbNumber2.Text)); } } }
Neben ein paar semantischen Unterschieden zum VB .NET-Code sollten Sie auch ber andere Dinge Bescheid wissen. Alle Zeilen sind bis zur Zeile 28 miteinander identisch. Beachten Sie, dass Sie die AddHandler-Methode nicht mehr verwenden und das Schlsselwort WithEvents aus Zeile 8 verschwunden ist. C# setzt eine andere Methode ein, um Objekte Aktionen ausfhren zu lassen. Darauf kommen wir an Tag 5 zu sprechen. Andere Unterschiede treten nur noch in den Zeilen 39 und 40 auf. Statt die Funktionen CStr und CInt fr die Datentypumwandlung zu verwenden, nutzen Sie nun die Methoden Convert.ToString und Convert.ToInteger. Wenn Sie mit C# vertraut sind, fragen Sie sich vielleicht, warum wir nicht den Casting-Operator fr die Konvertierung von Datentypen verwendet haben, beispielsweise (string) und (int) vor den jeweiligen Variablennamen: (int)tbNumber1.Text usw. Der Grund liegt in dem Umstand, dass man in C# weder implizit noch explizit einen string in einen anderen Basisdatentyp konvertieren kann. Die Klasse System.Convert verfgt hingegen ber alle ntigen Methoden, um jeden beliebigen vordefinierten Datentyp in einen anderen umzuwandeln (ToInt32, ToString, ToDouble usw.). Der Befehl zum Kompilieren ist der gleiche, nur dass Sie jetzt den C#-Compiler nutzen:
csc /t:winexe /r:system.dll /r:system.windows.forms.dll /r:system.drawing.dll Calculator.cs
73
2.4
Zusammenfassung
Die heutige Lektion war sehr intensiv. Durch das Untersuchen eines einfachen Quellcodes haben Sie eine ganze Menge ber das .NET Framework und seine Arbeitsweise gelernt, u.a. ber Klassen, Namensrume, Assemblies und Methoden. Klassen sind Bauplne fr Objekte. In einer Klasse definieren Sie die Eigenschaften, Methoden und Ereignisse, die ein Objektbenutzer verwenden kann. Diese offen gelegten also fr die Allgemeinheit bereitgestellten Elemente werden mit Hilfe des Schlsselworts public deklariert. Elemente, die Sie nicht offen legen mchten, erfordern das Schlsselwort private. Sie haben auch etwas ber Klassenvererbung gelernt. Eine Klasse kann von einer anderen erben, um so deren Funktionsumfang zu nutzen das erspart Ihnen viel Codeschreiben. Alle Ihre Windows Forms-Klassen erben von der Klasse System.Windows.Forms.Form. Klassen verfgen ber Konstruktoren und Destruktoren, also ber Methoden, die die von einer Klasse verwendeten Ressourcen initialisieren und wieder freigeben. In C# hat der Konstruktor den gleichen Namen wie die Klasse; der Destruktor erhlt den gleichen Namen, allerdings mit einer vorangestellten Tilde. VB .NET hingegen verfgt ber keine Destruktoren und der Konstruktor trgt immer den Namen New. Namensrume sind Gruppierungen von Klassen, und Assemblies sind physische Dateien, die Namensrume gruppieren. Namen von Assemblies enden auf .dll und lassen sich von Anwendungen mit Hilfe der Option /r des Compilers referenzieren. Die Main-Methode ist stets der Anfang einer Anwendung. Sie muss sich in einer Klasse befinden, aber es ist gleichgltig, in welcher. In der Regel ruft diese Methode die Methode Application.Run auf, welche ein Formular am Bildschirm anzeigt und auf Benutzereingaben wartet. Zum Schluss haben Sie gelernt, wie man alles zusammenfgt, indem Sie eine funktionierende Windows Forms-Anwendung erstellten. Mit diesem Wissen knnen Sie nun beinahe jeden Bestandteil einer Windows Forms-Anwendung identifizieren und Ihre eigene Anwendung erstellen.
2.5
F
Bedeutet der Import von Namensrumen zustzlichen Verwaltungsaufwand und somit Speicherbedarf fr meine Anwendung? A Nicht unbedingt. Die Objekte in importierten Namensrumen werden nur bei Bedarf geladen und nicht alle auf einmal. Daher bentigt die Verwendung externer Objekte zwar schon etwas (Speicher-) Ressourcen, aber nur in recht geringem Umfang.
74
Workshop
2.6
Workshop
Quiz
1. Wie heit die Basisklasse, von der alle anderen Klassen erben? 2. Was bewirken die Schlsselwrter shared und static? 3. Wahr oder falsch? Man kann vorhandene Namensrume um eigene Klassen erweitern. 4. Wahr oder falsch? Die Main-Methode wird jedes Mal ausgefhrt, wenn eine neue Instanz ihrer Klasse erzeugt wird. 5. Aus welchem Grund ist der folgende Code nicht ausreichend? Was muss auerdem verwendet werden?
dim MyObject as Button
6. Was stimmt mit dem folgenden Kompilierungsbefehl nicht? (Tipp: Er kann mehr als einen Fehler enthalten.)
csc /type:windowsexe /r:system.dll /r:system.drawing.dll / r:system.drawing.text.dll dateiname.vb
7. Was bedeuten die folgenden Eigenschaften?

Button.CanSelect Button.Cursor Form.AllowDrop Form.Visible
8. Nennen Sie drei semantische Unterschiede zwischen C# und Visual Basic .NET. 9. Wahr oder falsch? Jede Klasse muss einen Konstruktor haben.
bung
Erweitern Sie das heutige Taschenrechner-Beispiel. Fgen Sie weitere Schaltflchen hinzu, mit denen sich arithmetische Operationen ausfhren lassen: Subtraktion, Multiplikation und Division. Versuchen Sie, die Anwendung sowohl in C# als auch in Visual Basic .NET zu erstellen. Verschnern Sie die Benutzeroberflche Ihres Taschenrechners durch den grozgigen Gebrauch von Bezeichnungsfeldern (Label-Steuerelementen).
75
Mit Windows Forms arbeiten
An den ersten zwei Tagen haben Sie eine ganze Menge ber die Funktionsweise von Windows Forms-Anwendungen gelernt. Sie knnen jeden ihrer Bestandteile identifizieren und beschreiben, wissen, wie er mit .NET zusammenarbeitet, und Sie knnen auf die Verwendung derjenigen Teile schlieen, die Ihnen noch unbekannt sind. Da Sie nun ber das Grundlagenwissen verfgen, um Windows Forms zu erstellen, ist es an der Zeit, mehr ins Detail zu gehen. Die heutige Lektion konzentriert sich auf alle Aspekte des Objekts System.Windows.Forms.Form und zeigt Ihnen die Vielfalt an Mglichkeiten, mit denen Sie Ihre Anwendungen anpassen knnen. Heute lernen Sie,

wie man das Object-Objekt verwendet, in welcher Weise Sie Layout und Aussehen eines Formulars steuern, wie man Interaktion in Formularen kontrolliert, was die Nachrichtenschleife ist und wie sie mit der CLR zusammenarbeitet, wie Sie mit Tastatur- und Mauseingaben umgehen, auf welche Weise man Formulare veranlasst, mit Drag & Drop zu arbeiten.
3.1
Das objektorientierte Windows-Formular
Nun sollten Sie langsam anfangen, sich Ihre Formulare als Objekte vorzustellen. Stellen Sie sich das Windows -Formular auf Ihrem Bildschirm als ein echtes Fenster in Ihrem Haus vor. Sie knnen die Farbe des Fensters (bzw. seines Rahmens) und seine Transparenz ndern, den Typ der Handgriffe und des Glases sowie die Vorhnge usw. Sie knnen praktisch alles, was Ihnen einfllt, mit Ihrem Fenster anstellen (vorausgesetzt, Sie verfgen ber die entsprechenden Mittel). Das Gleiche gilt auch fr Windows Forms. Aus der gestrigen Lektion wissen Sie, dass Sie die Titelzeile und die Gre eines Formulars ndern knnen. Das trifft auch auf die Titelleiste zu wie auch auf die Anordnung der Objekte im Formular, die Farbe, Transparenz und Sichtbarkeit, die Umrisslinien, die Schaltflchen usw. In Abbildung 3.1 sehen Sie nur ein paar der Layouts, die Ihr Formular annehmen kann. Daher ist es hilfreich, sich Windows Forms als generische Objekte vorzustellen, die sich in jeder gewnschten Weise bearbeiten und anpassen lassen. Sie knnen quasi in den Laden der .NET-Klassenbibliothek gehen und sich ein Form-Objekt heraussuchen. Dann schneiden Sie es sich nach Ihren Wnschen zu.
78
Abbildung 3.1: Formulare knnen transparent, rahmenlos und skalierbar sein.
Mit dem Objekt Object arbeiten

An den Tagen 1 und 2 haben Sie mit ein paar Objekten gearbeitet, aber Sie haben noch nicht das Objekt Object untersucht, die Basisklasse aller .NET-Klassen einschlielich der Windows Forms-Formulare. Da es von jeder Klasse geerbt wird, werden Sie von jetzt ab damit umgehen, und so ist es ratsam, ein wenig mehr darber zu erfahren, insbesondere ber die Methoden, die es Ihnen zur Verfgung stellt.
Object ist die allgemeinste Klasse, die Sie in .NET verwenden knnen. Daher wird sie verwendet, um jedes ansonsten unbekannte Objekt darzustellen. Wenn Sie beispielsweise folgendes Statement zum Erzeugen einer Variablen verwenden, wei die CLR nicht, als welchen Typ sie sie erzeugen soll, und erzeugt lediglich ein Object: Dim MyObjectVariable
Weil Ihre Variable nur ein Objekt ist, verlieren Sie eine Menge Funktionalitt, die Sie durch das Deklarieren eines expliziten Datentyps gewinnen wrden. So knnten Sie etwa einem Integer einen weiteren Integer hinzufgen, aber Sie knnen keine Objects aneinander hngen; ungeachtet Ihrer guten Absicht wrde dies zu einer Fehlermeldung fhren. Daher empfiehlt es sich, stets einen spezifischen Typ anzugeben, statt ein Object als Mdchen fr alles zu verwenden. Standardmig mssen Ihre Anwendungen stets einen Typ fr Ihre Variablen deklarieren. Das verhindert den falschen Einsatz der Variablen und verbessert das Leistungsverhalten. Sie knnen aber diese Sicherheitsfunktion durch Deaktivieren des Merkmals Option Strict abschalten. Um Nheres darber zu erfahren, lesen Sie bitte in Tag 2 den Abschnitt Das Kompilieren von Windows Forms.
79
Sie werden in der Windows Forms-Programmierung viele Funktionen kennen lernen, die fr Sie Objekte erzeugen. So ruft etwa die Methode ConfigurationSettings.GetConfig Konfigurationseinstellungen aus einer Datei ab. Die Funktion liefert einen Datentyp Object, weil sie nicht genau wei, was Sie mit den zurckgegebenen Ergebnissen machen werden. Wird aber ein Object geliefert, knnen Sie die Ergebnisse durch Typumwandlung (Casting) in jeden gewnschten Datentyp transformieren. In C# wandeln Sie den Typ einer Variablen folgendermaen um:
myDataType myVariable; // Variable vom Typ myDataType deklarieren myVariable = (myDataType) ConfigurationSettings.GetConfig ("some setting"); // Einstellungen abrufen und in myDataType umwandeln
Das Objekt Object verfgt ber fnf Hauptmethoden: Equals, ReferenceEquals, GetHashCode, GetType und ToString. Sie sind allesamt ntzlich, daher wollen wir sie im Detail betrachten. Denken Sie daran, dass jedes Objekt von Object erbt, so dass diese Methoden jedem Objekt, das Sie verwenden, zur Verfgung stehen. Die Equals-Methode ist sowohl ein statisches als auch ein nicht-statisches Element. Sie knnen sie daher sowohl von einer bestimmten Objektinstanz aus als auch vom Typ Object selbst aus aufrufen. Listing 3.1 zeigt beispielsweise ein Codefragment, in dem sowohl statische als auch nicht-statische Versionen der Equals-Methode verwendet werden. Listing 3.1: Der Gebrauch der Equals-Methode
1: 2: 3: 4: 5: 6: 7: 8: int intA; int intB; intA = 4; intB = 5; Console.WriteLine("{0}", intA.Equals(intB)); // nicht-statische Methode Console.WriteLine("{0}", ObjectEquals(intA, intB)); // statische Methode
Die Zeilen 7 und 9 geben beide false in der Befehlszeile aus, weil die Objekte intA und intB nicht gleich sind (intA ist 4, und intB ist 5). Zeile 7 ruft jedoch die Equals-Methode von einer Instanz aus auf, whrend Zeile 9 Equals von der Object-Klasse selbst aus aufruft. Sehr hufig werden Sie zwei Objekte miteinander vergleichen mssen, so dass sich diese Methode als ntzlich erweisen drfte. Die Console.WriteLine-Methode gibt eine Zeichenfolge in der Befehlszeile aus. Der erste Parameter besteht in der auszugebenden Zeichenfolge. Eine Zahl in Klammern bedeutet, dass die Methode auf einen der zustzlich angegebenen Parameter verweisen sollte: {0} bedeutet also Gib den nchsten Parameter aus, {1} bedeutet Gib den darauf folgenden Parameter aus usw. Man knnte anstelle der numerischen Bezeichner auch einfach den Parameter selbst verwenden.
80
Um diese Methode verwenden zu knnen, mssen Sie Ihre Anwendung als regulre ausfhrbare Datei kompilieren (verwenden Sie dabei die Option /t:exe). Die Methode ReferenceEquals ist ein nur-statisches Element, das der Equals-Methode hnelt. Sie unterscheiden sich dahingehend, dass ReferenceEquals zwei Objekte miteinander vergleicht, um herauszufinden, ob sie sich in der gleichen Instanz befinden, also nicht, ob sie den gleichen Wert besitzen. Das lsst sich deswegen bewerkstelligen, weil in Computerbegriffen eine Instanz durch ihren Ort im Speicher (ihre Speicheradresse) definiert ist. Wenn also zwei Objekte auf dieselbe Speicheradresse verweisen, handelt es sich um dieselbe Instanz. Zwei verschiedene Speicheradressen knnen den gleichen Wert haben, aber es handelt sich nicht um dieselbe Instanz. (Beachten Sie, dass null oder Nothing in VB .NET stets mit derselben Instanz wie ein anderes null gleichzusetzen ist. Werfen Sie einen Blick auf Listing 3.2, das unterschiedliche Variablen miteinander vergleicht. Listing 3.2: Referenzen vergleichen
1: 2: 3: 4: 5: 6: 7: 8: object a = null; object b = null; object c = new Object(); Console.WriteLine(Object.ReferenceEquals(a, b)); Console.WriteLine(Object.ReferenceEquals(a, c)); a = c; Console.WriteLine(Object.ReferenceEquals(a, c));
Zeile 5 liefert true, weil sich alle null-Werte auf dieselbe Instanz beziehen und einander sind. Zeile 6 hingegen gibt false bzw. unwahr zurck, weil a und c zwei unterschiedliche Objekte sind. Zeile 7 sieht aus, als wrde sie a und c demselben Wert zuordnen, aber wenn Sie die eine Variable einer anderen zuweisen, setzen Sie eigentlich die Speicheradressen miteinander gleich, und daher liefert Zeile 8 true oder wahr. Falls Sie bereits ber Programmiererfahrung verfgen, wissen Sie, woher der Name ReferenceEquals kommt: Diese Methode vergleicht die Speicheradressen (bzw. Referenzen) der Variablen statt ihre Werte miteinander. In den meisten Fllen gengt die Equals-Methode, aber es ist hilfreich, auch ber die ReferenceEquals-Methode verfgen zu knnen. Die nchsten drei Methoden sind alle nicht-statisch. GetHashCode liefert einen Hash-Code fr Ihr Objekt. Ein Hash-Code ist eine numerische Darstellung eines Objekts und hat darber hinaus keine Bedeutung an sich. Die Objekte A und B knnen unterschiedliche
81
Objekte sein, aber den gleichen Hash-Code generieren, wie etwa in Zeile 7. Sie knnen diesen Vorgang nicht umkehren und von der Zahl 7 auf ein Objekt schlieen; Hashing ist ein Einbahnstraen-Mechanismus. Wie ihr Name schon sagt, liefert die Methode GetType einfach nur den spezifischen Datentyp eines Objekts. Das ist sehr ntzlich, wenn man nicht wei, mit welcher Art von Daten man es zu tun hat, so etwa, wenn eine Funktion ein nicht identifizierbares Objekt liefert:
string a = "hallo"; Console.WriteLine(a.GetType());
Dieses Codestck wird System.String liefern, den Datentyp der Variablen a. Beachten Sie, dass diese Methode einen Datentyp zurckgibt, nicht etwa nur den Namen des Typs: Sie liefert einen Typ und keine Zeichenfolge. Diese Methode wird hufig zum Vergleichen von Datentypen verwendet, etwa im Zusammenhang mit der eben besprochenen Methode GetConfig:
myType myVariable; if (myVariable.GetType() != ConfigurationSettings.GetConfig ("mySettings").GetType()) return false;
Dieser Code prft, ob der von der GetConfig-Methode gelieferte Typ (ein Type-Objekt) der gleiche Typ ist wie myVariable. Und in diesem Fall ist er es nicht. Zum Schluss kommen wir auf die gebruchlichste Methode zu sprechen: ToString liefert die Zeichenfolgendarstellung eines Variablentyps. Das folgende Codefragment wrde beispielsweise die Zeichenfolge "system.object" in der Befehlszeile ausgeben:
Object objA = new Object(); Console.WriteLine(objA.ToString());
Beachten Sie, dass hier nicht der Wert eines Objekts ausgegeben wird, sondern der Typname. Manchmal wird die ToString-Methode fr eine bestimmte Klasse berschrieben. Der string-Datentyp berschreibt beispielsweise ToString, so dass er den tatschlichen Wert der Variablen ausgibt statt den Namen des Typs. Der folgende Code gibt die Zeichenfolge "hello world" aus:
string strA = "hello world"; Console.WriteLine(strA.ToString());
Formular-Eigenschaften
Das Objekt System.Windows.Forms.Form verfgt ber genau 101 Eigenschaften, die es Ihnen gestatten, beinahe jeden Aspekt des Formulars zu steuern. Da dies zu viele Eigenschaften fr nur einen Tag sind, lassen Sie uns nur auf ein paar der ntzlicheren Aspekte einen Blick werfen, gruppiert nach Funktion.
82
Gre und Position steuern

Ihnen sind bereits zwei Mglichkeiten, die Formulargre festzulegen, bekannt: die Eigenschaften Width und Height (Breite bzw. Hhe). Diese Eigenschaften bernehmen lediglich Zahlenwerte, um die Formulargre in Pixelwerten festzulegen. Zum Beispiel:
form1.Width form1.Height = 200
Sie knnen die Gre auch mit Hilfe der Size-Eigenschaft und eines Size-Objekts festlegen:
form1.Size = New Size(100, Form1.Size.Height) form1.Size = New Size(100, Form1.Size.Width)
Beide Methoden bewirken das Gleiche, aber meistens werden Sie die erste verwenden, da sie einfacher ist. Sie knnen die Gre auch abhngig von der Bildschirmgre des Benutzers festlegen, und zwar, indem Sie das Screen-Objekt verwenden. Listing 3.3 zeigt dafr ein Beispiel. Listing 3.3: Das Festlegen der Formularhhe abhngig von der Bildschirmgre (in VB .NET)
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: Imports System Imports System.Windows.Forms Public Class MultiForm : Inherits Form Public Sub New Me.Text = "Hauptformular" Me.Height = Screen.GetWorkingArea(Me).Height / 2 End Sub End Class Public Class StartForm Public Shared Sub Main() Application.Run(New MultiForm) End Sub End Class
Dieser Quellcode drfte Ihnen mittlerweile vertraut sein, daher betrachten wir lediglich Zeile 7 etwas genauer. Die Methode GetWorkingArea des ScreenObjekts liefert ein Rectangle-Objekt, das fr den Benutzerbildschirm steht. Sie bergeben das aktuelle Formularobjekt (mit Hilfe des Me-Schlsselworts), um der CLR mitzuteilen, welchen Bildschirm sie verwenden soll (nur fr den Fall, dass der Benutzer mehr als einen Bildschirm besitzt). Rectangle-Objekte haben wiederum Height- und Width-Eigenschaften, welche ihrerseits Integer liefern, die die
83
Hhe und Breite des Bildschirms beschreiben. Danach teilen wir den Hhe-Wert durch 2. Kompilieren Sie diese Anwendung und fhren Sie sie aus. Beachten Sie, dass das Fenster jetzt die halbe Hhe Ihres Bildschirms beansprucht. Um festzulegen, wo das Fenster sich ffnet, knnen Sie die Eigenschaften Location, DesktopLocation, Top oder Left verwenden. Die letzten beiden legen die Position der oberen linken Ecke Ihres Formulars auf dem Bildschirm fest. Sie funktionieren genauso wie die Height- und Width-Eigenschaften. Beachten Sie, dass Sie diese Eigenschaften auf eine Position festlegen knnen, die sich weit auerhalb des Bildschirms befindet, etwa auf Top = 9999 und Left = 9999. Die Eigenschaften Location und DesktopLocation sind einander hnlich. Bei einem FormObjekt bewirken sie das Gleiche: Sie legen die Anfangsposition der oberen linken Ecke des Formulars fest. Die beiden folgenden Zeilen realisieren beispielsweise die gleiche Funktionalitt:
Form1.DesktopLocation = New Point(100,300) Form1.Location = New Point(100,300) Location ist eine Eigenschaft, die von Control, der Urgroelternklasse von Form, geerbt
wird. Diese Eigenschaft verwendet man, um die Position eines Steuerelements innerhalb eines anderen Steuerelements festzulegen. In unserem Fall ist das beinhaltende Steuerelement fr das Formular einfach der Benutzerbildschirm. Sie knnten die Location-Eigenschaft fr jedes beliebige Objekt verwenden, das vom Control-Objekt erbt, etwa fr die Steuerelemente TextBox oder Label (Beschriftung), um seine Position innerhalb eines anderen Objekts zu festzulegen zum Beispiel Ihres Formulars. Die Eigenschaft DesktopLocation gilt hingegen nur fr das Form-Objekt. Der Einheitlichkeit halber werden wir ab jetzt die Eigenschaft Location verwenden. Daher brauchen Sie nur eine Eigenschaft fr alle Windows Forms-Objekte zu verwenden.
Das Aussehen steuern

Sie wissen bereits ber die Text-Eigenschaft Bescheid, die den in der Titelzeile angezeigten Text steuert. Lassen Sie uns daher ein paar Dinge betrachten, die Sie mit Schriftarten (Fonts) anstellen knnen. Die Eigenschaft Font legt die Schriftart fest, die im Formular benutzt wird, es sei denn, die Font-Eigenschaft eines Steuerelements htte Prioritt. Die Eigenschaft ForeColor legt die Textfarbe fest. Betrachten Sie das folgende Codefragment:
Form1.Font = New Font(new FontFamily("WingDings"), 23) Form1.ForeColor = Color.Blue
Die erste Zeile erzeugt ein neues Font-Objekt (Sie merken schon, dass absolut alles in .NET ein Objekt ist, selbst Schriftarten und Farben). Es gibt eine ganze Reihe unterschiedlicher
84
Mglichkeiten, um Font-Objekte zu erzeugen (in anderen Worten: Es hat viele Konstruktoren), und dies ist lediglich eine davon. Sie legen die Schriftart fest, indem Sie das Objekt FontFamily verwenden, das vordefinierte Schriftartnamen enthlt. Der zweite Parameter besteht in der Gre der Schriftart (in der Maeinheit Punkt). Die zweite Zeile legt die Textfarbe mit Hilfe der Blue-Eigenschaft des Color-Objekts als blau fest. Wird dieser Code in einem Windows Forms-Formular verwendet, erzeugt er die Ausgabe, die Sie in Abbildung 3.2 sehen (Sie mssen mir glauben, dass die Farbe wirklich blau ist).
Abbildung 3.2: Aussehen und Farbe einer Schriftart werden in ihren jeweiligen Eigenschaften festgelegt.
Die Eigenschaften BackColor und BackgroundImage erlauben Ihnen, das vorgegebene Erscheinungsbild eines Formulars zu ndern. BackColor wird genauso verwendet wie ForeColor:
Form1.BackColor = Color.Lachsrosa
Die Eigenschaft BackgroundImage bernimmt ein Image-Objekt als Parameter. blicherweise verwenden Sie die FromFile-Methode des Image-Objekts, um eine Grafik zu laden; Sie mssen einen Pfadnamen angeben, z.B. so:
Form1.BackgroundImage = Image.FromFile("c:\winforms\day3\kaffeebohne.bmp") FromFile ist eine statische Methode, wie Sie wahrscheinlich schon herausgefunden haben, da Sie ja keine neue Image-Instanz erzeugen mssen, um sie verwenden zu knnen. Wenn wir von Abbildung 3.2 ausgehen, erhalten wir nun einen gekachelten Hintergrund, wie man in Abbildung 3.3 sehen kann.
Die Hintergrundfarbe des Label-Objekts (Bezeichnungsfeld) ist immer noch grau. An Tag 6 lernen Sie, wie Sie dies ndern knnen. Eine weitere Bildeigenschaft, die Sie anpassen knnen, ist die Icon-Eigenschaft. Das Icon oder Symbol wird in der oberen linken Ecke der Titelzeile Ihres Formulars verwendet, ebenso wie in jeder anderen Darstellung Ihrer Anwendung, wie etwa der Windows-Taskleiste. So legen Sie die Eigenschaft fest:
Me.Icon = New Icon("c:\winforms\day3\VSProjectApplication.ico")
85
Abbildung 3.3: Sie knnen eine Grafik dazu verwenden, den Hintergrund Ihres Formulars damit zu kacheln.
Sie mssen eine neue Instanz des Icon-Objekts erzeugen, wobei Sie einen gltigen Pfad zu einer Grafik angeben. Die Grafik, die Sie auswhlen, muss eine Icon-Datei (.ico) sein, sonst erzeugt Ihre Anwendung eine Fehlermeldung. Das Bild des Mauszeigers lsst sich durch die Cursor-Eigenschaft steuern:
Me.Cursor = Cursors.Hand
Das Cursors-Objekt verfgt ber eine Menge Eigenschaften fr den Standardsatz an Windows-Mauszeigern, darunter Arrow, IBeam, WaitCursor und Help. In der .NET-Dokumentation finden Sie weitere Mauszeiger. Sie knnen auch einen eigenen Mauszeiger aus einer Datei laden:
Me.Cursor = New Cursor("Pfadname")
Die Mauszeigerdatei muss die Endung .cur tragen. Animierte Mauszeiger (jene mit der Endung .ani) werden von der CLR nicht untersttzt. Die Eigenschaft ShownInTaskBar legt fest, ob Ihre Anwendung in der Windows-Taskleiste zu sehen sein soll (dies betrifft nicht das Fenster am Bildschirm, sondern nur die Schaltflche in der Taskleiste). Der Standardwert lautet true (wahr). Unter bestimmten Gegebenheiten mchten Sie diese Einstellung vielleicht ndern, um einen Anwender daran zu hindern, ein Formular auszuwhlen. Wenn Sie etwa einen so genannten Splash Screen erzeugen, der etwa das Logo Ihrer Firma anzeigt, wollen Sie wahrscheinlich nicht, dass der Benutzer es auswhlt (es verschwindet ja auch sofort). Setzen Sie dann einfach die Eigenschaft ShownInTaskBar auf false, und der Benutzer kann es nicht mehr aus der Taskleiste auswhlen. Die Eigenschaft FormBorderStyle legt das Aussehen der Umrisslinie einer Windows FormsFormulars fest. Hauptschlich ndern Sie diese Eigenschaft, um die Grennderung des Formulars zu erlauben oder zu unterbinden. Manchmal betrifft das ndern einer Umrisslinie auch das Aussehen des Formulars, wie zum Beispiel:
Form1.FormBorderStyle = FormBorderStyle.Sizable
86
Die Aufzhlung fr FormBorderStyle (nicht zu verwechseln mit der Eigenschaft Form.FormBorderStyle) fhrt sieben verschiedene Typen von Umrisslinien auf, wie in Tabelle 3.1 zu sehen. (Eine Aufzhlung ist einfach eine Sammlung von Eigenschaften oder Stilen.) Abbildung 3.4 zeigt eine Sammlung der unterschiedlichen Stile.
Abbildung 3.4: Es stehen sieben vordefinierte Umrisslinienstile zur Auswahl.
Stil
Fixed3D FixedDialog FixedSingle FixedToolWindow
Beschreibung Nicht skalierbar. Dreidimensionale Umrisslinie. Nicht skalierbar. Dicke Umrisslinie. Nicht skalierbar. Dnne Umrisslinie. Formular mit schmalerer Titelleiste. Ntzlich fr die Anzeige von QuickInfos und Hilfefenstern. Nicht skalierbar. Enthlt keine Maximieren- oder Minimieren-Schaltflchen. Nicht skalierbar. Keine Umrisslinie. Skalierbar. Standardstil. Formular mit schmalerer Titelleiste. Ntzlich fr die Anzeige von QuickInfos und Hilfefenstern. Skalierbar. Enthlt keine Maximieren- oder MinimierenSchaltflchen.
None Sizable SizableToolWindow
Tabelle 3.1: Stile fr FormBorderStyle
87
Zum Schluss gibt es noch drei Eigenschaften, die steuern, wie und ob Ihr Formular am Bildschirm angezeigt wird. Die Visible-Eigenschaft legt fest, ob Ihr Formular fr den Benutzer sichtbar ist. Ist ein Formular nicht zu sehen, kann man nicht damit interagieren. Auf diese Weise lassen sich bestimmte Dinge vor dem Anwender verbergen, etwa wenn Sie Ihre Anwendung geffnet lassen wollen, sie aber nicht mit der Benutzeroberflche interferieren soll. Standardmig ist ein solches Formular nicht sichtbar. Um ein Formular teilweise sichtbar zu machen (mit anderen Worten: transparent), mssen Sie die Eigenschaft Visible auf true (wahr) setzen und die Eigenschaft Opacity (Undurchsichtigkeit) verwenden. Diese Eigenschaft bernimmt einen Wert zwischen 1 (= vllig undurchsichtig, also vllig sichtbar) und 0,0 (= unsichtbar bzw. vllig durchsichtig). Um ein paar wirklich interessante Transparenztechniken vorzufhren, knnen Sie die Eigenschaft TransparencyKey so einstellen, dass eine bestimmte Farbe durchsichtig sein soll. Der folgende Code macht beispielsweise alle grauen Flchen im Formular unsichtbar, whrend alles andere undurchsichtig bleibt:
Form1.TransparencyKey = Color.Gray
Wenn Sie nun auch noch die BackColor des Formulars auf Grau setzen, erhalten Sie schlielich ein Formular wie das in Abbildung 3.5 zu sehende (das Formular wurde ber ein Fenster mit Befehlszeilenausgabe gelegt, um den Transparenzeffekt zu verdeutlichen).
Abbildung 3.5: Verwenden Sie die Eigenschaft TransparencyKey, um nur eine bestimmte Farbe sichtbar zu machen.
Interaktivitt steuern
Wenn Sie eine Windows-Anwendung betrachten, dann sehen Sie an deren Fenstern die Standardmerkmale: In der oberen rechten Ecke befinden sich Schaltflchen fr das Minimieren und Maximieren sowie das Schlieen des Fensters, manchmal auch eine HILFESchaltflche. Rechts unten befindet sich oft ein Anfasser, damit man mit der Maus die Fenstergre verndern kann. Diese Systemmenfelder sehen Sie in Abbildung 3.6.
88
Jedes Systemmenfeld lsst sich mit Hilfe der folgenden Eigenschaften in Ihrem Formular verstecken oder anzeigen:

MaximizeBox MinimizeBox HelpButton ControlBox SizeGripStyle
Abbildung 3.6: Diese Systemmenfelder gehren zu den Standardmerkmalen von Windows.
Die ersten vier Eigenschaften nehmen lediglich den Wert true oder false an. ControlBox legt fest, ob die vorhergehenden Schaltflchen berhaupt angezeigt werden sollen. Seien Sie hier jedoch vorsichtig: Wenn Sie ControlBox auf false setzen, knnte es sein, dass Sie Ihre Anwendung nicht mehr schlieen knnen!
Die HILFE-Schaltflche taucht nur auf, wenn die MINIMIEREN- und MAXIMIEREN-Schaltflchen nicht sichtbar sind. Dies ist ein Standardmerkmal von .NET.
Die Eigenschaft SizeGripStyle nimmt einen SizeGripStyle-Aufzhlungswert an: Auto, Hide oder Show. Auto zeigt den Skalierungsanfasser an, falls ntig (also abhngig vom FormBorderStyle), whrend Hide und Show die Grenziehpunkge (Skalierungsanfasser) jeweils verbergen oder zeigen. Mit einer Anwendung sind hufig zwei besondere Tasten verbunden: () und (ESC). Viele Anwendungen werden geschlossen, wenn Sie die (ESC)-Taste drcken. Sie knnen diese Funktionen mit den Eigenschaften AcceptButton und CancelButton steuern. Listing 3.4 zeigt in C# ein Beispiel, wie man diese Eigenschaften verwendet.
89
Listing 3.4: Die Eigenschaften AcceptButton und CancelButton

1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41: 42: 43: 44: using System; using System.Windows.Forms; using System.Drawing; namespace TYWinForms.Day3 { public class Listing34 : Form { Button btAccept = new Button(); Button btCancel = new Button(); Label lblMessage = new Label(); public Listing34() { lblMessage.Location = new Point(75,150); lblMessage.Width = 200; btAccept.Location = new Point(100,25); btAccept.Text = "OK"; btAccept.Click += new EventHandler(this.AcceptIt); btCancel.Location = new Point(100,100); btCancel.Text = "Abbrechen"; btCancel.Click += new EventHandler(this.CancelIt); this.AcceptButton = btAccept; this.CancelButton = btCancel; this.Text = "Beispiel fr die Buttons OK und Abbrechen"; this.Height = 200; this.Controls.Add(lblMessage); this.Controls.Add(btAccept); this.Controls.Add(btCancel); } public void AcceptIt(Object Sender, EventArgs e) { lblMessage.Text = "Der OK-Button wurde gedrckt"; } public void CancelIt(Object Sender, EventArgs e) { lblMessage.Text = "Der Abbrechen-Button wurde gedrckt"; } } public class StartForm { public static void Main() { Application.Run(new Listing34());
90
45: 46: 47: 48:
} } }
Ein Groteil dieses Codes drfte bereits vertraut aussehen, daher knnen wir das meiste davon berfliegen. Die Zeilen 1 bis 3 importieren die notwendigen Namensrume. Zeile 5 deklariert den Namensraum, zu dem diese Anwendung gehrt; gem unserem Bezeichnungsschema heit dieser Namensraum TYWinForms.Day3. Zeile 7 deklariert die Windows Forms-Formularklasse. Die Zeilen 8 bis 10 deklarieren die Steuerelemente, die wir im Formular verwenden werden. Beachten Sie, dass sie auerhalb einer Methode deklariert werden, doch innerhalb einer Klasse. Dadurch lassen sie sich von jeder Methode in der Klasse verwenden. Im Konstruktor ab Zeile 12 findet der Groteil des Geschehens statt. Der Code in den Zeilen 13 bis 22 setzt einfach ein paar Eigenschaften fr unsere Steuerelemente. Beachten Sie insbesondere die Zeilen 18 und 22, die auf Methoden zeigen, die ausgefhrt werden, sobald eine der beiden Schaltflchen im Formular angeklickt wird. Diese Methoden, AcceptIt und CancelIt, befinden sich in den Zeilen 33 und 37 und geben einfach nur eine Meldung im Label-Steuerelement aus. Die Zeilen 24 bis 30 stellen einige Eigenschaften ein und fgen dem Formular die Steuerelemente hinzu. Die Zeilen 24 und 25 legen die Eigenschaften AcceptButton und CancelButton fr die jeweilige OK- oder Abbrechen-Schaltflche fest. Im Wesentlichen bewirkt das Anklicken der OK- oder Abbrechen-Schaltflche das Gleiche wie das Drcken der ()- oder der (ESC)-Taste. Schlielich enthalten die Zeilen 42 bis 46 eine weitere Klasse. Sie dient lediglich dazu, unsere Main-Methode aufzunehmen und die Methode Application.Run aufzurufen. Die Ausgabe der Anwendung nach dem Drcken der (ESC)-Taste wird in der Schaltflche AcceptButton und Abbildung 3.7 gezeigt. Erhlt die Abbrechen-Schaltflche im Formular den Fokus, veranlasst das Drcken der ()-Taste das Anklicken oder Niederdrcken dieser Schaltflche und folglich das Auslsen der CancelIt-Methode. Mit anderen Worten: Die Schaltflche erhlt die Eingabe noch vor dem eigentlichen Formular. Leider gibt es fr diese missliche Tatsache keinen einfachen Ausweg. Manche Steuerelemente, wie etwa die Button- und RichTextBox-Steuerelemente, behandeln das Drcken der ()-Taste automatisch, wenn sie den Fokus haben, also noch bevor irgendetwas anderes ausgefhrt werden kann. Sobald Sie dem Abbrechen-Button den Fokus geben (indem Sie ihn anklicken oder mit der Tabulatortaste darauf gehen), bewirkt die ()-Taste stets die Ausfhrung der CancelIt-Methode.
91
Falls es Sie interessiert, knnen Sie diese Verhaltensweise umgehen, indem Sie das Button-Steuerelement selbst berschreiben. Wir werden dies an Tag 18 behandeln. Obwohl die AcceptButton- und CancelButton-Eigenschaften auf Button-Steuerelemente verweisen mssen, beachten Sie bitte, dass diese Buttons nicht unbedingt fr den Benutzer zu sehen sein mssen. Indem man die Visible-Eigenschaft auf false setzt, macht man die Schaltflchen unsichtbar, ohne ihre Funktionalitt zu verlieren. Die Eigenschaft AllowDrop schlielich legt fest, ob das Formular mit Drag & Drop-Funktionen umgehen kann, d.h. wenn ein Anwender mit der Maus ein Objekt in das Formular zieht und dort fallen lsst. Diese Eigenschaft kann einen true- oder false-Wert annehmen. Wie Sie Ihr Formular dazu bringen, etwas bei einem solchen Ereignis auszulsen, besprechen wir heute spter im Abschnitt Ereignisse im Formular.
Abbildung 3.7: Das Drcken der (ESC)-Taste hat die gleiche Wirkung wie das Anklicken der ABBRECHEN-Schaltflche.
Um eine vollstndige Liste der Eigenschaften des Form-Objekts nachzuschlagen, lesen Sie Anhang B Windows Forms-Steuerelemente.
Formular-Methoden
Das Form-Objekt verfgt ebenfalls ber zahlreiche Methoden: ber 57, um genau zu sein. In der Mehrzahl sind sie von den Klassen Object und Control geerbt, so dass sie den meisten Objekten, mit denen Sie in Windows Forms arbeiten, zur Verfgung stehen. Eingeteilt nach Kategorien sollen einige davon hier vorgestellt werden. Neben den hier behandelten Methoden sollten Sie auch die bereits vorgestellten ObjectMethoden wie Equals und ToString nicht vergessen. Das Form-Objekt kann auch sie nutzen.
Aspekte der Bildschirmanzeige

Die ersten zwei Methoden sind Show und Hide. Diese beiden Funktionen machen Ihr Formular jeweils sichtbar oder unsichtbar, indem sie die Visible-Eigenschaft ndern. Sie verndern das Formular selbst nicht etwa das Entfernen aus dem Speicher oder der Aufruf anderer Funktionen , sondern nur, ob der Benutzer es sehen kann.
92
Die Close-Methode jedoch entsorgt ein Formular (und seine Steuerelemente) vollstndig durch das Entfernen aus dem Speicher. Setzen Sie diese Methode ein, wenn Sie Ihre Anwendung schlieen wollen oder wenn Sie einfach kein Formular mehr brauchen. Da Windows ja ein Multitasking-Betriebssystem ist, drfen viele Fenster gleichzeitig geffnet sein. Jedes Fenster muss um die Aufmerksamkeit des Benutzers wetteifern. Das FormObjekt verfgt ber einige Methoden, die Ihnen helfen, diese Schwierigkeit zu bewltigen. Die Activate-Methode aktiviert Ihr Formular. Das kann zweierlei bedeuten:
Wenn Ihre Anwendung die aktive ist, also vom Benutzer gerade verwendet wird, stellt Activate das Formular in den Vordergrund der Bildschirmanzeige, so dass es ber allen anderen Fenstern liegt. Falls es nicht die aktive Anwendung ist, blinken die Titelleiste und das Symbol in der Taskleiste, um die Aufmerksamkeit des Benutzers auf sich zu lenken. Wahrscheinlich haben Sie diese Art von Blickfang schon einmal gesehen; die gebruchlichste Verwendung findet sich bei Instant-Messaging-Anwendungen. Hat Ihnen jemand eine Instant Message (IM) gesendet, whrend Sie gerade in einer anderen Anwendung arbeiten, ffnet sich pltzlich das IM-Fenster im Hintergrund und seine Titelleiste blinkt.
Beim Blickfang noch etwas direkter als Activate sind die Methoden BringToFront und SendToBack. Die erste Methode stellt ein Formular vor alle anderen Fenster in der Bildschirmanzeige, so dass der Benutzer gezwungen ist, es anzusehen. Das ist ntzlich, falls etwas mit Ihrer Anwendung geschieht, das die volle Aufmerksamkeit des Benutzers verlangt (beispielsweise der Erhalt einer Instant Message). Umgekehrt stellt SendToBack ein Formular hinter alle anderen Fenster auf dem Bildschirm. SendToBack wird zwar nicht hufig benutzt, ist aber fr alle Flle vorhanden. Sie knnen die Eigenschaft TopMost auf true setzen, um dafr zu sorgen, dass Ihr Formular immer im Vordergrund steht. Besonders ntzlich ist dieses Leistungsmerkmal, wenn Alarm- oder Fehlermeldungen ausgegeben werden sollen. Schlielich funktioniert die Refresh-Methode hnlich wie die Schaltflche AKTUALISIEREN in Ihrem Web-Browser: Sie zeichnet alles im Formular neu und aktualisiert mitunter sogar dessen Inhalte. Wir werden nher auf diese Methode zu sprechen kommen, wenn wir GDI+ an Tag 13 durchnehmen.
Eigenschaften zurcksetzen
Das Form-Objekt verfgt ber eine Reihe von Reset-Methoden, mit denen Sie genderte Eigenschaften auf ihre Vorgabewerte zurcksetzen knnen. Alle diese Methoden folgen dem Bezeichnungsschema ResetEigenschaft. Einige der gebruchlicheren sind:

ResetBackColor ResetCursor
93
ResetFont ResetForeColor ResetText
Diese Methoden sind sehr ntzlich, wenn man etwas gendert hat und alles wieder rckgngig machen muss, man aber nicht wei oder sich nicht darum kmmert, welches jeweils der ursprngliche Wert war. Wenn der Benutzer beispielsweise in einem Textprogramm mehrmals die Schriftart ndert, aber dann wieder zu den Standardwerten zurckkehren mchte, knnte man ResetFont einsetzen.
3.2
Ereignisbehandlung
Ein Ereignis (event) ist etwas, das als Ergebnis einer Aktion oder Aktivitt passiert. Greifen Sie auf die Auto-Analogie zurck und stellen Sie sich bitte vor, dass Sie auf die Bremse treten (eine Aktion). Der Wagen hlt an (ein Ereignis). Treten Sie auf das Gaspedal (Aktion), fhrt der Wagen wieder an (Ereignis). Ein Ereignis ist stets die Folge einer Aktion, die stattgefunden hat. Auch Windows Forms verfgen ber Ereignisse, obwohl so manches davon nicht besonders augenfllig ist. ffnen und Schlieen etwa sind zwei Ereignisse, die erfolgen, wenn Sie Ihre Anwendung starten beziehungsweise beenden. Schieben Sie Ihren Mauszeiger ber das Formular, findet ein Ereignis statt, und wenn Ihr Mauszeiger es wieder verlsst, findet ein weiteres Ereignis statt. Ohne Ereignisse wren Windows Forms ziemlich fade, denn sie wrden nie etwas bewirken, ganz gleich, wie sehr der Anwender das auch erzwingen wollte.
Die Nachrichtenschleife
Ereignisse eignen sich in wunderbarer Weise dafr, Benutzereingaben zu handhaben. Lassen Sie uns zwei verschiedene Anwendungsmodelle betrachten eines mit, das andere ohne Ereignisse , bevor wir untersuchen, wie Anwendungen Ereignisse verwenden. Stellen Sie sich zunchst die ereignisgesteuerte Anwendung vor. Unter ereignisgesteuert versteht man, dass die Anwendung auf Ereignisse reagiert, die auf Benutzeraktionen hin erfolgen. Ohne diese Ereignisse wrde die Anwendung in der Tat berhaupt nichts tun. Die Ereignisse treiben die Anwendung quasi an. In diesem Modell ist die Anwendung unttig und wartet darauf, dass etwas passiert. Sie verwendet Ereignisse als ihr Stichwort, eine Aktion auszufhren. Ein Benutzer drckt beispielsweise eine Taste. Die Anwendung merkt, dass ein Ereignis stattgefunden hat
94
Ereignisbehandlung
(Tastendruck), fhrt eine Aktion aus, um das entsprechende Zeichen anzuzeigen, und wartet dann auf das nchste Ereignis. Eine Anwendung, die nicht ereignisgesteuert ist, gestattet dem Benutzer nicht die gewnschte Nutzung der Anwendung, vielmehr kann er lediglich auf ihre Aufforderungen reagieren. Mit einer ereignisgesteuerten Anwendung hingegen kann der Benutzer interagieren, ganz gleich, mit welchem ihrer Teile, zu welcher Zeit oder in welcher Reihenfolge. Stellen Sie sich einmal eine Taschenrechner-Anwendung vor, die nicht ereignisgesteuert wre. Sobald Sie die Anwendung gestartet haben, holt sie zwei Werte aus den Textfeldern, fhrt mathematische Berechnungen aus und gibt das Ergebnis aus. Befinden sich jedoch keine Werte in den Textfeldern, tut der Taschenrechner berhaupt nichts. Er kann nicht feststellen, ob sich eine Zahl gendert hat, da er keine Ereignisse erkennt. Jedes Mal, wenn Sie die Zahlen ndern, um einen anderen Wert zu berechnen, mssen Sie zuerst die Zahlen ndern und dann die Anwendung erneut ausfhren. Klassische Active Server Pages (also ASP als Vorgnger von ASP.NET) funktionieren auf diese Weise. Eine ASP-Anwendung wird ausgefhrt, sobald ein Benutzer die Seite von seinem Browser aus anfordert, dann gibt sie den ntigen HTML-Code aus und hlt an. Um das, was danach passiert, kmmern sich ASPs nicht, da sie nicht auf Ereignisse zu warten brauchen. Damit eine ASP-Anwendung Benutzereingaben verarbeitet, muss der Benutzer alle Eingaben in ein Webformular eintippen, bevor er es der ASP zur Verarbeitung zuschickt. Die ASP kennt nichts anderes als das, was ihr beim Start bekannt gegeben worden ist. Abbildung 3.8 illustriert diesen Vorgang.
Nicht ereignisbasiert Anwendung starten Benutzereingaben liefern
Verarbeitung
Stop
Abbildung 3.8: Anwendungen, die nicht ereignisgesteuert sind, erfordern einen dreistufigen Prozessablauf.
Beide Modelle haben ihre Vor- und Nachteile. Sobald sie einmal gestartet sind, laufen Anwendungen, die nicht ereignisgesteuert sind, ohne Benutzereingaben ab. Ereignisgesteuerte Anwendungen erfordern hingegen blicherweise eine Benutzereingabe, sind aber hufig reaktionsfhiger und interaktiv. Da aber Interaktion eine zwingende Eigenschaft einer jeden Windows-basierten Anwendung ist, werden alle Ihre Programme das ereignisgesteuerte Modell verwenden.
95
Wie also entdeckt eine Anwendung, dass ein Ereignis stattgefunden hat? Sobald eine typische Windows-Anwendung gestartet wird, tritt sie in eine Nachrichtenschleife ein. Dies ist lediglich eine Zeitspanne, in der die Anwendung auf eine Eingabe wartet oder auf Mitteilungen vom Benutzer (einen Befehl etwa). Die Zeitspanne dauert so lange, bis die Anwendung beendet wird, so dass dies als eine Schleife (oder Zyklus) bezeichnet wird. Whrend dieser Schleife tut die Anwendung nichts, auer auf eine Benutzereingabe zu warten (die Spanne der Nicht-Aktivitt wird Leerlauf bzw. idling genannt). Sobald eine Eingabe entgegengenommen wird, verrichtet die Anwendung ihr Werk und fllt dann wieder zurck in ihre Nachrichtenschleife. Dieser Zyklus setzt sich wieder und wieder fort, bis die Anwendung geschlossen wird. Wenn Sie etwas eingeben, ist das Windows-Betriebssystem die erste Stufe in der Verarbeitung. Windows entscheidet darber, zu welcher Anwendung das Ereignis gehrt, und schickt es ihr zu. Diese Nachrichten sind als Windows-Nachrichten bekannt, wovon die Bezeichnung Nachrichtenschleife abgeleitet wurde.
Ereignisbasiert Anwendung starten
in Messageschleife eintreten
Verarbeitung
Benutzereingabe
Falls Benutzereingabe auf Stop lautet, dann
Stop
Abbildung 3.9: Die Nachrichtenschleife wartet auf eine Benutzereingabe.
Wenn Sie beispielsweise ein Microsoft Word-Dokument das erste Mal ffnen, passiert nichts. Word wartet auf Ihre Eingabe. Sobald Sie eine Taste drcken, findet ein Ereignis statt, eine Methode wird ausgefhrt (um das Zeichen am Bildschirm anzuzeigen), dann fllt Word wieder in die Nachrichtenschleife zurck, um weiteren Input abzuwarten. Jedes Mal wenn Sie eine Taste drcken, hlt die Nachrichtenschleife fr einen Augenblick an, um etwas zu verarbeiten, und setzt dann das Warten fort. Abbildung 3.9 illustriert diesen Zyklus. Windows Forms sind blicherweise die primre Benutzeroberflche Ihrer Anwendungen. Daher handhaben sie eine ganze Reihe unterschiedlicher Ereignisse.
96
Ereignisbehandlung
Form-Ereignisse
Sie haben bereits gesehen, wie sich einige Ereignisse handhaben lassen. Im Beispiel des Taschenrechners aus der gestrigen Lektion nutzten Sie das Click-Ereignis des ButtonObjekts. Die Handhabung von Ereignissen in Windows Forms ist immer ziemlich die gleiche, ungeachtet der Objekte, denen die Ereignisse zugeordnet sind. An Tag 5 besprechen wir Ereignisse eingehender, wie man sie handhabt und welche Unterschiede zwischen verschiedenen Ereignissen bestehen. Nun lassen Sie uns aber frs Erste einen Blick auf einige der 71 Ereignisse des Form-Objekts werfen.
Die Ausfhrung steuern

Um Ihnen als Entwickler die grtmgliche Kontrolle ber Ihre Anwendung zu verleihen, werden manche Ereignisse sowohl vor als auch nach dem Eintreten einer Aktion gestartet. Wenn Sie beispielsweise Ihr Formular schlieen, findet das Closing-Ereignis direkt vor dem Schlieen des Formulars statt, das Closed-Ereignis direkt danach. Diese Arten von Ereignisnamen folgen stets den Regeln fr das Partizip Prsens bzw. Partizip Perfekt, daher Closing (sich gerade schlieend) und Closed (also geschlossen). Nicht alle Ereignisse treten in solchen Paaren auf. Wenn Sie jedoch einen ing-Ereignisnamen lesen, knnen Sie sicher sein, dass auch ein ed-Ereignis folgt; das gilt aber nicht umgekehrt. Was ist der Grund fr die Methode, zwei Ereignisse pro Aktion zu verwenden? Stellen Sie sich bitte einen groen Gemseladen vor, der um 20:00 Uhr schliet. Fnf Minuten, bevor der Laden eigentlich zumacht, wird ber die Lautsprecheranlage eine Ansage zu hren sein, die die Kunden bittet, dass sie sich zu den Kassen begeben mchten. Dieses Vor-Schlieen-Ereignis dient dazu, die Kunden zu warnen, dass etwas geschehen wird. Um 20:00 Uhr schliet der Laden, und alle Kunden werden zum Verlassen des Ladens aufgefordert, alle Tren werden verriegelt. Diese zweistufige Vorgehensweise erlaubt es sowohl dem Ladeninhaber oder Filialleiter als auch den Kunden, sich auf das tatschliche eintretende Ereignis des Ladenschlusses vorzubereiten. Bei Windows-Anwendungen verhlt es sich hnlich. Wenn z.B. ein Benutzer eine groe Zahl von nderungen an einem Word-Dokument vornimmt, dann die Anwendung mit Hilfe des SCHLIEEN-Steuerelements schliet, aber das Speichern seines Dokuments vergisst, was wrde dann geschehen? Wenn man auf das Closed-Ereignis warten wrde, bevor man etwas unternhme, wre es bereits zu spt: Das Dokument wre schon geschlossen worden, und alle nderungen wren verloren. In .NET jedoch wird das Closing-Ereignis ausgelst, bevor das eigentliche Schlieen des Dokuments eintritt. In diesem Fall knnen Sie nun den Benutzer auffordern, sein Dokument zu speichern, bevor die nderungen verloren gehen, und dadurch die nderungen zu erhalten. Sobald das Fenster geschlossen ist,
97
wird das Closed-Ereignis ausgelst. Danach knnen Sie jede Verarbeitungsmglichkeit nutzen, die Sie bentigen (etwa dem Benutzer eine Meldung anzeigen). Lassen Sie uns einen Blick auf ein Beispiel werfen, in dem dieser zweistufige Vorgang verwendet wird. Listing 3.5 verwendet die Closing- und Closed-Ereignisse im Form-Objekt, um das obige Beispiel zu illustrieren. Listing 3.5: Die Kontrolle der Programmausfhrung mit Hilfe von Ereignissen in VB .NET
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: Imports Imports Imports Imports System System.Windows.Forms System.Drawing System.ComponentModel
Namespace TYWinForms.Day3 public class Listing35 : Inherits Form public sub New() Me.Text = "Beispiel fr ein Ereignis" AddHandler Me.Closing, AddressOf Me.ClosingMsg AddHandler Me.Closed, AddressOf Me.ClosedMsg end sub public sub ClosingMsg(Sender as Object, e as CancelEventArgs) Microsoft.VisualBasic.MsgBox("Formular schliet sich") end sub public sub ClosedMsg(Sender as Object, e as EventArgs) Microsoft.VisualBasic.MsgBox("Formular ist geschlossen") end sub end class public class StartForm public shared sub Main() Application.Run(new Listing35) end sub end class End Namespace
In Zeile 4 wird ein Namensraum importiert, der noch nicht aufgetreten ist: System.ComponentModel. Er verfgt ber Objekte, die Ereignisse betreffen, die man weiter unten im Code bentigt. Die Zeilen 6 bis 10 sind nichts Besonderes. Die
98
Ereignisbehandlung
Zeilen 11 und 12 verwenden die AddHandler-Methode (die Ihnen an den Tagen 1 und 2 begegnet ist), um der CLR zu befehlen, die Methoden ClosingMsg und ClosedMsg (in den Zeilen 15 und 19) auszufhren, wenn die Closing- und Closed-Ereignisse jeweils ausgelst werden. Wir springen in Zeile 15 zur Closing-Methode, die ausgefhrt wird, sobald das Closing-Ereignis ausgelst worden ist und sich das Formular tatschlich schliet. Sehen Sie sich zunchst die Signatur (die erste Zeile) dieser Methode an. Sie bernimmt zwei Parameter: ein Object- und ein System.ComponentModel.CancelEventArgs-Objekt. Sie wissen bereits, was das Object-Objekt ist. Der zweite Parameter ist ein spezialisiertes Objekt, das nur fr Ereignisse gilt, insbesondere fr Closing-Ereignisse. Es verfgt ber eine besondere Eigenschaft namens Cancel, um damit den Vorgang in diesem Fall das Schlieen des Formulars zu unterbrechen, falls dies ntig sein sollte (wie etwa im Beispiel des Textprogramms). Wenn Sie festlegen, dass das Schlieen gestoppt werden soll (etwa weil der Benutzer vergessen hat, sein Dokument zu speichern), setzen Sie die Cancel-Eigenschaft auf true:
e.Cancel = true
Die Anwendung wird mit dem Schlieen innehalten und in die Nachrichtenschleife zurckkehren. In unserem Fallbeispiel befassen wir uns nicht damit zu verhindern, dass das Formular geschlossen wird. In Zeile 16 rufen wir vielmehr eine Methode auf, die eine Meldung auf dem Bildschirm anzeigt. Die MsgBox-Methode des Namensraums Microsoft.VisualBasic prsentiert lediglich ein Popup-Feld mit dem festgelegten Text darin. (Beachten Sie, dass wir anstatt den vollen Namen der MsgBox-Methode in Zeile 16 zu verwenden, auch den Namensraum Microsoft.VisualBasic mit Hilfe von Imports htten importieren knnen.) In Zeile 19 beginnt die Methode ClosedMsg. Sie wird ausgefhrt, nachdem das Formular sich geschlossen hat. Beachten Sie, dass sie als zweiten Parameter ein EventArgs-Objekt statt CancelEventArgs bernimmt. Den Grund dafr besprechen wir an Tag 5. Diese Methode wiederum ruft die MsgBox-Funktion auf, um eine weitere Meldung anzuzeigen, die den Benutzer darber informiert, dass das Formular geschlossen wurde. Kompilieren Sie zum Schluss diesen Code, entweder mit VS .NET oder mit folgendem Befehl:
vbc /t:winexe /r:system.windows.forms.dll /r:system.drawing.dll listing.3.5.vb
Sie erinnern sich bestimmt noch von Tag 2 daran, dass sich der Namensraum System.ComponentModel in der Assembly System.dll befindet. Das ist der Grund, warum wir hier keine
99
neuen Assemblies referenzieren mssen. Abbildung 3.10 zeigt die Ausgabe, nachdem das Steuerelement zum Schlieen des Fensters angeklickt worden ist.
Abbildung 3.10: Das Closing-Ereignis erlaubt Ihnen, das ClosedEreignis abzufangen.
Nicht alle Ereignisse folgen diesem zweistufigen Ablauf. Man findet ihn aber bei einigen
Form-Objekten, die Tabelle 3.2 beschreibt. Ereignis
Closed
Beschreibung Erfolgt beim Schlieen eines Formulars
InputLanguage- Erfolgt, sobald der Benutzer die Sprache des Formulars zu ndern versucht Changed Validated
Erfolgt, sobald die Eingabe eines Steuerelements auf Gltigkeit geprft worden ist
Tabelle 3.2: Ereignisse, die vor dem Cursor-Einsatz stattfinden
Es gibt einige wichtige Ereignisse, von deren Existenz Sie Kenntnis haben sollten, wenn Sie mit Windows Forms zu tun haben. Closed haben Sie ja bereits kennen gelernt: Es wird ausgelst, sobald sich ein Formular schliet. Es gibt weiter ein Load-Ereignis, das sofort ausgelst wird, noch bevor ein Formular zum ersten Mal angezeigt wird. Der Ereignishandler fr dieses Ereignis ist hufig eine geeignete Stelle, um Komponenten fr Ihr Formular zu initialisieren, d.h. falls Sie sie noch nicht im Konstruktor initialisiert haben sollten. Das Activated-Ereignis findet statt, sobald Ihr Formular den Fokus erhlt und zur aktiven Anwendung wird es korrespondiert mit der Activate-Methode. Dementsprechend wird
100
Ereignisbehandlung
Deactivate ausgelst, sobald Ihr Formular deaktiviert wird, also den Fokus verliert, oder wenn eine andere Anwendung die aktive wird.
Maus- und Tastaturereignisse

Maus- und Tastaturaktionen gehren zu den wichtigsten Arten von Ereignissen. Schlielich sind dies wesentliche Formen von Benutzereingaben. Daher gibt es eine ganze Reihe von Ereignissen, die mit diesen zwei Eingabegerten verbunden sind. Lassen Sie uns mit Tastaturereignissen anfangen. Zuerst an der Reihe ist das KeyPress-Ereignis. Es erfolgt jedes Mal, wenn eine Taste gedrckt wird, ganz gleich welche (wir sehen gleich noch, wie man feststellt, welche Taste es war). Falls dieses Ereignis nicht gengend Kontrollmglichkeiten erffnet, gibt es noch die Ereignisse KeyDown und KeyUp, die jeweils ausgelst werden, sobald eine Taste heruntergedrckt und dann wieder losgelassen wird. Diese Ereignisse liefern zustzliche Informationen (etwa welche Taste gedrckt wurde), die Sie in Ihrer Anwendung nutzen knnen. Ihre Ereignishandler, also diejenigen Methoden, die ausgefhrt werden, sobald das Ereignis ausgelst worden ist, sind dementsprechend spezialisiert. In VB .NET erfolgt das Deklarieren dieser Handler auf die gleiche Weise, mit der Sie bereits vertraut sind:
'VB .NET AddHandler Form1.KeyPress, AddressOf methodenName AddHandler Form1.KeyDown, AddressOf methodenName AddHandler Form1.KeyUp, AddressOf methodenName
In C# mssen Sie jedoch die spezialisierten Handler bercksichtigen. Statt EventHandler in Zeile 18 von Listing 3.4 wie gewohnt zu verwenden
18: btAccept.Click += new EventHandler(this.AcceptIt);
mssen Sie die Objekte KeyPressEventHandler und KeyEventHandler einsetzen:

//C# Form1.KeyPress += new KeyPressEventHandler(methodenName) Form1.KeyDown += new KeyEventHandler(methodenName) Form1.KeyUp += new KeyEventHandler(methodenName)
Genau wie das CancelEventArgs-Objekt besitzen auch die Objekte KeyPressEventHandler und KeyEventHandler besondere Eigenschaften, die Ihrer Anwendung helfen festzustellen, welche Aktion das jeweilige Ereignis ausgelst hat. Der KeyPressEventHandler hat zwei Eigenschaften: Handled und KeyChar. Bei der ersten Methode handelt es sich lediglich um einen true- oder false-Wert, der anzeigt, ob Ihre Methode den Tastendruck verarbeitet hat (ist das nicht der Fall, wird der Tastendruck zur Verarbeitung an das Windows-Betriebssystem geschickt). Meistens werden Sie diese Eigen-
101
schaft auf true setzen, es sei denn, Sie wnschen explizit, dass das Betriebssystem diesen speziellen Tastendruck verarbeitet (wenn Sie etwa die Taste (Druck) nicht handhaben mssen, leiten Sie dies an das Betriebssystem weiter). Die Eigenschaft KeyChar liefert einfach die Taste, die gedrckt wurde. Listing 3.6 zeigt ein Beispiel in VB .NET. Listing 3.6: Verarbeitung von Tastenbettigungen
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: Imports Imports Imports Imports System System.Windows.Forms System.Drawing System.ComponentModel
Namespace TYWinForms.Day3 public class Listing36 : Inherits Form public sub New() Me.Text = "Tastendruck-Beispiel" AddHandler Me.KeyPress, AddressOf Me.KeyPressed end sub public sub KeyPressed(Sender as Object, e as KeyPressEventArgs) Microsoft.VisualBasic.MsgBox(e.KeyChar) e.Handled = True end sub public shared sub Main() Application.Run(new Listing36) end sub end class End Namespace
In Zeile 11 stoen Sie auf den Ereignishandler namens KeyPressed, welcher dem Ereignis KeyPress zugeordnet ist. In Zeile 14 deklarieren Sie den Ereignishandler. Beachten Sie bitte, dass er ein KeyPressEventArgs-Objekt als Parameter bernimmt dieser Name korrespondiert mit dem KeyPressEventHandlerObjekt, das wir weiter oben besprochen haben. In Zeile 15 zeigen Sie einfach das gedrckte Zeichen in einem Meldungsfeld an und setzen dann in Zeile 16 die Handled-Eigenschaft auf true. Abbildung 3.11 zeigt die entsprechende Bildschirmausgabe, wenn das groe A gedrckt wurde (() + (a)). Beachten Sie jedoch, dass lediglich Buchstaben, Zahlen und die ()-Taste das KeyPressEreignis auslsen. Um andere Tasten wie etwa (Strg), (Alt) und die Funktionstasten (F1) bis (F12) zu handhaben, mssen Sie die KeyUp- und KeyDown-Ereignisse verwenden. Erin-
102
Ereignisbehandlung
nern Sie sich daran, dass diese Ereignisse Handler des Typs KeyEventhandler nutzen, so dass der zweite Parameter Ihrer Ereignishandler-Methode auf KeyEventArgs lauten muss:
Public Sub KeyReleased(Sender as Object, e as KeyEventArgs) 'ein wenig Code end Sub
Abbildung 3.11: Solange Ihr Formular den Fokus besitzt, fhrt jeder Tastendruck die KeyPressed-Methode aus.
Das Objekt KeyEventArgs verfgt ber mehrere Eigenschaften, die sich als ntzlich erweisen, um festzustellen, welche Taste gedrckt wurde:

Alt: Wahr- oder Falsch-Wert, der anzeigt, ob die (Alt)-Taste gedrckt wurde Control: zeigt an, ob die (Strg)-Taste gedrckt wurde Handled: entspricht der Handled-Eigenschaft des Objekts KeyPressEventArgs KeyCode: der Tastaturcode fr die gedrckte Taste KeyData: die Tastendaten fr die gedrckte Taste KeyValue: der Tastaturcode fr die gedrckte Taste Modifiers: gibt Flags zurck, die anzeigen, welche Tasten und Zusatztasten (wie etwa (), (Strg) oder (Alt)) gedrckt wurden Shift: zeigt an, ob die ()-Taste gedrckt wurde
Jede Taste auf der Tastatur hat eindeutige KeyCode-, KeyData- und KeyValue-Werte. Die Eigenschaften KeyCode und KeyValue sind blicherweise gleich. KeyData weist bei den meisten Tasten den gleichen Wert wie die beiden anderen Eigenschaften auf, ist jedoch unter-
103
schiedlich bei Zusatztasten (eine vollstndige Referenz finden Sie bei der Keys- bzw. Tasten-Aufzhlung in der Dokumentation des .NET Frameworks). Mausereignisse finden in einer standardisierten Reihenfolge statt: 1. MouseEnter: sobald der Mauszeiger ber das Formular gelangt 2. MouseMove: wenn der Mauszeiger sich ber dem Formular bewegt 3. MouseHover: wenn der Mauszeiger einfach nur ber dem Formular schwebt (d.h. ohne Bewegung oder Mausklick) 4. MouseDown: wenn man ber dem Formular eine Maustaste drckt 5. MouseUp: wenn man die Maustaste wieder lst 6. MouseLeave: wenn der Mauszeiger das Formular wieder verlsst (sich vom Formular wegbewegt) Die Ereignisse MouseEnter, MouseHover und MouseLeave liefern keine besonderen Informationen und verwenden daher den standardmigen Ereignishandler EventHandler und die Ereignisparameter-Objekte EventArgs. Die Ereignisse MouseMove, MouseDown und MouseUp liefern hingegen spezifische Informationen und verwenden alle die MouseEventArgsObjekte des Ereignishandlers MouseEventHandler:
public Sub MouseClick(Sender as Object, e as MouseEventHandler)
Das MouseEventhandler-Objekt liefert Information wie etwa die genaue Position des Mauszeigers auf dem Bildschirm, welche Maustaste gedrckt wurde usw. Die Eigenschaften sind in Tabelle 3.3 zusammengefasst.
Eigenschaft
Button
Beschreibung Holt die Information ein, welche Maustaste gedrckt wurde (MouseButtons.Left, MouseButtons.Middle, MouseButtons.None, MouseButtons.Right, MouseButtons.XButton1 oder MouseButtons.XButton2) Die Anzahl von Mausklicks (ein Integerwert) Die Anzahl von Drehungseinheiten, um die sich das Mausrad bewegt hat Die x-Bildschirmkoordinate des Mauszeigers Die y-Bildschirmkoordinate des Mauszeigers
Clicks Delta X Y
Tabelle 3.3: Eigenschaften von MouseEventHandler
104
Ereignisbehandlung
Drag & Drop

Das mit Windows eingefhrte Merkmal des Drag & Drop, also des Klickziehens, erlaubt es dem Anwender, eine Art Abkrzung zu nehmen, indem er mit der Maus ein Symbol auf dem Bildschirm auf eine Anwendung zieht. Diese bernimmt die Datei, die vom Symbol dargestellt wird, und verarbeitet sie. Haben Sie beispielsweise Microsoft Word geffnet und ziehen das Symbol eines Word-Dokuments darauf, ffnet Word dieses Dokument automatisch zur Bearbeitung. Klickziehen erlaubt Ihnen auch, nur mit der Maus Dateien aus einem Ordner in einen anderen zu verschieben oder zu kopieren. Es ist recht einfach, eine Windows Forms-Anwendung fr Drag & Drop fit zu machen. Als Erstes mssen Sie die Eigenschaft DragDrop des Formulars auf true setzen und dann den Code fr die Ereignisse DragDrop, DragEnter, DragLeave oder DragOver schreiben. Die letzten drei Ereignisse sind den hnlich benannten Mausereignissen sehr hnlich; sie treten auf, wenn ein Symbol in oder aus Ihrem bzw. ber Ihr Formular bewegt wird. Alle diese Ereignisse verwenden den Objekt-Handler DragEventHandler und den Ereignisparameter DragEventArgs. Wir werfen einen Blick auf die Eigenschaften dieses Parameters. Die Eigenschaft AllowedEffects ist ein Indikator, der besagt, welche Drag & DropAktionen stattfinden knnen. Wenn Sie etwa versuchen, eine Datei, die nur gelesen werden darf, zu ziehen und abzulegen, knnen Sie diese Datei nur kopieren, nicht aber verschieben. Die Aktionen werden durch die DragDropEffects-Aufzhlung angezeigt: DragDropEffects.All, DragDropEffects.Copy, DragDropEffects.Link, DragDropEffects.Move, DragDropEffects.None und DragDropEffects.Scroll. Alle diese Effekte entsprechen einfachen Windows-Funktionen. Die Eigenschaft DragEventsArgs wiederum gibt den sich gerade ereignenden Effekt an. Dieser ist einer der oben aufgefhrten DragDropEffects-Werte. Wenn der Benutzer etwa eine Datei zieht, whrend er die (Strg)-Taste gedrckt hlt, wird versucht, eine Kopieroperation durchzufhren, und die Effect-Eigenschaft wird DragDropEffects.Copy anzeigen. Die Data-Eigenschaft enthlt das Element, das gerade Gegenstand einer Drag & DropOperation ist. Ungeachtet seines Typs wird dieses Element vom IdataObject-Objekt dargestellt, das zahlreiche unterschiedliche Objekttypen abbilden kann. (Nhere Informationen hierzu finden Sie in der Dokumentation zum .NET Framework.) Die Eigenschaft KeyState verrt Ihnen, ob jeweils die Taste (), (Strg) oder (Alt) gedrckt ist, genau wie die Alt-, Control- und Shift-Eigenschaften der KeyUp- und KeyDownEreignisse. Die X- und Y-Eigenschaften schlielich sind die gleichen wie jene fr Mausereignisse. Sie zeigen an, an welcher Stelle (im Koordinatensystem) sich zum Zeitpunkt des Ereignisses ein Element befand.
105
nderungsereignisse
Jedes Mal wenn sich eine der Form-Eigenschaften ndert, ist damit normalerweise ein Ereignis verbunden. Wenn man beispielsweise die Text-Eigenschaft des Formulars ndert, wird das TextChanged-Ereignis ausgelst. Meist werden diese Ereignisarten fr Validierungsroutinen verwendet. Wenn Sie etwa die Zahl der in Ihrem Formular verwendbaren Schriftarten begrenzen wollen, knnten Sie einen Handler fr das FontChanged-Ereignis erzeugen, der ungltige Benutzerauswahlen berschreibt. Ich werde hier nicht alle diese Ereignisse auffhren. Sie knnen feststellen, welche das sind, indem Sie einfach das Wort Changed (gendert) an die jeweiligen Eigenschaften anhngen, ber die Sie heute gelesen haben: TextChanged, CursorChanged, VisibleChanged usw. Alle diese Methoden verwenden Handler vom Typ EventHandler.
3.3
Zusammenfassung
Das Basisobjekt fr alle anderen Objekte ist im .NET Framework nomen est omen das Object-Objekt. Da es so allgemeingltig gefasst ist, wird es an verschiedenen Stellen verwendet, an denen ein spezialisiertes Objekt entweder nicht gebraucht wird oder sich nicht genauer bestimmen lsst. Object verfgt ber fnf Methoden Equals, ReferenceEquals, GetHashCode, GetType und ToString , die alle anderen .NET-Objekte erben. Das indirekt von Object abgeleitete Objekt System.Windows.Forms.Form stellt blicherweise den Hauptbestandteil Ihrer Windows Forms-Anwendungen dar. Es stellt den Rahmen und Hintergrund fr weitere Bestandteile der Benutzerschnittstelle bereit und enthlt selbst eine reiche Palette an Funktionen. Das Form-Objekt besitzt 101 Eigenschaften, mit denen Sie praktisch jeden einzelnen Aspekt der Benutzeroberflche steuern knnen. Sie knnen Ihr Formular mit Hilfe der Opacity-Eigenschaft transparent machen, es mit der Eigenschaft FormBorderStyle nichtskalierbar machen, und Sie knnen die Art und Weise der Benutzerinteraktion mit Hilfe der Eigenschaften MaximizeBox, MinimizeBox, HelpButton, SizeGripStyle und ControlBox kontrollieren.
Form verfgt zudem ber zahlreiche Methoden wie etwa BringToFront oder Focus, die Sie zur Steuerung der Bildschirmanzeige ausfhren knnen.
Sie haben etwas ber Ereignisse und die Nachrichtenschleife erfahren, die einer Anwendung das Unttigsein erlaubt, bis ein Benutzer eine Eingabe vornimmt. Das Form-Objekt verfgt ber Ereignisse, die anlsslich zahlreicher Benutzeraktivitten ausgelst werden, darunter Mausklick, Tastendruck und Drag & Drop.
106
3.4
F
Kann ich von einem selbst erstellten Formular erben? Wie werden dabei Eigenschaften behandelt? A Das ist zutreffend; Sie knnen von jeder Klasse erben, es sei denn, sie ist mit dem Schlsselwort NonInheritable (in C# heit es sealed) deklariert. Der Umgang mit geerbten Eigenschaften ist hufig kompliziert. Schauen Sie sich als Beispiel folgenden Code an:
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32: Imports System Imports System.Windows.Forms Imports System.Drawing Public Class ClassA : Inherits Form private lblMessage as New Label Public Sub New() lblMessage.Location = new Point(100,100) lblMessage.Height = 100 lblMessage.Width = 200 lblMessage.Text = "Hello World!" Me.Controls.Add(lblMessage) End Sub End Class Public Class ClassB : Inherits ClassA private lblMessage as New Label Public Sub New() lblMessage.Location = new Point(100,100) lblMessage.Height = 100 lblMessage.Width = 200 Me.Controls.Add(lblMessage) End Sub End Class Public Class StartForm Public Shared Sub Main() Application.Run(New ClassB) End Sub End Class
Wenn Sie diese Anwendung kompilieren und ausfhren, wird das von ClassB definierte Formular angezeigt. Beachten Sie, dass in dieser Klasse nirgends die Text-
107
Eigenschaft des in Zeile 18 deklarierten Bezeichnungsfelds (Label) gesetzt wird. Wenn Sie jedoch die Anwendung ausfhren, enthlt das Bezeichnungsfeld den Text Hello World! Dieser Text wird in Zeile 12 in ClassA festgelegt. All dies passiert nicht deshalb, weil das Bezeichnungsfeld von ClassB von ClassA geerbt worden wre, sondern vielmehr, weil im Konstruktor von ClassA ein Bezeichnungsfeld mit dem fraglichen Text erstellt und dem Formular hinzugefgt wird. Erinnern Sie sich daran, dass in jedem Konstruktor als Erstes ein Aufruf an den Konstruktor seiner Basisklasse erfolgt. Daher ist zur Ausfhrungszeit des Konstruktors von ClassB bereits ein Bezeichnungsfeld mit den Worten Hello World! vorhanden. Sie knnen jedoch von ClassB aus dieses Bezeichnungsfeld nicht bearbeiten. Es ist nmlich in Zeile 6 als private deklariert und daher nur fr ClassA zugnglich. Wrden Sie es in public ndern, erhielten Sie eine Fehlermeldung, denn ClassB htte das Bezeichnungsfeld lblMessage geerbt und Zeile 18 wrde versuchen, es zu redeklarieren das ist leider keine gltige Operation. Unterm Strich lsst sich also sagen, dass Vorsicht beim Erben eigener Klassen angebracht ist. Achten Sie ebenfalls auf den Kontext der Sicherheit, in dem Variablen deklariert werden.
3.5
Workshop
Quiz
Die Fragen 1 bis 3 beziehen sich auf das folgende Codefragment:
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: using System; using System.Windows.Forms; using System.Drawing; public class MyForm : Form { private Label lblMessage = new Label(); public MyForm() { this.Text = "Hello World!"; } }
108
Workshop
12: 13: 14: 15: 16: 17:
public class StartForm { public static void Main() { Application.Run(new MyForm()); } }
1. Was wrde das folgende Statement liefern, wenn man es unter Zeile 9 platzieren wrde?
Console.Write(this.ToString());
2. Was wrde der folgende Code liefern, wenn man ihn unter Zeile 9 platzieren wrde?
Label lblTemp = new Label(); Console.Write(lblTemp.Equals(this.lblMessage).ToString());
3. Was wrde der folgende Code liefern, wenn man ihn unter Zeile 9 platzieren wrde?
Label lblTemp = new Label(); Console.Write(Object.ReferenceEquals(lblTemp, this.lblMessage).ToString());
4. Wahr oder falsch? Das KeyPress-Ereignis erfordert einen Handler vom Typ KeyEventHandler. 5. Nennen Sie die fnf Eigenschaften des Objekts MouseEventArgs. 6. Schreiben Sie ein einzelnes Statement in VB .NET, das die Breite eines Formulars auf ein Drittel der Bildschirmhhe festlegt. 7. Welche Eigenschaft kontrolliert, welche Schaltflche aktiviert wird, sobald der Benutzer die (ESC)-Taste gedrckt hat? 8. Welches ist der Standardwert von FormBorderStyle? 9. Welche drei Ereignisse verwenden das Paradigma, dass mit einer einzelnen Aktion zwei Ereignisse verknpft sind?
bungen
1. Erstellen Sie in C# eine Anwendung, die alle sechs Mausereignisse berwacht. Zeigen Sie eine Meldung in einem Textfeld an, wenn die einzelnen Ereignisse auftreten. 2. Erstellen Sie in VB .NET eine Anwendung, mit der die Benutzer die Eigenschaften Text, Height, Width und Opacity durch Werteingaben in eine TextBox und das Drcken einer EINGEBEN-Schaltflche anpassen knnen.
109
Mens und Symbolleisten
Mittlerweile drften Sie mit dem Form-Objekt und dem Erstellen von Windows FormsAnwendungen vertraut sein. Sie haben bereits gelernt, wie Sie die Benutzeroberflche verndern, indem Sie einige Steuerelemente wie etwa Label oder TextBox einfgen sowie die Eigenschaften des Formulars verndern. Schauen wir uns einmal einige trickreichere Steuerelemente an. Mens und Symbolleisten gehren zur Standardausstattung einer Benutzeroberflche. Praktisch jede Windows-Anwendung weist sie auf, und die Benutzer wissen sie zu bedienen. Darber hinaus verleihen sie Ihrer Anwendung ein vollstndigeres und gepflegteres Aussehen. Dieses Kapitel zeigt, wie Sie diese gebruchlichen UI-Elemente erstellen und dem Benutzer gestatten, sie zu bedienen. Heute lernen Sie,

was Windows Forms-Steuerelemente sind, wie Sie Ihren Formularen interaktive Mens hinzufgen, wie Sie Ihre Anwendung kontextabhngig machen, wie Sie Schaltflchen in eine Symbolleiste einfgen, wie man Informationen in der Statusleiste anzeigt, wie Sie Ihrer Anwendung Bildlaufleisten hinzufgen.
4.1
Einfhrung in Windows Forms-Steuerelemente
An den Tagen 1 bis 3 haben Sie mit einigen Steuerelementen gearbeitet, doch Sie haben eigentlich nicht untersucht, was man unter einem Steuerelement versteht. Lassen Sie uns einen Schritt zurcktreten und uns ansehen, was Steuerelemente (Controls) sind und warum und wozu man sie verwendet. Fr den Benutzer ist ein Windows Forms-Steuerelement ein selbststndiger Bestandteil der Benutzeroberflche. Schaltflchen, Mens und Listenfelder sind allesamt Steuerelemente. Manche davon, wie etwa Schaltflchen, sind interaktiv, whrend andere, wie etwa LabelSteuerelemente (Bezeichnungsfelder), es nicht sind. Den Benutzer kmmert es nicht, wie ein Steuerelement genau funktioniert er kann es intuitiv nutzen, um seine Aufgaben zu erledigen. Stellen Sie sich ein Steuerelement wie eine Uhr vor. Der Benutzer sieht nur das uere der Uhr und daher nur uere Eigenschaften, wie etwa die Farbe oder die Uhrzeit. Der Benutzer kann die Standuhr verschieben und Dinge darauf platzieren, denn sie ist eine physische Entitt, die sich manipulieren lsst.
112
Einfhrung in Windows Forms-Steuerelemente
Der Entwickler hingegen betrachtet die Uhr (das Steuerelement) ein wenig anders, da er in der Lage ist, sie zu ffnen und ihr Innenleben zu manipulieren: die Zeit einstellen, sie aufziehen, die Zahnrder verndern, das Pendel in Gang setzen usw. Die Uhr steht immer noch fr einen Teil der Benutzeroberflche, doch sie ist auch ein Gegenstand mit Eigenschaften, Methoden und Ereignissen. Ein Steuerelement lsst sich ebenso steuern wie das Form-Objekt. Jedes Steuerelement wird ebenfalls aus einer Klasse erzeugt, die genau jenen Klassen hnelt, die Sie erstellt haben. Das Steuerelement erbt von anderen Klassen, die sich im .NET Framework befinden. Die Standuhr prsentiert Ihnen ebenso wie Windows Forms-Steuerelemente zwei Gesichter (vgl. Abbildung 4.1): ein ueres fr den Benutzer, ein tiefer reichendes inneres fr den Entwickler. (Es gibt sogar noch tiefer reichende. Schlielich kann der Hersteller der Zahnrder Elemente kontrollieren, auf die der Entwickler keinen Zugriff hat.) Ihnen ist bekannt, dass Forms, Objects und Steuerelemente Objekte sind, die Sie mit Hilfe ihrer Methoden und Eigenschaften manipulieren knnen. Wir wollen einmal unser Lieblingsobjekt, Form, mit Formular-Steuerelementen vergleichen.
Forms und Steuerelemente sind einander sehr hnlich. Sie erben beide (direkt oder indirekt) von der Control-Klasse, demzufolge teilen sie zahlreiche Eigenschaften und Methoden miteinander, so etwa ToString, Equals und GetType. Da Sie das Form-Objekt zu
verwenden wissen, kennen Sie die Grundlagen fr die Verwendung aller Steuerelemente. Auch Steuerelemente werden im Namensraum System.Windows.Forms gespeichert.
Entwickler kann mit Innenleben arbeiten
Benutzer sieht ueres
Abbildung 4.1: Ein Steuerelement stellt ein inneres und ein ueres Gesicht zur Schau.
Der Unterschied zwischen einem Form und einem Steuerelement besteht darin, dass ein Steuerelement in einer anderen Komponente enthalten sein muss das ist meistens, aber nicht zwingend ein Form. Steuerelemente bilden den Schwerpunkt der Interaktion des Benutzers, denn normalerweise wird der Hintergrund einer Anwendung (der leere FormBereich) einfach ignoriert. Werfen wir einen kurzen Blick auf die mglichen Typen von Steuerelementen (wir untersuchen sie detaillierter an Tag 6):
113
Containersteuerelement e: Eine Reihe von Steuerelementen wurde exklusiv dafr entworfen, andere Steuerelemente aufzunehmen. Steuerelemente wie etwa das PanelSteuerelemente gruppieren Elemente nicht nur, um die Benutzeroberflche aufzurumen, sondern um dem Entwickler ihre Bearbeitung zu erleichtern. Fgen Sie etwa einem Panel weitere Steuerelemente hinzu, knnen Sie deren gemeinsame Eigenschaften mit einem einzigen Befehl ndern, statt fr jedes Steuerelement einen Befehl auszugeben. Schaltflchen-Steuerelemente: Sie haben bereits mit dem Steuerelement Button gearbeitet. Diese Kategorie umfasst weitere Steuerelemente wie etwa CheckBox und RadioButton, die zwar nicht wie Schaltflchen aussehen mgen, sich aber tatschlich so verhalten. Eine CheckBox etwa, also ein ankreuzbares Kstchen wie jene in Web-Formularen, lsst sich anklicken, verfgt ber eine zugeordnete Textmeldung und kann auf einen Klick hin eine Aktion ausfhren genau wie ein regulrer Button. Diese Steuerelemente gehren zu den gebruchlichsten in Windows Forms. Listen-Steuerelemente: Listen-Steuerelemente werden blicherweise verwendet, um Daten, meist aus Datenbanken, anzuzeigen. Zu dieser Kategorie gehren Steuerelemente wie die ComboBox und die ListBox. Mit ihnen zu arbeiten, ist nicht einfach, da man dabei mit Sammlungen von Daten arbeitet (im Gegensatz dazu ist es einfach, den Umgang mit ihnen zu erlernen!). Wir berspringen ihre nhere Betrachtung, bis Sie an Tag 9 lernen, wie Sie mit Daten und Datenbanken arbeiten. Men-Steuerelemente: Mens gehren neben Schaltflchen zu den gebruchlichsten Steuerelementen in einer Anwendung: von normalen Symbolleisten-Mens bis hin zu Kontextmens. Der Rest dieses Kapitels beschftigt sich mit der Funktionsweise dieser Steuerelemente. Weitere Steuerelemente: Zu den Steuerelementen, die nicht in die obigen Kategorien passen, gehren etwa das Label-Steuerelement, Zeit- und Datum-Steuerelemente sowie das Steuerelement TreeView (Strukturansicht). Das bedeutet nicht, dass sie weniger wichtig wren, im Gegenteil: Wie Sie bereits gesehen haben, ist das Label-Steuerelement eines der gebruchlichsten berhaupt.
Lassen Sie uns ohne weiteren Verzug lernen, wie man Mens erstellt!
4.2
Mens hinzufgen
Wir alle knnen uns etwas unter Mens und ihrer Verwendung vorstellen, doch lassen Sie uns ein wenig rekapitulieren. Ein Men ist eine Gruppe hnlicher Befehle, die sich in einer direkt unter der Titelleiste befindlichen Leiste befinden. Die Titelzeile des Hauptmens dient lediglich der Gruppierung der Kategorien und fhrt ansonsten keine Funktionen
114
Mens hinzufgen
aus. Die Unterelemente sind die eigentlichen Arbeitsbienen unter den Mens. Manchmal knnen sogar Unterelemente als Mens dienen, um so weitere Befehle zu Unterkategorien zusammenzufassen. Abbildung 4.2 zeigt ein typisches Men.
Abbildung 4.2: Das DATEI-Men des Internet Explorers ist typisch fr ein Befehlsmen.
In Abbildung 4.2 beachten Sie bitte die waagrechten Linien, die Mengruppen im DATEI-Men voneinander trennen. Diese Zeilen werden Separatoren oder Trennlinien genannt und sie helfen dem Benutzer bei der Navigation in den Anwendungsmens. Wie Sie Trennlinien in Ihre Mens integrieren, lernen Sie im heutigen Abschnitt Mens anpassen weiter unten. In .NET werden die Menkopfzeilen durch das Objekt MainMenu dargestellt, Unterelemente jedoch durch MenuItem-Steuerelemente. Diese hneln den Ihnen bereits bekannten Steuerelementen, also lassen Sie uns daher in etwas Code eintauchen. Listing 4.1 ist ihr erster Vorsto ins Men-Territorium. Listing 4.1: Beispiel fr Ihr erstes Men, geschrieben in VB .NET
1: 2: 3: 4: 5: 6: 7: Imports System Imports System.Windows.Forms Namespace TYWinForms.Day4 public class Listing41 : Inherits Form private mnuFile as new MainMenu
115
8: private lblMessage as new Label 9: 10: public sub New() 11: Me.Text = "Listing 4.1" 12: Me.Menu = mnuFile 13: 14: dim miFile as MenuItem = mnuFile.MenuItems.Add("&Datei") 15: miFile.MenuItems.Add(new MenuItem("&ffnen...")) 16: 17: lblMessage.Text = "Ich liebe WinForms" 18: lblMessage.Width = 200 19: lblMessage.Height = 200 20: 21: Me.Font = new System.Drawing.Font(new System.Drawing.FontFamily("Arial"), 15) 22: Me.Controls.Add(lblMessage) 23: End Sub 24: 25: public Shared Sub Main() 26: Application.Run(new Listing41) 27: end sub 28: end class 29: 30: End Namespace
Ab Zeile 7 erzeugen wir eine Instanz unseres ersten neuen Objekts, dem MainMenu. Dadurch erhalten wir ein Gerst fr das Einfgen weiterer Mens. Dies und entsprechende Befehle folgen spter. In Zeile 12 machen Sie Bekanntschaft mit einer neuen Eigenschaft des Form-Objekts: Menu. Menu muss stets auf ein MainMenu-Objekt zeigen, insbesondere auf das MainMenu des Formulars. Auf diese Weise knnen Sie so viele Mens erzeugen, wie Sie wnschen, und dann dasjenige, das angezeigt wird, austauschen einfach indem Sie die Menu-Eigenschaft bearbeiten. In Zeile 14 sehen Sie die erste Instanz des MenuItem-Objekts. Es lsst sich sehr vielseitig verwenden; es kann jedes Menelement (MenuItem) darstellen, ganz gleich, ob es sich in der Menhierarchie auf oberster oder drittklassiger Ebene befindet. Sie verwenden die AddMethode des MainMenu-Objekts, um der MenuItems-Auflistung neue Menelemente hinzuzufgen. Dieses MenuItem wird die oberste Ebene oder Kopfzeile fr ein Men bilden. In diesem Fall haben wir es Datei genannt, ein sehr gebruchliches Men in WindowsAnwendungen.
116
Mens hinzufgen
Das kaufmnnische Und-Zeichen (&, auch Ampersand genannt) im Mennamen bedeutet, dass das Zeichen, das unmittelbar darauf folgt, durch die Tastatur zugnglich ist. Dies wird als Zugriffstaste. In Zeile 14 folgt dem Ampersand der Buchstabe D. So kann der Benutzer das DATEI-Men mit der Tastenkombination (Alt)+(D) ffnen. Es darf nur eine solche Tastenkombination pro Menelement geben. Auch nach dem Erstellen eines Menelements knnen Sie dessen Titelzeile noch mit Hilfe der Text-Eigenschaft ndern. In Zeile 15 fgen Sie dem in Zeile 14 erzeugten MenuItem-Objekt ein weiteres hinzu. Weil dieses MenuItem zu einem anderen MenuItem-Objekt statt zum MainMenu-Objekt gehrt, wird es als Menelement im Men statt in der Hauptmenleiste erscheinen. Das neue MenuItem heit ffnen. Abbildung 4.3 zeigt das Ergebnis dieses Codes.
Abbildung 4.3: Listing 4.1 erzeugt ein DATEI-Men mit einem Menelement namens FFNEN.
Wenn Sie auf das Menelement klicken, passiert nichts; das liegt daran, dass wir noch einen Handler fr dieses Menelement erstellen mssen. Dafr ndern wir einfach die Zeile 15 wie folgt:
miFile.MenuItems.Add(new MenuItem("&ffnen...", new EventHandler(AddressOf Me.Open_Clicked)))
oder in C# wie folgt:

miFile.MenuItems.Add(new MenuItem("&ffnen...", new EventHandler(this.ffnen_Clicked)));
Erstellen Sie dann die ffnen_Clicked-Methode. Fgen Sie den folgenden Code irgendwo zwischen dem Schluss der New-Methode und dem Anfang der Main-Methode ein:
public sub ffnen_Clicked(Sender as Object, e as EventArgs) Microsoft.VisualBasic.MsgBox("ffnen-Men angeklickt!") end sub
117
Statt die vertraute AddHandler-Methode zu verwenden, legen Sie einfach nur die Methode fest, die nach der Menauswahl ausgefhrt werden soll ein weiterer Parameter bei der Erstellung des Menelements (wenn Sie wollen, knnten Sie auch AddHandler verwenden). Abbildung 4.4 zeigt das genderte Ergebnis.
Abbildung 4.4: Das Hinzufgen eines Handlers verleiht den Menelementen Funktionsfhigkeit.
Lassen Sie uns einen Blick auf ein weiteres Beispiel werfen, diesmal fr die Erstellung von Untermens. Listing 4.2 zeigt die Anwendung in C#-Code. Listing 4.2: Ein erweitertes Men in C#
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: using System; using System.Windows.Forms; namespace TYWinForms.Day4 { public class Listing42 : Form { private MainMenu mnuDatei = new MainMenu(); private Label lblMessage = new Label(); public Listing42() { this.Text = "Listing 4.2"; this.Menu = mnuDatei; MenuItem miDatei = mnuDatei.MenuItems.Add("&Fenster"); miDatei.MenuItems.Add(new MenuItem("&Forms")); miDatei.MenuItems[0].MenuItems.Add(new MenuItem("&Mens")); miDatei.MenuItems[0].MenuItems[0].MenuItems.Add(new MenuItem("&Sind")); miDatei.MenuItems[0].MenuItems[0].MenuItems.Add(new MenuItem("So")); miDatei.MenuItems[0].MenuItems[0].MenuItems[1].MenuItems.Add(new MenuItem("&Einfach wie"));
118
Mens hinzufgen
20: 21: 22: 23: 24: 25: 26: 27: 28: 29:
miDatei.MenuItems[0].MenuItems[0].MenuItems[1].MenuItems.Add(new MenuItem("Kuchenbacken")); } public static void Main(){ Application.Run(new Listing42()); } } }
Bis zur Zeile 14 ist Listing 4.2 mit Listing 4.1 identisch. Ab hier wird es interessant. Die Zeilen 14 und 15 fgen dem MainMenu genau wie zuvor weitere MenuItem-Objekte hinzu. An diesem Punkt haben Sie zwei Hierarchieebenen: die Kopfzeile des Mens (die wir 'Item A' nennen wollen) und ein einzelnes Menelement, Fenster (das wir 'Item B' nennen wollen). Denken Sie daran, dass die MenuItems-Eigenschaft eine Auflistung ist: Sie knnen auf jedes Element in der Auflistung mit Hilfe einer Indexzahl verweisen (0 ist stets das erste Mitglied in der Auflistung). In Zeile 16 greifen Sie auf das erste Element in der MenuItems-Auflistung von Item B zu, welches wiederum ein weiteres MenuItem darstellt. Dieses MenuItem wollen wir 'Item C' nennen. Diesem fgen Sie genau wie zuvor ein weiteres MenuItem hinzu. Weil Sie das MenuItem 'Item C' hinzugefgt haben, wird es zu einem weiteren Untermen. Jetzt verfgen wir ber drei Menebenen: Fenster, Formulare und Mens. Um auf ein Mitglied in einer Auflistung in VB .NET zuzugreifen, bentigen Sie die Item-Eigenschaft:
miDatei.MenuItems.Item(0).MenuItems.Add(new etc etc)
In Zeile 17 erweitern Sie dieses Konzept ein wenig. Sie greifen auf die MenuItems-Auflistung von Item C zu und fgen ein neues MenuItem ein, so dass Sie eine vierte Menebene erhalten. Zeile 18 tut das Gleiche, indem sie der vierten Ebene ein weiteres MenuItem hinzufgt. Die Zeilen 19 und 20 fhren diesen Vorgang fort, indem sie dem zweiten Element (wie durch den Index 1 angezeigt) weitere Untermens hinzufgen. Als Ergebnis unserer Bemhungen erhalten wir fnf Menebenen, wie in Abbildung 4.5 zu sehen ist. Der Vorgang des Verschachtelns von Mens mag zunchst ein wenig verwirrend erscheinen, aber denken Sie einfach daran, dass das erste MenuItem, das Sie einem anderen MenuItem hinzufgen, stets ein Untermen erzeugt.
119
Abbildung 4.5: Das Verschachteln von Mens erzeugt einen interessanten Quellcode.
Sie knnen auch Untermens dadurch hinzufgen, dass Sie fr jedes Element im Men explizit ein neues MenuItem erzeugen. Schauen Sie sich zum Beispiel folgendes Codefragment an:
MenuItem MenuItem MenuItem MenuItem miDatei = mnuDatei.MenuItems.Add("&Windows"); miForms = miDatei.MenuItems.Add("&Forms"); miMens = miFormulare.MenuItems.Add("&Mens"); miSind = miMens.MenuItems.Add("Sind");
Die erste Zeile erzeugt ganz normal das Element fr die Kopfzeile des Mens. Das nchste Menelement wird als neues MenuItem erzeugt und der MenuItems-Auflistung der vorhergehenden Ebene hinzugefgt, genau wie Sie das mit der Menkopfzeile gemacht haben. Beachten Sie, dass jede darauffolgende Zeile das neue MenuItem in die MenuItems-Auflistung der vorhergehenden Zeile hinzufgt. Beide Methoden zur Menerzeugung erledigen diese Aufgabe effizient. Die zweite Methode weist jedoch eine Reihe von Vorteilen auf: Sie erzeugt fr jedes Menelement einen neuen Namen, so dass wir es notfalls spter leicht wiederfinden knnen (statt seine Indexzahl zu benutzen); und der Code ist ebenfalls leichter zu lesen. Letztlich bleibt die Wahl Ihnen berlassen.
Mens anpassen
Mens sind in hchstem Ma anpassungsfhig. Sie knnen Mens zusammenfassen, visuelle Erweiterungen und Kurzbefehle hinzufgen und so weiter. Da diese Verschnerungen dem Endbenutzer eine bessere Bedienungserfahrung vermitteln, wollen wir einen Blick darauf werfen. Die einfachste Methode zur Anpassung Ihrer Mens besteht darin, hnliche Elemente zusammenzufassen. Das in Abbildung 4.2 gezeigte DATEI-Men des Internet Explorers zeigt, wie sich hnliche Menelemente gruppieren lassen; eine Trennlinie (Separator)
120
Mens hinzufgen
separiert eine Serie von Menelementen von der nchsten. Das Einfgen einer Trennlinie ist problemlos und eine gute Mglichkeit, den Benutzern beim Navigieren durch die Mens zu helfen. Sehen Sie sich bitte folgendes Stck Code an:
MenuItem miDatei = mnuDatei.MenuItems.Add("&Datei"); MenuItem miffnen = miDatei.MenuItems.Add("&ffnen"); MenuItem miSpeichern = miDatei.MenuItems.Add("&Speichern"); miFile.MenuItems.Add(""); MenuItem miBeenden = miDatei.MenuItems.Add("Beenden");
Die ersten drei Zeilen fgen einem vorhandenen MainMenu-Objekt einfache Menelemente hinzu. Um eine Trennlinie einzufgen, mssen Sie lediglich die Add-Methode aufrufen und ihr einen Gedankenstrich () bergeben. Die CLR versteht: Sie wollen die folgenden Menelemente zu einer anderen Gruppe zusammenfassen und abtrennen. Diese einfache Erweiterung fhrt zu dem folgenden Men in Abbildung 4.6.
Abbildung 4.6: Trennlinien helfen beim Organisieren Ihrer Mens.
Zustzlich zu den Zugriffstaten in den Menkopfzeilen knnen Sie auch Tastenkombinationen fr Ihre Menelemente einbauen. Microsoft Word verwendet beispielsweise (Strg) + (S) als Tastenkombination, um Dokumente zu speichern. Die meisten Anwendungen verwenden die Funktionstaste (F1) als Shortcut zu einem Element des HILFE-Mens. (Strg) + (O) fhrt den Menbefehl DATEI/FFNEN aus.
MenuItem miffnen = miDatei.MenuItems.Add("&ffnen", this.ffnen_Clicked, Shortcut.CtrlO);
Der dritte Parameter, den Sie hier sehen, ist die Eigenschaft Shortcut. Sie knnen die Shortcut-Aufzhlung verwenden, um die gewnschte Tastenkombination festzulegen. Diese Aufzhlung verfgt ber Werte fr die meisten Tastenkombinationen, wie etwa Ctrlx wobei x eine beliebige Zahl oder ein beliebiges Zeichen sein kann; in Fx steht x fr jede beliebige Zahl, und in CtrlShiftx ist x eine beliebige Zahl oder ein beliebiges Zeichen. In der .NET-Dokumentation erhalten Sie vollstndige Informationen dazu.
121
Wenn Sie whrend der Erstellung eines Menelements keine Tastenkombination festlegen wollen, knnen Sie das auch noch spter tun, indem Sie die Eigenschaft Shortcut des MenuItems nutzen:
miDatei.Shortcut = Shortcut.ShiftF9
Setzen Sie die ShowShortcut-Eigenschaft auf true, wenn Sie die damit verknpfte Tastenkombination im Men neben dem Menelement anzeigen lassen wollen:
MiDatei.Shortcut = ShowShortcut = true
Schlielich gibt es noch ein paar einfache boolesche Eigenschaften, die Sie fr jedes Menelement anpassen knnen:
Enabled legt fest, ob der Benutzer das Menelement auswhlen kann oder nicht (deaktivierte Elemente erscheinen grau). Visible zeigt an, ob der Benutzer das Element sehen kann (bedenken Sie, dass ein
Menelement selbst dann noch per Tastenkombination aktiviert werden kann, wenn es nicht sichtbar ist; sorgen Sie dafr, dass sowohl Enabled als auch Visible auf false gesetzt sind, wenn Sie verhindern wollen, dass Benutzer ein Menelement sehen oder auswhlen).
Checked zeigt an, ob sich neben dem Menelement ein Hkchen befindet. Das ist
ntzlich, wenn Sie beispielsweise kenntlich machen wollen, ob ein Menelement ausgewhlt worden ist.
DefaultItem zeigt an, ob das Menelement die voreingestellte Auswahl ist (Standardelemente erscheinen in fetter Schrift).
Um weitere Informationen ber MenuItem-Eigenschaften zu erhalten, schlagen Sie bitte in Anhang B nach.
Kontextmens
Wenn Sie bereits einmal auf ein Formular mit der rechten Maustaste (ein Rechtsklick) geklickt haben, wissen Sie, dass dann nichts passiert: kein Popup-Men ffnet sich, wie so oft in Windows-Anwendungen. Dieses Popup-Men nach dem Rechtsklick, welches hufig kontext-relevante Mens zur Auswahl bereitstellt (etwa Ausschneiden, Einfgen usw.), bezeichnet man als Kontextmen. Wenn Sie bereits einmal etwas lnger mit WindowsAnwendungen gearbeitet haben, wissen Sie, dass solch ein Men fr produktives Arbeiten einfach unerlsslich ist. Zum Glck lassen sich Kontextmens ebenso einfach einem Formular hinzufgen wie normale Mens. Alle Kontextmens werden durch das ContextMenu-Objekt dargestellt. Es ist dem MainMenuObjekt sehr hnlich. Menelemente im ContextMenu werden sogar als MenuItem-Objekte dargestellt. Folglich knnen Sie alles, was Sie bisher ber Mens gelernt haben, auch auf Kontextmens anwenden.
122
Mens hinzufgen
Am einfachsten lsst sich ein Kontextmen als Kopie des regulren Mens anfertigen, das Sie bereits erzeugt haben. Dies knnen Sie mit der CloneMenu-Methode bewerkstelligen. Der folgende Code erzeugt ein neues ContextMenu-Objekt und fgt die Kopie eines vorhandenen Mens hinzu:
ContextMenu mnuContext = new ContextMenu(); Form1.ContextMenu = mnuContext; MenuItem miContext = miDatei.CloneMenu(); mnuContext.MenuItems.Add(miContext);
Sobald Sie Ihrem Formular diesen Code hinzugefgt haben, wird ein Rechtsklick ein Popup-Men hervorbringen, das genau Ihrem DATEI-Men entspricht. Dieses Beispiel ist das allereinfachste Kontextmen. Der Grund jedoch, warum es Kontext-Men genannt wird, liegt darin, dass die Anwendung feststellen kann, in welchem Teil des Formulars sich der Mauszeiger beim Rechtsklicken befand, und kann so fr diese Stelle ein spezialisiertes Men bereitstellen. So kann etwa ein Rechtsklick auf eine leere Flche im Formular das DATEI-Men aufrufen, und ein Rechtsklick auf eine TextBox knnte ein spezielles Kontextmen mit den Befehlsoptionen AUSSCHNEIDEN und EINFGEN darin aufrufen. Um dieses Funktionsmerkmal bereitzustellen, verfgt jedes Windows Forms-Steuerelement (inklusive des Form-Objekts) ber die Eigenschaft ContextMenu, die das Men angibt, welches geffnet wird, wenn das Steuerelement rechts angeklickt wird. Dies macht es Ihnen recht leicht, Ihre Kontextmens anzupassen. Lassen Sie uns mit Listing 4.3 ein Beispiel dafr ansehen. Listing 4.3: Angepasste Kontextmens
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: using System; using System.Windows.Forms; using System.Drawing; namespace TYWinForms.Day4 { public class Listing43 : Form { private MainMenu mnuFile = new MainMenu(); private ContextMenu ctmTextBox = new ContextMenu(); private ContextMenu ctmLabel = new ContextMenu(); private Label lblMessage = new Label(); private TextBox tbMessage = new TextBox(); public Listing43() { this.Text = "Listing 4.3 "; this.Menu = mnuFile; AddMenus();
123
19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41: 42: 43: 44: 45: 46: 47: 48: 49: 50:
lblMessage.Text = "Ich liebe Windows Forms "; lblMessage.Location = new Point(100,75); lblMessage.Width = 150; tbMessage.Text = "Ich liebe Windows Forms "; tbMessage.Location = new Point(75,125); tbMessage.Width = 150; this.Controls.Add(lblMessage); this.Controls.Add(tbMessage); } public void AddMenus() { MenuItem miDatei = mnuDatei.MenuItems.Add("&Datei"); MenuItem miffnen = miDatei.MenuItems.Add("&ffnen"); MenuItemSpeichern = miDatei.MenuItems.Add("&Speichern"); miDatei.MenuItems.Add("-"); MenuItem miBeenden = miDatei.MenuItems.Add("Beenden"); MenuItem ctiLabel = ctmLabel.MenuItems.Add("Label-Men"); lblMessage.ContextMenu = ctmLabel; MenuItem ctiTextBox = ctmTextBox.MenuItems.Add("Textbox-Men"); tbMessage.ContextMenu =ctmTextBox; } public static void Main() { Application.Run(new Listing43()); } } }
In den Zeilen 1 bis 30 findet sich nichts Neues. Beachten Sie jedoch, dass die Zeilen 9 und 10 Instanzen von ContextMenu-Objekten erzeugen; wir werden sie gleich verwenden. Die Zeile 18 ruft die AddMenus-Methode auf, die in Zeile 32 beginnt. Die Zeilen 33 bis 37 erzeugen ein normales DATEI-Men fr Ihre Anwendung (Sie haben diesen Code bereits in Listing 4.2 gesehen). Zeile 39 erzeugt ein neues MenuItem fr das ContextMenu-Objekt ctmLabel. Seine Beschriftung lautet Label-Men. In Zeile 40 verbinden Sie dieses ContextMenu-Objekt (und somit sein untergeordnetes MenuItem-Objekt) mit dem Label-Steuerelement. Dieses Kontextmen lsst sich nun auf dieses Label anwenden (wenn Sie wollen, knnten Sie dieses Kontextmen auch anderen Steuerelementen zuweisen).
124
Symbolleisten, Statusleisten und Bildlaufleisten hinzufgen
Die Zeilen 42 und 43 erledigen das Gleiche fr das TextBox-Objekt, indem sie ein Menelement erzeugen, das die Beschriftung Textbox-Men trgt. Da Sie an keiner Stelle auch dem Form-Objekt ein ContextMenu zuweisen, wird ein Rechtsklick auf eine leere Formularflche kein Kontextmen ffnen. Dieses Listing erzeugt das in Abbildung 4.7 gezeigte Ergebnis.
Abbildung 4.7: Wenn Sie mit der rechten Maustaste auf das Bezeichnungsfeld (Label) klicken, wird das damit verbundene Kontextmen angezeigt.
In diesem Beispiel zeigt ein Rechtsklick auf das Textfeld das Kontextmen TextboxMen an. Wenn Sie einmal die Zeilen 42 und 43 aus dem Listing auskommentieren und es neu kompilieren, zeigt ein Rechtsklick auf das Textfeld ein ganz anderes damit verknpftes Kontextmen an: eines, das Befehlsoptionen fr Ausschneiden und Einfgen anzeigt. Der Grund dafr ist, dass TextBox (und ebenso RichTextBox) bereits voreingestellte Kontextmens besitzen. Indem Sie Ihr eigenes Kontextmen erzeugen, setzen Sie die vorhandenen Mens auer Kraft.
4.3
Symbolleisten, Statusleisten und Bildlaufleisten sind ebenso vertraute Bestandteile jeder Windows-Anwendung wie Mens. Eine Symbolleiste befindet sich gewhnlich am oberen Ende eines Anwendungsfensters, also direkt unter der Menleiste, und enthlt Schaltflchen mit Grafiken darauf, die die jeweilige Funktionalitt in der Anwendung signalisieren. Word etwa hat eine Schaltflche mit dem Bild eines geffneten Ordners, um das ffnen einer Datei zu bezeichnen, und ein Diskettensymbol fr die Speichern-Funktion. Eine Statusleiste befindet sich am unteren Rand des Anwendungsfensters und stellt dem Benutzer Verarbeitungsinformationen zur Verfgung. Ihre einzige interaktive Funktion besteht darin, Meldungen anzuzeigen. Bildlaufleisten schlielich erlauben dem Benutzer, durch ein Formular zu blttern, falls nicht alle Steuerelemente in die vorhandene Fensterflche passen. Abbildung 4.8 stellt alle drei Leistentypen dar.
125
Abbildung 4.8: In den meisten Anwendungen finden sich Symbolleisten, Statusleisten und Bildlaufleisten.
Trotz ihrer Namenshnlichkeit erweisen sich die drei Steuerelemente bei der Implementierung als recht unterschiedlich. Die Symbolleiste agiert als selbststndiges Steuerelement (obwohl es weitere Steuerelemente enthlt) und ist mit einem ImageList-Objekt verknpft. Die Statusleiste hingegen agiert hnlich einem Formular als Container fr andere Steuerelemente. Die Bildlaufleiste ist wieder eine andere Angelegenheit und verfgt nur ber wenige anpassbare Eigenschaften. Wir betrachten diese Steuerelemente der Reihe nach.
Symbolleisten
Eine Symbolleiste besteht aus einer Sammlung von Schaltflchen (normalerweise durch Grafiken dargestellt), die Kurzbefehle (Shortcuts) zu den Funktionen Ihrer Anwendung anbieten. Wahrscheinlich arbeiten Sie bereits seit lngerem mit Symbolleisten, so dass wir uns hier nicht bei konzeptionellen Details aufhalten. Die Symbolleiste und ihre Schaltflche werden durch die Objekte ToolBar und ToolBarButton dargestellt. Diese beiden Objekte hneln den Objekten MainMenu und MenuItem: Sie erstellen das zweite Objekt und fgen es dem ersten Objekt hinzu, die Schaltflchen also der Leiste. Lassen Sie uns einen Blick auf Listing 4.4 werfen, das Code zeigt, welcher eine einfache Symbolleiste erzeugt.
126
Listing 4.4: Eine einfache Symbolleiste hinzufgen

1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: using System; using System.Windows.Forms; namespace TYWinForms.Day4 { public class Listing44 : Form { private ToolBar tlbStandard = new ToolBar(); public Listing44() { ToolBarButton tbbOpen = new ToolBarButton(); tbbOpen.Text = "ffnen "; tlbStandard.Buttons.Add(tbbOpen); this.Controls.Add(tlbStandard); } public static void Main() { Application.Run(new Listing44()); } } }
In Zeile 7 erzeugen Sie ein neues ToolBar-Objekt auf die gleiche Weise wie ein MainMenu-Objekt. In Zeile 15 fgen Sie es Ihrem Formular wie jedes andere Steuerelement hinzu. In Zeile 10 erstellen Sie ein neues ToolBarButton-Steuerelement: Darauf wird der Benutzer spter klicken knnen. In Zeile 11 setzen Sie die Text-Eigenschaft so, dass das Wort ffnen angezeigt wird (Sie werden gleich merken, dass diese Text-Eigenschaft nicht ganz das ist, wofr Sie sie halten). Schlielich fgen Sie das ToolBarButton-Steuerelement Ihrem ToolBarObjekt hinzu. Ohne diesen Schritt wre Ihre Symbolleiste leer und wrde in sich zusammenfallen. Kompilieren Sie diese Anwendung und fhren Sie sie aus. Das Ergebnis sollte wie in Abbildung 4.9 aussehen. Wir haben zwar jetzt eine Symbolleistenschaltflche, aber einige Dinge scheinen zu fehlen oder nicht zu stimmen. Augenfllig ist, dass sich ihr Text nicht in der Mitte befindet. Zweitens ist mit der Schaltflche keine Grafik verknpft. Und schlielich passiert nach einem Klick auf die Schaltflche berhaupt nichts. Alle diese Mngel lassen sich leicht beheben.
127
Abbildung 4.9: Listing 4.4 erzeugt eine einfache Symbolleiste mit nur einer Schaltflche.
Die Text-Eigenschaft sieht nicht nach dem aus, was wir gewohnt sind. Die Text-Eigenschaft auf einem Button-Steuerelement zeigt eine Beschriftung im Zentrum der Schaltflche. Die Text-Eigenschaft fr den ToolBarButton hingegen wird verwendet, um die Grafik auf der Schaltflche zu ergnzen (denken Sie mal an die ZURCK-Schaltflche im Internet Explorer). Der Grund fr das Erscheinen des Textes auerhalb des Zentrums ist also, dass er Platz lsst fr die Grafik. Wenn wir der Schaltflche eine Grafik zuweisen wollen, mssen wir etwas ber ein neues Objekt namens ImageList lernen. Es wird meist von anderen Steuerelementen wie etwa dem ToolBar-Steuerelement dazu verwendet, Grafiken mit einer Auflistung (wie etwa ToolBarButtons) zu verknpfen. ImageList verfgt ber Methoden, um die Grafiken, die es enthlt, hinzuzufgen, zu entfernen und neu zu sortieren. Nachdem Sie einer ImageList Grafiken hinzugefgt haben, werden die Schaltflchen in einer Symbolleiste auf die Grafiken mit Hilfe ihrer jeweiligen ImageIndex-Eigenschaft verweisen. Etwa so:
MyToolBar.ImageList = myImageList; MyToolBarButton.ImageIndex = 1;
Wir wollen eine neue Methode namens AddToolBar verwenden, um die Erstellung unserer Symbolleiste zu bewerkstelligen. Ersetzen Sie die Zeilen 10 bis 13 in Listing 4.4 durch einen Aufruf der Methode
AddToolbar();
und fgen Sie dann Ihrer Anwendung den Code, der in Listing 4.5 gezeigt wird, zwischen dem Konstruktor und der Main-Methode hinzu. Listing 4.5: Grafiken mit Symbolleistenschaltflchen verknpfen
1: 2: 3: private ImageList ilstToolbar =new ImageList(); public void AddToolbar(){
128
4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24:
ilstToolbar.Images.Add(Image.FromFile("i_open.bmp ")); ilstToolbar.Images.Add(Image.FromFile("i_maximize.bmp ")); ilstToolbar.Images.Add(Image.FromFile("i_happy.bmp ")); ToolBarButton tbbOpen =new ToolBarButton(); tbbOpen.ImageIndex =0; tbbOpen.Text ="ffnen "; ToolBarButton tbbMaximize =new ToolBarButton(); tbbMaximize.ImageIndex =1; tbbMaximize.Text ="Maximieren "; ToolBarButton tbbHappy =new ToolBarButton(); tbbHappy.ImageIndex =2; tbbHappy.Text ="Werden Sie glcklich!"; tlbStandard.ImageList =ilstToolbar; tlbStandard.Buttons.Add(tbbOpen); tlbStandard.Buttons.Add(tbbMaximize); tlbStandard.Buttons.Add(tbbHappy); }
Zeile 1 erzeugt ein neues ImageList-Objekt. In den Zeilen 4 bis 6 fgen Sie diesem Objekt Grafiken hinzu, indem Sie die statische FromFile-Methode des Image-Objekts verwenden. (Beachten Sie, dass Sie die Namen der Dateien, die Sie oben sehen, zu solchen ndern sollten, die Sie tatschlich besitzen!) Diese Methode ldt die angegebene Datei und bergibt sie der Images-Auflistung von ImageList. Da Sie in Listing 4.5 das Image-Objekt verwenden, sollten Sie nicht vergessen, auch den Namensraum System.Drawing zu importieren! Sie knnten etwa folgenden Code am Anfang Ihrer Datei einfgen:
using System.Drawing;
Die Zeilen 8 bis 18 erzeugen drei neue ToolBarButton-Objekte, wobei die Eigenschaften fr Text und ImageIndex angegeben werden. Der ImageIndex zeigt auf den Index fr diejenige Grafik in der ImageList, die Sie mit der Schaltflche verknpfen wollen (der erste Index lautet stets 0). In Zeile 20 verknpfen Sie schlielich die in Zeile 1 erzeugte ImageList mit dem ToolBarObjekt. Dabei verwenden Sie die ImageList-Eigenschaft des Objekts. Die Zeilen 21 bis 23 fgen einfach die neu erstellten Schaltflchen der Symbolleiste hinzu. Abbildung 4.10 zeigt das Ergebnis dieser Datei.
129
Abbildung 4.10: Jetzt verfgt die Symbolleiste ber Schaltflchen mit Symbolen und Beschriftungen.
Die Anwendung sieht schon ein wenig besser gefllt aus. Aber es gibt noch einiges zu tun: Die Schaltflchen sollten auch eine Funktion erfllen. Erinnern Sie sich an meine Worte, wonach die ToolBar als ein einzelnes Steuerelement agiert? Gleich werden Sie den Grund dafr erkennen.
ToolBarButton-Objekte verfgen ber keine Ereignisse, die man behandeln kann (von dem Disposed-Ereignis einmal abgesehen, doch dies wird von einem anderen Objekt geerbt).
Von alleine wissen sie also nicht, dass sie angeklickt wurden. Wenn man also die Aktionen steuern mchte, sobald ein Benutzer auf eine Symbolleistenschaltflche geklickt hat, muss man sich dem ToolBar-Objekt zuwenden. Das ToolBar-Steuerelement verfgt ber ein ButtonClick-Ereignis, das ausgelst wird, sobald eine der in ihm enthaltenen ToolBarButtons angeklickt wird. Daher mssen alle Ereignisse und Aktionen ber die ToolBar erfolgen. Um Ihrer ToolBar einen Handler hinzuzufgen, verwenden Sie folgenden Code:
tlbStandard.ButtonClick += new ToolBarButtonClickEventhandler (this.MyToolBarHandler);
Das Listing 4.6 zeigt den MyToolBarHandler. Listing 4.6: Die Behandlung von Symbolleisten-Ereignissen in C#
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: private void MyToolBarHandler(Object Sender, ToolBarButtonClickEventArgs e){ switch(tlbStandard.Buttons.IndexOf(e.Button)){ case 0: //hier folgt etwas Code; break; case 1: // hier folgt etwas Code; break; case 2: // hier folgt etwas Code;
130
11: 12: 13:
break; } }
Das Parameterobjekt ToolBarButtonClickEventArgs verfgt ber eine Button-Eigenschaft, wie in Zeile 2 zu sehen ist. Sie gibt an, welche Schaltflche angeklickt wurde. Wir verwenden die IndexOf-Eigenschaft der Buttons-Auflistung, um fr jede Schaltflche eine numerische Darstellung zurckzugeben, die wir fr die Entscheidung darber verwenden knnen, welcher Code auszufhren ist. Das switch-Statement (in VB .NET wird statt dessen Select Case verwendet) wertet die ihm gelieferte Bedingung gegenber jedem einzelnen case-Element aus. Wenn die Werte bereinstimmen, wird der Code im betreffenden case-Zweig ausgefhrt. IndexOf legt fest, welches Element in der Buttons-Auflistung der ToolBar mit dem im Parameterobjekt angegebenen bereinstimmt und gibt dann den Index des entsprechenden Steuerelements in der Auflistung zurck. Break ist ntig, um der CLR mitzuteilen, nach der Ausfhrung des case-Statements keine weiteren mehr auszufhren oder auszuwerten. Listing 4.7 zeigt den gleichen Code in VB .NET geschrieben. Listing 4.7: Die Behandlung von Symbolleisten-Ereignissen in VB .NET
1: private Sub MyToolBarHandler(Sender as Object,e as ToolBarButtonClickEventArgs) 2: Select Case tlbStandard.Buttons.IndexOf(e.Button) 3: Case 0 4: 'etwas Code ausfhren 5: Case 1 6: 'etwas Code ausfhren 7: Case 2 8: 'etwas Code ausfhren 9: end Select 10: End Sub
Symbolleisten anpassen
ToolBar- und ToolBarButton-Steuerelemente verfgen ber einige Eigenschaften, die Ihnen erlauben, deren Aussehen anzupassen. Wir werfen kurz einen Blick darauf, angefangen bei den Eigenschaften des ToolBar-Steuerelements.
Die Eigenschaft Appearance gibt an, ob Ihre Symbolleistenschaltflchen als normale dreidimensionale Objekte (erhabene Schaltflchen) oder flach (Browser-Stil) erscheinen sollen. Den Unterschied versteht man am besten, indem man sich beide Stile ansieht sie sind beide in Abbildung 4.11 zu sehen.
131
Abbildung 4.11: Normale Symbolleistenschaltflchen sehen dreidimensional aus; flache Schaltflchen hingegen sind eben das: flach. Appearance lsst sich auf zwei Werte setzen: Normal (3D) oder Flat. Beide Werte gehren zur Aufzhlung ToolBarAppearance. Das folgende Codefragment lsst die Schaltflche flach aussehen: tlb.Standard.Appearance = ToolBarAppearance.Flat;
Funktional gesehen besteht kein Unterschied zwischen den beiden Stilen; es ist lediglich eine Angelegenheit der visuellen Vorliebe. Die AutoSize-Eigenschaft des ToolBar-Steuerelements gibt an, ob sich die ToolBar je nach der Gre der ToolBarButtons, die sie enthlt, vergrern und verkleinern soll. Dementsprechend gibt es auch eine ButtonSize-Eigenschaft, die die Gre der Schaltflchen in der ToolBar vorgibt. Die Standardgre fr eine Schaltflche betrgt 24 (Breite) x 22 (Hhe) Pixel. Doch wenn ButtonSize nicht anderweitig angegeben ist, passen sich die Schaltflchen der grten Grafik und dem mit ihnen verknpften Text an. Um die Begrenzung Ihrer Symbolleiste zu steuern, stehen Ihnen die Eigenschaften Divider und BorderStyle zur Verfgung. Divider gibt an, ob eine Trennlinie zwischen der Symbolleiste und anderen Steuerelementen, wie etwa einem Men, eingezogen werden soll. BorderStyle kann BorderStyle.FixedSingle, BorderStyle.Fixed3D oder BorderStyle.None sein. Diese Eigenschaft funktioniert hier genauso wie fr das Form-Objekt. Das Steuerelement ToolBarButton verfgt nur ber eine Haupteigenschaft, nmlich Style, und ber verschiedene weitere, die diese Eigenschaft untersttzen. Style gibt an, welche Art von Schaltflche dem Benutzer gezeigt wird. Sie kann einen der Werte in der Aufzhlung ToolBarButtonStyle annehmen:
132
DropDownButton: Zeigt auf Mausklick ein Dropdown-Men an. Verwenden Sie die Eigenschaft DropDownMenu, um ein anzuzeigendes MenuItem zuzuweisen. Verwenden Sie die DropDownArrows-Eigenschaft des ToolBar-Objekts, um anzugeben, ob ein Pfeil anzeigt wird, der auf Anklicken hin ein Men anzeigt. PushButton: Die standardmige 3D-Schaltflche, wie sie vom jeweiligen Betriebssystem definiert wird. (Die Schaltflche kann in manchen Windows-Versionen flach statt dreidimensional erscheinen.) Separator: Eine Trennlinie zwischen zwei Schaltflchen. ToggleButton: Eine Schaltflche, die, sobald sie angeklickt wurde, wie eingedrckt aussieht und so bleibt. Verwenden Sie die Pushed-Eigenschaft, um anzugeben, ob die Schaltflche gerade gedrckt ist. PartialPush hnelt Pushed, nur dass die Schaltflche
nicht gedrckt, sondern vielmehr grau eingefrbt ist. Abbildung 4.12 zeigt Beispiele fr all diese Stile.
Abbildung 4.12: Hier sind die Schaltflchenstile DropDown, PushButton und ToggleButton umgesetzt.
Statusleisten
In einer Windows Forms-Anwendung wird eine Statusleiste durch das StatusBar-Objekt und eine beliebige Anzahl von StatusBarPanels (Statusleistenbereiche) dargestellt. Die StatusBar sieht fast wie ein Label-Steuerelement aus: Sie verfgt ber keine Umrisslinien oder Trennlinien. Daher verwendet sie StatusBarPanels, um Informationen abzutrennen und anzuzeigen. Es gibt keine Regel, die besagt, man habe einer StatusBar irgendwelche StatusBarPanels hinzuzufgen schlielich besitzt die StatusBar eine Text-Eigenschaft, die dem Benutzer Text anzeigen wird das Standarderscheinungsbild einer Statusleiste sieht allerdings solche Bereiche vor. Die Steuerelemente StatusBar und StatusBarPanel sind den Men- und SymbolleistenSteuerelementen sehr hnlich, die Sie heute kennen gelernt haben. Daher drften Sie sie leicht verstehen knnen. Wir wollen wieder in etwas Code eintauchen: Listing 4.8 (fr dieses Beispiel verwenden wir VB .NET) zeigt, wie eine Statusleiste hinzugefgt wird.
133
Listing 4.8: Ihrer Anwendung eine in VB .NET geschriebene Statusleiste hinzufgen

1: Imports System 2: Imports System.Windows.Forms 3: 4: Namespace TYWinForms.Day4 5: 6: public class Listing48 : Inherits Form 7: private sbrMain as new StatusBar 8: private lblMessage as new Label 9: 10: public sub New() 11: Me.Text = "Listing 4.8 " 12: 13: AddStatusBar 14: 15: lblMessage.Text = "Ich liebe WinForms" 16: lblMessage.Width = 200 17: lblMessage.Height = 200 18: lblMessage.Font = new System.Drawing.Font(new System.Drawing.FontFamily("Arial "), 15) 19: 20: Me.Controls.Add(lblMessage) 21: Me.Controls.Add(sbrMain) 22: 23: End Sub 24: 25: public sub AddStatusBar() 26: dim sbpName as StatusBarPanel = sbrMain.Panels.Add("Hallo, Dave!") 27: sbpName.Width = 100 28: sbpName.BorderStyle = StatusBarPanelBorderStyle.Raised 29: 30: dim sbpTime as StatusBarPanel = sbrMain.Panels.Add(" ") 31: sbpTime.Text = Datetime.Now.ToString 32: sbpTime.AutoSize = StatusBarPanelAutoSize.Spring 33: sbpTime.Alignment = HorizontalAlignment.Right 34: 35: sbrMain.ShowPanels = true 36: end sub 37: 38: public Shared Sub Main() 39: Application.Run(new Listing48) 40: end sub 41: end class 42: 43: End Namespace
134
Das Listing demonstriert eine Reihe von Eigenschaften der Steuerelemente StatusBar und StatusBarPanel. In Zeile 7 erzeugen Sie das erste Objekt: die StatusBar. Um den Code irgendwie logisch zu sortieren, haben wir den Initialisierungscode fr die Statusleiste in einer Methode namens AddStatusBar untergebracht, die in Zeile 13 aufgerufen wird. Zeile 21 fgt die Statusleiste dem Formular hinzu. Die erste Zeile der AddStatusBar-Methode (Zeile 26) erzeugt ein neues StatusBarPanelObjekt und fgt es der Panels-Auflistung der StatusBar hinzu. Zeile 27 legt die Breite des Bereichs fest und Zeile 28 setzt den BorderStyle auf Raised (einen Wert in der Aufzhlung StatusBarPanelBorderStyle; die anderen Werte, die Sie verwenden knnen, sind None oder Sunken, welches der Standardstil ist). In Zeile 30 wird ein weiterer StatusBarPanel-Bereich erzeugt. Die Text-Eigenschaft ist zunchst auf eine leere Zeichenfolge eingestellt. In Zeile 21 setzen Sie sie mit Hilfe der DateTime.Now-Funktion auf die aktuelle Uhrzeit (verwenden Sie ToString, um die Zeit als Zeichenfolge zurckzugeben der Standardrckgabetyp ist ein DateTime-Objekt). Zeile 32 setzt die AutoSize-Eigenschaft, welche angibt, wie sich der Bereich vergrern bzw. verkleinern lsst, je nach seinem Inhalt und/oder der Gre des Formulars. Spring wirkt wie eine Feder, so dass der Bereich den gesamten verfgbaren Raum einnimmt, der noch nicht von anderen Bereichen belegt ist. AutoSize kann auch auf None oder Contents gesetzt sein, wodurch die Gre des Bereichs an seinen Inhalt angepasst wird. In Zeile 33 wird die Alignment-Eigenschaft verwendet, um den Inhalt des Bereichs rechtsbndig auszurichten. Dieser Wert kann Left, Center oder Right sein die Werte stammen aus der Aufzhlung HorizontalAlignment. Zum Schluss setzen Sie in Zeile 35 die ShowPanels-Eigenschaft der StatusBar auf true, damit die von Ihnen erzeugten Bereiche dem Benutzer angezeigt werden. Abbildung 4.13 zeigt, wie diese Anwendung nun aussieht. Sie knnen Ihrer Statusleiste so viele Bereiche hinzufgen, wie Sie wnschen. Nehmen Sie aber nicht zu viele, sonst kann sie der Benutzer nicht alle sehen. Das Steuerelement StatusBarPanel hat eine weitere wichtige Eigenschaft hinsichtlich seiner Anpassung: Icon. Die Eigenschaft lsst sich dazu nutzen, eine Grafik statt blo Text in der Statusleiste anzuzeigen (wie zum Beispiel die Statusleiste von Word mit einem Symbol den Status Ihres Dokuments anzeigt). Diese Grafikdatei muss eine .ico-Datei sein. Durch das Hinzufgen des folgenden Codes zur AddStatusBar-Methode in Listing 4.8 erhlt man einen neuen Bereich:
dim sbpIcon as StausBarPanel = sbrMain.Panels.Add("") sbpIcon.AutoSize = StatusBarPanelAutoSize.Contents sbpIcon.Icon = new Icon("VSProjectApplication.ico")
135
Abbildung 4.13: Ihre erste Statusleiste enthlt eine Meldung sowie die Uhrzeit und das Datum.
Event-driven Start application
Enter message loop
Do processing
User input
If user input is stop then
Stop
Abbildung 4.14: Die Nachrichtenschleife wartet auf eine Benutzereingabe.
Bildlaufleisten
Bildlaufleisten erlauben es Ihnen (und Ihren Benutzern), sich im Formular zu bewegen, wenn die darin enthaltenen Steuerelemente zu gro sind, um in das aktuelle Fenster zu passen. Es gibt zwei Arten von Bildlaufleisten: horizontale (verschieben das Formular zwischen linkem und rechtem Rand), dargestellt durch das HScrollBar-Steuerelement, und vertikale (bewegen das Formular auf und ab, dargestellt durch VScrollBar. Bildlaufleisten lassen sich Ihrem Formular sehr leicht hinzufgen, aber es ist ein wenig schwieriger, sie zum Funktionieren zu bringen. Um zu erfahren, wie Sie Bildlaufleisten verwenden, sehen Sie sich bitte den Code in Listing 4.9 an (eine modifizierte Version von Listing 3.4).
136
Listing 4.9: Bildlaufleisten implementieren

1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41: 42: 43: 44: using System; using System.Windows.Forms; using System.Drawing; namespace TYWinForms.Day4 { public class Listing49 : Form { Button btAccept = new Button(); Button btCancel = new Button(); Label lblMessage = new Label(); VScrollBar vbarForm = new VScrollBar(); HScrollBar hbarForm = new HScrollBar(); public Listing49() { lblMessage.Location = new Point(75,150); lblMessage.Width = 200; btAccept.Location = new Point(100,25); btAccept.Text = "OK "; btAccept.Click += new EventHandler(this.AcceptIt); btCancel.Location = new Point(100,100); btCancel.Text = "Abbrechen"; btCancel.Click += new EventHandler(this.CancelIt); vbarForm.Dock = DockStyle.Right; vbarForm.Visible = false; hbarForm.Dock = DockStyle.Bottom; hbarForm.Visible = false; this.Resize += new EventHandler(this.Resized); this.AcceptButton = btAccept; this.CancelButton = btCancel; this.Text = "Beispiel fr OK- und Abbrechen-Schaltflchen"; this.Height = 200; this.Controls.Add(lblMessage); this.Controls.Add(btAccept); this.Controls.Add(btCancel); this.Controls.Add(vbarForm); this.Controls.Add(hbarForm); } public void Resized(Object Sender, EventArgs e) { if (this.Height < lblMessage.Top + lblMessage.Height) {
137
45: 46: 47: 48: 49: 50: 51: 52: 53: 54: 55: 56: 57: 58: 59: 60: 61: 62: 63: 64: 65: 66: 67: 68: 69: 70: 71: 72:
vbarForm.Visible = true; }else { vbarForm.Visible = false; } if (this.Width < btAccept.Left + btAccept.Width) { hbarForm.Visible = true; }else { hbarForm.Visible = false; } this.Refresh(); } public void AcceptIt(Object Sender, EventArgs e) { lblMessage.Text = "Der OK-Button wurde gedrckt"; } public void CancelIt(Object Sender, EventArgs e) { lblMessage.Text = "Der Abbrechen-Button wurde gedrckt"; } } public class StartForm { public static void Main() { Application.Run(new Listing49()); } } }
Hier gibt es zwar eine Menge Code zu lesen, doch das meiste davon haben wir bereits gestern besprochen. Die Zeilen 15 bis 24 erzeugen und zeigen ein Labelund zwei Schaltflchen-Steuerelemente an. Die Zeilen 32 bis 38 fgen diese Steuerelemente dem Formular hinzu, und die Zeilen 58 bis 65 behandeln die Ereignisse der Schaltflchen. (Mehr Details finden sich nach Listing 3.4.) Die Zeilen 11 und 12 enthalten den ersten neuen Code; sie erzeugen neue VScrollBarund HScrollBar-Steuerelemente. Die Zeilen 26 bis 29 legen die Dock- und Visible-Eigenschaften fest. Da wir wissen, dass das Formular gro genug sein wird, um seine Inhalte komplett anzuzeigen, wollen wir die Bildlaufleisten zunchst einmal unsichtbar lassen. Um die Dock-Eigenschaft kmmern wir uns an Tag 6. Halten wir erst einmal fest, dass unsere Bildlaufleisten am rechten und am unteren Rand unseres Formulars angedockt sind.
138
In Zeile 31 behandeln Sie ein neues Ereignis des Form-Objekts: Resize. Dieses Ereignis wird natrlich ausgelst, sobald die Gre des Formulars gendert wird. Zeile 31 besagt: Sobald dies passiert, fhre die Methode Resized aus, wie in den Zeilen 43 bis 56 zu sehen. Diese Methode muss zwei Dinge tun: Erstens muss sie bei einer Grennderung die Gre des Formulars bewerten (waagrecht wie senkrecht) und bestimmen, ob das Formular gro genug zur Darstellung seiner Inhalte ist. Ist das nicht der Fall, zeigt sie die Bildlaufleisten an. Zweitens muss sie die Refresh-Methode aufrufen, um das Formular neu zu zeichnen, so dass die gerade modifizierten Bildlaufleisten gezeichnet oder gelscht werden knnen. Die Mindesthhe des Formulars vor der Anzeige von vertikalen Bildlaufleisten liegt beim unteren Rand des untersten Steuerelements in unserem Fall ist dies lblMessage. Die Summe der Top- und Height-Eigenschaften des Bezeichnungsfeldes ergibt die richtige Hhe. Das if-Statement in Zeile 44 fhrt den Vergleich zwischen der Hhe des Formulars und der Mindesthhe aus. Ist die Formularhhe niedriger, zeigt man die vertikale Bildlaufleiste an (Zeile 45). Umgekehrt gilt: Ist die Formularhhe grer als die Mindesthhe, verbergen Sie die Bildlaufleiste, wie in Zeile 47 zu sehen. Die Zeilen 50 bis 54 machen das Gleiche fr die waagrechte Ausrichtung. In diesem Fall entspricht die Mindestbreite der Left-Eigenschaft des am weitesten rechts liegenden Steuerelements plus dessen Breite (Width). In Zeile 55 rufen Sie schlielich die Refresh-Methode auf. Kompilieren Sie diese Anwendung und versuchen Sie das Formular auf eine Gre zu reduzieren, die geringer ist als die minimalen Begrenzungen. Abbildung 4.14 zeigt ein typisches Beispiel.
Abbildung 4.15: Die richtigen Bildlaufleisten tauchen auf, sobald die Formulargre gendert wird.
Beachten Sie jedoch, dass auf einen Klick auf die Bildlaufleisten hin nichts passiert! Ihr Formular lsst sich nicht wie vorgesehen bewegen. Es gibt zwei Mglichkeiten, diesen Mangel zu beheben. Die erste und einfachere Mglichkeit besteht im Setzen der AutoScoll-Eigenschaft des Formulars auf true:
this.AutoScroll = true;
Ihr Formular lsst sich nun wie erwartet bewegen. Die zweite Mglichkeit besteht in einer manuellen Vorgehensweise, wobei man die Ereignisse der Bildlaufleisten behandelt. Normalerweise nutzt man diese Mglichkeit nur dann, wenn man vorher nicht wei, wie gro ein Formular werden kann (etwa wenn ein Benutzer die Gre dynamisch steigern kann).
139
Lassen Sie uns untersuchen, wofr der Bildlauf auszufhren ist, wenn die Bildlaufleisten angeklickt werden. Zunchst wrde man vermuten, es sei das Form-Objekt, doch das trfe nicht zu. Denken Sie daran, dass die Position des Formulars auf den Desktop bezogen ist; wenn Sie also einen Bildlauf bezglich des Formular-Objekts versuchen, bewegt es sich nur auf dem Desktop, doch seine Inhalte wrden an ihrem relativen Ort (im Formular) verbleiben. Entgegen unseren Erwartungen wrden sich die Steuerelemente nicht bewegen. Wir wollen aber die Steuerelemente innerhalb des Formulars bewegen, nicht aber das Formular selbst. Wenn also der Benutzer den Abwrtspfeil auf der senkrechten Bildlaufleiste anklickt, mssen sich alle Steuerelemente nach oben bewegen. Das Entsprechende gilt, wenn der Benutzer in der waagrechten Bildlaufleiste nach rechts klickt: Alle Steuerelemente mssen sich nach links bewegen. Wenn man, wie wir in unserem Beispiel, nur drei Steuerelemente im Formular hat, hlt sich der Aufwand in Grenzen. Was ist aber, wenn man mehr hat? Die Neupositionierung jedes einzelnen Steuerelements wird zur Schwerstarbeit. Unser Kniff besteht in der Verwendung eines weiteren Containersteuerelements: ein Panel-Steuerelement, das alle Steuerelemente enthlt, die bewegt werden mssen. Dann knnen Sie das PanelSteuerelement bewegen, und alle seine untergeordneten Steuerelemente werden sich entsprechend mitbewegen! Stellen Sie sich das Panel-Steuerelement als eine Art Mini-Form vor oder als Formular innerhalb eines Form-Objekts. Indem Sie die Steuerelemente in einem Panel-Steuerelement gruppieren, knnen Sie sie als eine Gruppe manipulieren das ist genau das, was Sie ja beim Bildlauf erreichen wollen. Das Erzeugen des Panel-Steuerelements ist einfach; fgen Sie den folgenden Code an einer beliebigen Stelle zwischen den Zeilen 8 und 13 in Listing 4.9 ein:
Panel pnlForm =new Panel();
Sie wollen sicher dafr sorgen, dass das Panel-Steuerelement die gleiche Gre besitzt wie das Formular, so dass alle Steuerelemente normal angezeigt werden. Fgen Sie dem Konstruktor folgenden Code hinzu:
pnlForm.Height =this.Height; pnlForm.Width =this.Width;
Als Nchstes ersetzen Sie die Zeilen 36 bis 38 durch folgenden Code:
pnlForm.Controls.Add(lblMessage); pnlForm.Controls.Add(btAccept); pnlForm.Controls.Add(btCancel);
Jetzt sind das Label- und die beiden Button-Steuerelemente nicht mehr mit dem FormObjekt verknpft, sondern stattdessen mit dem Panel-Steuerelement. Als Nchstes fgen Sie das Panel-Steuerelement dem Konstruktor des Form-Objekts hinzu:
this.Controls.Add(pnlForm);
140
Um die Bildlaufereignisse zu behandeln, mssen Sie im Konstruktor Ereignishandler zum Scroll-Ereignis der Bildlaufleisten hinzufgen, etwa so:
vbarForm.Scroll +=new ScrollEventHandler(this.HandleVScroll); hbarForm.Scroll +=new ScrollEventHandler(this.HandleHScroll);
Beachten Sie die Verwendung des Objekts ScrollEventHandler. Dies bedeutet, dass Sie ein Parameterobjekt ScrollEventArgs fr Ihre Methoden verwenden. Zum Schluss mssen Sie noch die Methoden HandleVScroll und HandleHScroll erstellen, wie in Listing 4.10 gezeigt: Listing 4.10: Methoden zur Behandlung des Bildlaufs
1: 2: 3: 4: 5: 6: 7: public void HandleVScroll(Object Sender,ScrollEventArgs e){ pnlForm.Top =0 -e.NewValue; } public void HandleHScroll(Object Sender,ScrollEventArgs e){ pnlForm.Left =0 -e.NewValue; }
Diese zwei Methoden verrichten einfache Aufgaben: Sie bewegen das Panel-Steuerelement auf- oder abwrts und nach links oder rechts, wobei die entsprechenden Top- und Left-Eigenschaften des Panel-Steuerelements verwendet werden. Die Schwierigkeit besteht nun darin, wie man herausfindet, wie weit das Panel-Steuerelement in die jeweilige Richtung bewegt werden soll. Das Panel-Steuerelement sollte stets in Bezug zu seiner Startposition bewegt werden. Wenn die Bildlaufleiste beispielsweise um x Raumeinheiten abwrts bewegt wird, sollte sich das Panel-Steuerelement von seiner ursprnglichen Position aus um x Raumeinheiten aufwrts bewegen. In diesem Fall entspricht die Anfangsposition des Panel-Steuerelements den X-Y-Koordinaten (0,0), was der Grund dafr ist, warum Sie diese Nullen in den Zeilen 2 und 6 sehen. Von dieser Anfangsposition ziehen Sie den Betrag ab, um den sich die Bildlaufleiste bewegt hat. Durch das Subtrahieren stellen Sie sicher, dass sich das Panel-Steuerelement in die entgegengesetzte Richtung des Bildlaufs bewegt (der Benutzer klickt abwrts, also bewegen sich die Steuerelemente aufwrts). Tabelle 4.1 zeigt ein paar beispielhafte Situationen.
Aktion 1. Der Benutzer klickt den AufwrtsPfeil um zehn Einheiten (Wert der Bildlaufleiste = 10) Ergebnisse Das Panel-Steuerelement bewegt sich 10 Einheiten abwrts. Der neue Panel.Top-Wert lautet 10, Panel.Left = 0.
Tabelle 4.1: Beispiele fr Bewegungen beim Bildlauf
141
Aktion 2. Der Benutzer verschiebt die Bildlaufleiste bis ganz nach unten (Wert der Bildlaufleiste = Form.Height)
Ergebnisse Das Panel-Steuerelement bewegt sich ganz nach oben. Neuer Panel.Top-Wert = 0 Form.Height.Left = 0. (Beachten Sie, dass sich Bewegungen nicht akkumulieren, da die Bewegung nur relativ zur Ausgangsposition gemessen wird. Das heit, der Top-Wert in diesem Schritt ist nicht 10 Form.Height.)
3. Der Benutzer verschiebt die BildDas Panel-Steuerelement bewegt sich um 20 Einheiten laufleiste um 20 Einheiten nach links. nach rechts. Top = 0 Form.Height.Left-Wert = 20. Tabelle 4.1: Beispiele fr Bewegungen beim Bildlauf (Forts.)
Und welche Einheiten benutzen nun die Bildlaufleisten? Per Voreinstellung ist die Minimum-Eigenschaft auf 0 gesetzt (dies entspricht der Ausgangsposition der Bildlaufleiste; fr die senkrechte Bildlaufleiste also ganz oben, fr die waagrechte ganz links). Die Vorgabe fr Maximum lautet 100, was bedeutet, dass sich die Bildlaufleisten um 100 Einheiten bewegen knnen, nicht mehr. Sie knnen sowohl Minimum als auch Maximum ndern, aber der Effekt ist gleich null: Minimum entspricht immer waagrecht ganz links oder senkrecht ganz oben, und Maximum entspricht dem jeweils entgegengesetzten Ende. Die NewValue-Eigenschaft des ScrollEventArgs-Parameters bestimmt die neue Position der Bildlaufleiste (die der Benutzer durch Verschieben herbeigefhrt hat). Gem den Zeilen 2 und 6 des Listings 4.10 sind 100 Einheiten auf- und abwrts, nach links oder rechts der maximale Bewegungsradius des Panel-Steuerelements. Hat ein Formular kompliziertere Anforderungen an seine Gre, mssen Sie vielleicht den Betrag erhhen, um den sich ein Panel-Steuerelement bewegen kann. Sollte Ihr Formular also 1000 Pixel hoch sein, dann sind fr Ihre vertikale Bildlaufleiste 100 Einheiten nicht ausreichend. Somit sollte jede Einser-Einheit der Bildlaufleiste sich um mehr als nur eine Einheit der Hhe des Panel-Steuerelements bewegen. Der folgende Code knnte die notwendige Normalisierung erzielen:
int normalizedHeight = pnlForm.Height / vbarForm.Maximum; pnlForm.Top = 0 (e.NewValue * normalizedHeight);
Wenn Sie die Zeilen 2 und 6 des Listings 4.10 entfernen, erhalten Sie das zuvor besprochene Beispiel, bei dem sich das Formular ber den Desktop bewegt.
Formulare sind nicht die einzigen Objekte, die ber Bildlaufleisten verfgen knnen; Sie knnen beinahe jedem gewnschten Steuerelement Bildlaufleisten hinzufgen, so etwa einer PictureBox oder sogar Schaltflchen. Dies stellt Ihnen vielfltige Entwurfsmglichkeiten hinsichtlich der Interaktion Ihrer Anwendung mit dem Benutzer zur Verfgung.
142
Wir wollen noch weitere Eigenschaften betrachten, die Sie im Zusammenhang mit Bildlaufleisten nutzen knnen. Die Eigenschaften LargeChange und SmallChange lassen sich dazu verwenden, die Anzahl Einheiten, um die sich die Bildlaufleiste nach dem Anklicken bewegt, anzupassen. SmallChange wird meist verwendet, wenn der Benutzer auf einen der Pfeile am Ende der Bildlaufleiste klickt oder eine der ()- bzw. ()-Pfeiltasten drckt. LargeChange wird benutzt, wenn die Bildlaufleiste selbst angeklickt wird oder die (Bild)und (Bild)-Pfeiltasten gedrckt werden. Die Type-Eigenschaft des Parameterobjekts ScrollEventArgs teilt Ihnen mit, was tatschlich whrend des Bildlaufereignisses passiert ist, also etwa eine groe oder kleine Bewegung oder wohin sich die Bildlaufleiste bewegt hat. Tabelle 4.2 fhrt diese Werte auf, von denen alle zur Aufzhlung ScrollEventType gehren.
Wert
EndScroll
Beschreibung Das Bildlauffeld (Scroll-Box; das Kstchen, das die Position der Bildlaufleiste anzeigt) hat aufgehrt sich zu bewegen. Das Bildlauffeld hat sich zum Minimum-Wert bewegt. Das Bildlauffeld hat sich um den LargeChange-Wert nach oben oder nach links bewegt (die Inhalte verschieben sich dann nach unten oder nach rechts). Das Bildlauffeld hat sich um den LargeChange-Wert nach unten oder nach rechts bewegt (die Inhalte verschieben sich dann nach oben oder nach links). Das Bildlauffeld hat sich zu dem durch Maximum angegebenen Wert bewegt. Das Bildlauffeld hat sich um den SmallChange-Wert nach oben oder nach links bewegt (die Inhalte verschieben sich dann nach unten oder nach rechts). Das Bildlauffeld hat sich um den SmallChange-Wert nach unten oder nach rechts bewegt (die Inhalte verschieben sich dann nach oben oder nach links). Das Bildlauffeld selbst wurde bewegt. Das Bildlauffeld bewegt sich noch.
First LargeDecrement
LargeIncrement
Last SmallDecrement
SmallIncrement
ThumbPosition ThumbTrack
Tabelle 4.2: Werte fr ScrollEventType
Listing 4.11 zeigt ein kurzes Beispiel (zumindest im Hinblick auf die Komplexitt) fr die Verwendung dieser Werte.
143
Listing 4.11: So stellt man den Typ des aufgetretenen Bildlaufs fest.
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41: 42: using System; using System.Windows.Forms; using System.Drawing; namespace TYWinForms.Day4 { public class Listing410 : Form { Label lblMessage = new Label(); VScrollBar vbarForm = new VScrollBar(); HScrollBar hbarForm = new HScrollBar(); public Listing410(){ lblMessage.Location = new Point(75,75); lblMessage.Width = 200; vbarForm.Dock = DockStyle.Right; vbarForm.Visible = true; vbarForm.Scroll += new ScrollEventHandler (this.HandleScroll); hbarForm.Dock = DockStyle.Bottom; hbarForm.Visible = true; hbarForm.Scroll += new ScrollEventHandler (this.HandleScroll); this.Text = "Beispiel fr ScrollEventType-Wert"; this.Height = 200; this.Controls.Add(lblMessage); this.Controls.Add(vbarForm); this.Controls.Add(hbarForm); } public void HandleScroll(Object Sender, ScrollEventArgs e){ switch(e.Type){ case ScrollEventType.EndScroll: lblMessage.Text = "Die Scroll-Box bewegt sich nicht mehr"; break; case ScrollEventType.First: lblMessage.Text = "Die Scroll-Box befindet sich bei " + ((ScrollBar)Sender).Minimum.ToString(); break; case ScrollEventType.LargeDecrement: lblMessage.Text = "Die Scroll-Box hat sich bewegt " + ((ScrollBar)Sender).LargeChange.ToString(); break; case ScrollEventType.LargeIncrement: lblMessage.Text = "Die Scroll-Box hat sich bewegt" + ((ScrollBar)Sender).LargeChange.ToString();
144
43: 44: 45: 46: 47: 48: 49: 50: 51: 52: 53: 54: 55: 56: 57: 58: 59: 60: 61: 62: 63: 64: 65: 66: 67: 68:
break; case ScrollEventType.Last: lblMessage.Text = "Die Scroll-Box befindet sich bei " + ((ScrollBar)Sender).Maximum.ToString(); break; case ScrollEventType.SmallDecrement: lblMessage.Text = "Die Scroll-Box hat sich bewegt " + ((ScrollBar)Sender).SmallChange.ToString(); break; case ScrollEventType.SmallIncrement: lblMessage.Text = "Die Scroll-Box hat sich bewegt " + ((ScrollBar)Sender).SmallChange.ToString(); break; case ScrollEventType.ThumbPosition: lblMessage.Text = "Die Scroll-Box hat sich bewegt "; break; case ScrollEventType.ThumbTrack: lblMessage.Text = "Die Scroll-Box bewegt sich"; break; } } } public class StartForm { public static void Main(){ Application.Run(new Listing410()); } } }
Der Konstruktor drfte recht vertraut aussehen; er erzeugt einfach die Bildlaufleisten und ein Bezeichnungsfeld, danach fgt er die Steuerelemente dem Formular hinzu. Der Scroll-Ereignishandler namens HandleScroll sieht dagegen schon wesentlich interessanter aus. Diese in Zeile 30 beginnende Methode wertet die Type-Eigenschaft des Parameters ScrollEventArgs aus. Mit Hilfe eines switch-Statements vergleicht sie den Type-Wert mit jedem der ScrollEventType-Werte, die in Tabelle 4.2 aufgefhrt sind. Fr jeden Einzelfall gibt sie eine entsprechende Zeichenfolge an das Label-Steuerelement aus. Zu diesem Listing sind ein paar Bemerkungen angebracht. Erstens mssen Sie die Variablen in den Zeilen 36, 39, 42, 45, 48 und 51 konvertieren. Die Variable Sender ist ein Object-Typ (wie durch die Methodendeklaration in Zeile 30 angezeigt wird). Wir wissen zwei Dinge ber dieses Object: Es reprsentiert die angeklickte Bildlaufleiste (warum, verrate ich morgen) und sollte in dieser
145
Eigenschaft die verschiedenen Bildlaufleisten -Eigenschaften enthalten, darunter Minimum, Maximum usw. Ein Objekt hat jedoch diese Eigenschaft nicht, weshalb Sie es in den richtigen Typ ScrollBar umwandeln mssen, damit Sie die richtigen Eigenschaft erreichen knnen. (Mehr dazu morgen.) Als Zweites ist festzustellen, dass Sie in ein ScrollBar- und nicht in ein VScrollBaroder HScrollBar-Steuerelement umwandeln mssen (die beiden Letzteren erben ihre Eigenschaften vom ScrollBar-Steuerelement). Daher ist es unerheblich, ob das angeklickte Steuerelement nun ein VScrollBar- oder HScrollbar-Steuerelement ist, denn alles, was wir bentigen, ist der Zugang zu den entsprechenden Eigenschaften welche die ScrollBar-Klasse bereitstellt. (Mehr dazu morgen.) Abbildung 4.15 zeigt dieses Beispiel, nachdem die Bildlaufleiste unterhalb des Bildlauffeldes angeklickt wurde.
Abbildung 4.16: Wenn man unterhalb des Bildlauffeldes klickt, wird ein Bildlauf um den LargeChange-Wert ausgefhrt.
4.4
Zusammenfassung
Sie haben heute etwas ber drei wichtige und hufig eingesetzte Arten von Steuerelementen gelernt: Mens, Symbolleisten und Bildlaufleisten. Hinsichtlich ihrer Funktion sind sie sehr hnlich und teilen sich sogar viele hnliche Eigenschaften, doch hinsichtlich ihrer Implementierung sind sie vllig verschieden voneinander. Ein Steuerelement in Windows Forms ist ein Objekt, das dem Benutzer eine Schnittstelle prsentiert, mit der hufig eine Interaktion mglich ist. Es gibt unterschiedliche Arten von Steuerelementen, darunter Containersteuerelemente, Mens und Schaltflchen (Buttons). Mens lassen sich durch die Steuerelemente MainMenu und MenuItem darstellen. Das MainMenu nimmt Menelemente (MenuItems) auf, welche wiederum die Beschriftungen prsentieren, die der Benutzer sieht und mit denen er in Mens interagiert. Kontextmens, die sich ffnen, wenn der Benutzer auf ein Steuerelement rechtsklickt, verwenden ebenfalls MenuItem-Steuerelemente, setzen aber MainMenu anstelle von ContextMenu ein.
146
Eine Symbolleiste hnelt einem Men, nur dass man ein ToolBar-Steuerelement als bergeordnetes Objekt einsetzt und die ToolBarButton-Steuerelemente als untergeordnete Steuerelemente (ToolBarButtons knnen sogar MenuItem-Steuerelemente als untergeordnete Steuerelemente haben, wie es bei Dropdown-Schaltflchen der Fall ist). Von den beiden kann nur das ToolBar-Steuerelement verwendbare Ereignisse haben, so dass jeder Klick auf eine Schaltflche durch seinen Ereignishandler zu behandeln ist blicherweise mit einem switch- oder Select Case-Statement. Bei der Statusleiste handelt es um eine weitere Containerart. Sie verwendet die Steuerelemente StatusBar und StatusBarPanel. In der Regel sind Statusleisten nicht interaktiv, sondern zeigen lediglich Informationen an. Sowohl StatusBar als auch StatusBarPanel verfgen ber Eigenschaften, die sich zur Informationsanzeige nutzen lassen, doch das normale Vorgehen sieht so aus, dass man nur das StatusBarPanel-Steuerelement als Anzeigemechanismus verwendet und das Steuerelement StatusBar als Container. Bildlaufleisten schlielich gibt es in zwei Varianten: HScrollBar und VScrollBar stellen waagrechte bzw. senkrechte Bildlaufleisten dar. Sie haben erfahren, dass es recht leicht

Sprache

Windows Forms in 21 Tagen - Oberflächen Programmieren

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Windows Forms in 21 Tagen - Oberflächen Programmieren

Hochgeladen von

Copyright:

Verfügbare Formate

Chris Payne

bersetzung: Michael Matzer

.NET Windows Forms

Markt + Technik Verlag

2.2 2.3 2.4 2.5 2.6

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

3.3 3.4 3.5

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

4.4 4.5 4.6

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

9.7 9.8 9.9 9.10

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

11.3 11.4 11.5 11.6 11.7 11.8

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

12.5 12.6 12.7

15.3 15.4 15.5 15.6 15.7 15.8

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

16.4 16.5 16.6 16.7 16.8

Fortgeschrittene Techniken fr Steuerelemente in Windows Forms . 17.1 17.2

17.3 17.4 17.5 17.6

20.3 20.4 20.5 20.6 20.7 20.8

Inhaltsverzeichnis der Begleit-CD

1.16 1.17 1.18 1.19

1.20 1.21 1.22 1.23 1.24 1.25 1.26

Wer dieses Buch lesen sollte

Software fr die Beispiele

Wie dieses Buch aufgebaut ist

Wie dieses Buch aufgebaut ist

Programmcode auf Begleit-CD und US-Website

Und zu guter Letzt...

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

25 45 77 111 151 177 231

Tag 8 Tag 9 Tag 10 Tag 11 Tag 12 Tag 13 Tag 14

281 309 349 377 415 439 477

Tag 15 Tag 16 Tag 17 Tag 18 Tag 19 Tag 20 Tag 21

515 539 565 589 621 655 681

Woche 1: Die Grundlagen

Mit Windows Forms beginnen

Mit Windows Forms beginnen

Einfhrung in die Windows-Programmierung

Einfhrung in die Windows-Programmierung

Mit Windows Forms beginnen

Was ist .NET?

Was ist .NET?

Mit Windows Forms beginnen

gelieferte Daten senden

Was ist .NET?

Mit Windows Forms beginnen

Die Common Language Runtime (CLR)

Was ist .NET?

Das .NET Framework installieren

Mit Windows Forms beginnen

Was ist .NET Windows Forms?

Was ist .NET Windows Forms?

Mit Windows Forms beginnen

Integration mit .NET

Was ist .NET Windows Forms?

Mit Windows Forms beginnen

Die objektorientierte Vorgehensweise

So erstellen Sie Ihre erste Anwendung

So erstellen Sie Ihre erste Anwendung

Mit Windows Forms beginnen