.NET Windows Forms
Chris Payne Übersetzung: Michael Matzer
.NET Windows Forms ■ ■ ■
Oberf berfl rflächen hen ob objektorient entiert programmieren ADO.NET, ActiveX, Multithreading, Web Services Klassenbi nbiblio liothek des .NET Framework ken kenn ennenl enlernen
Markt + Technik Verlag
Bibliografische Information Der Deutschen Bibliothek Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über
abrufbar. Die Informationen in diesem Produkt werden ohne Rücksicht auf einen eventuellen Patentschutz veröffentlicht. Warennamen werden ohne Gewährleistung der freien Verwendbarkeit benutzt. Bei der Zusammenstellung von Texten und Abbildungen wurde mit größter Sorgfalt vorgegangen. Trotzdem können Fehler nicht vollständig ausgeschlossen werden. Verlag, Herausgeber und Autoren können für fehlerhafte Angaben und deren Folgen weder eine juristische Verantwortung noch irgendeine Haftung übernehmen. Für Verbesserungsvorschläge und Hinweise auf Fehler sind Verlag und Herausgeber dankbar. 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 zulässig. Fast alle Hardware- und Software-Bezeichnungen, die in diesem Buch erwähnt 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-Straße 10–12, D–81829 München/Germany Alle Rechte vorbehalten Übersetzung: Michael Matzer, Waldenbruch Lektorat: Rainer fuchs, [email protected] Fachlektorat: Frank Langenau, Chemnitz Herstellung: Philipp Burkart, [email protected] Satz: reemers publishing services gmbh, Krefeld, (www.reemers.de) Einbandgestaltung: Grafikdesign Heinz H. Rauner, Gmund Druck und Verarbeitung: Bercker, Kevelaer Printed in Germany
Inhaltsverzeichnis Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wer dieses Buch lesen sollte . . . . . . . . . . . . . . . . . . . . . . . . . . . . Vorkenntnisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Software für 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
Woche 1 – Vorschau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
23
Tag 1
Mit Windows Forms beginnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.1 Einführung 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. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
25 26 27 28 29 30 32 33 34 35 36 37 38 39 41 42 42 42 43
Tag 2
Windows Forms-Anwendungen erstellen . . . . . . . . . . . . . . . . . . . . . . . 2.1 Ein weiterer Blick auf Ihre Anwendung . . . . . . . . . . . . . . . . . . . Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
45 46 47
5
Inhaltsverzeichnis
Namensräume und Assemblies . . . . . . . . . . . . . . . . . . . . . . . . . . Die Main-Methode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Konstruktoren und Destruktoren. . . . . . . . . . . . . . . . . . . . . . . . . Ein abschließender Blick auf den Programmcode . . . . . . . . . . . Das Kompilieren von Windows Forms . . . . . . . . . . . . . . . . . . . . Eine vollständige Anwendung . . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Übung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
49 54 58 62 63 67 74 74 75 75 75
Mit Windows Forms arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
77
2.2 2.3 2.4 2.5 2.6
Tag 3
3.1
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. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
78 79 82 92 94 94 97 106 107 108 108 109
Menüs und Symbolleisten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
111
4.1 4.2
112 114 120 122 125 126 133 136 146 147 148 148 148
3.2
3.3 3.4 3.5
Tag 4
4.3
4.4 4.5 4.6
6
Einführung in Windows Forms-Steuerelemente . . . . . . . . . . . . Menüs hinzufügen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Menüs anpassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kontextmenüs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Symbolleisten, Statusleisten und Bildlaufleisten hinzufügen. . . Symbolleisten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Statusleisten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Bildlaufleisten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Übung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
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. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
151 152 153 156 158 162 162 163 168 169 173 173 174 174 175
Tag 6
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 Zusätzliche nützliche Steuerelemente . . . . . . . . . . . . . . . . . . . . 6.13 Das Layout steuern. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.14 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.15 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6.16 Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Übung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
177 179 180 183 184 186 187 189 193 195 199 200 206 208 215 218 221 222 228 229 230 230 230
7
Inhaltsverzeichnis
Tag 7
Mit Dialogfeldern arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.1 Informationen holen und anzeigen . . . . . . . . . . . . . . . . . . . . . . . 7.2 Unterschiedliche Arten von Dialogen. . . . . . . . . . . . . . . . . . . . . Modal vs. nichtmodal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Standarddialogfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.3 Dialogfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eigene Dialogfelder erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . Informationen abrufen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.4 Standarddialogfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ein- und Ausgabe von Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . Farben und Schriftarten wählen . . . . . . . . . . . . . . . . . . . . . . . . . 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
Woche 1 – Rückblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
261
Projekt 1: Eine Textverarbeitung erstellen. . . . . . . . . . . . . . . . . . Über das Textverarbeitungsprojekt. . . . . . . . . . . . . . . . . . . . . . . . Was Sie benötigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Benutzeroberfläche aufbauen. . . . . . . . . . . . . . . . . . . . . . . . Einige nützliche Dinge mit Pfiff hinzufügen . . . . . . . . . . . . . . .
261 261 262 262 274
Woche 2 – Vorschau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
279
Tag 8
Datenbindung in Windows Forms . . . . . . . . . . . . . . . . . . . . . . . . . . . .
281
8.1
282 283 284 285 287 290 290 293 296 306 307
8.2
8.3
8.4 8.5
8
Einführung in die Datenbindung . . . . . . . . . . . . . . . . . . . . . . . . Daten aus jeder beliebigen Quelle . . . . . . . . . . . . . . . . . . . . . . . Einfache Datenbindung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine Schaltfläche 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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Inhaltsverzeichnis
8.6
Tag 9
Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Übung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
307 307 308
ADO.NET einsetzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
309
9.1
Was ist ADO.NET? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ADO.NET gegenüber ADO . . . . . . . . . . . . . . . . . . . . . . . . . . . . ADO.NET und XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine Datenbank anlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine Access-Datenbank . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eine Datenbank in SQL Server 2000 anlegen . . . . . . . . . . . . . . SQL für die Datenbankabfrage . . . . . . . . . . . . . . . . . . . . . . . . . . Das SELECT-Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das INSERT-Statement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das UPDATE-Statement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das DELETE-Statement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einführung 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. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
310 311 313 314 314 317 319 319 322 322 323 323 325 326 329 334 338 341 342 345 346 347 347 348
MDI-Anwendungen erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.1 Einführung in die Mehrfachdokumentschnittstelle . . . . . . . . . . MDI-Menüs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.2 Eine MDI-Anwendung erstellen . . . . . . . . . . . . . . . . . . . . . . . . . Verschiedene Arten von untergeordneten Fenstern erstellen. . . 10.3 Die Besonderheiten von MDI-Formularen steuern . . . . . . . . . . Menüs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Untergeordnete Fenster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Auf untergeordnete Steuerelemente zugreifen . . . . . . . . . . . . . . 10.4 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
349 350 352 353 361 362 362 365 367 372
9.2
9.3
9.4 9.5
9.6
9.7 9.8 9.9 9.10
Tag 10
9
Inhaltsverzeichnis
10.5 10.6
Tag 11
Arbeiten mit der Windows-Ein-/Ausgabe . . . . . . . . . . . . . . . . . . . . . . .
377 378 380 388 393 396 400 402 405 406 411 412 413 413 413
Einführung in Streams. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Dateien und Verzeichnisse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Dateien lesen und schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . Binärdaten lesen und schreiben . . . . . . . . . . . . . . . . . . . . . . . . . Serialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Steuerelement RichTextBox . . . . . . . . . . . . . . . . . . . . . . . . Das Objekt FileSystemWatcher. . . . . . . . . . . . . . . . . . . . . . . . . . Asynchrone Ein-/Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Drucken unter .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Übung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Formulare Internet-fähig machen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
415
12.1
416 418 419 419 427 428 430
12.2
12.3
12.4
12.5 12.6 12.7
10
373 374 374 375
11.1 11.2
11.3 11.4 11.5 11.6 11.7 11.8
Tag 12
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. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
430 433 433 434 435 436 436 436 437
Inhaltsverzeichnis
Tag 13
Grafische Anwendungen mit GDI+ . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.1 Einführung 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 ausfüllen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Figuren dauerhaft machen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Figuren umwandeln. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.6 Windows Forms beschneiden . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.7 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.8 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.9 Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Übung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
439 440 442 442 443 446 450 454 460 468 470 471 473 474 475 475 475
Tag 14
ActiveX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.1 Einführung in ActiveX. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.2 ActiveX-Steuerelemente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das ActiveX-Steuerelement Webbrowser . . . . . . . . . . . . . . . . . . Die Typbibliotheken von Microsoft Office . . . . . . . . . . . . . . . . . 14.3 .NET-ActiveX-Steuerelemente erstellen . . . . . . . . . . . . . . . . . . . 14.4 Richtlinien für das Arbeiten mit ActiveX. . . . . . . . . . . . . . . . . . . 14.5 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.6 Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.7 Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Übung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
477 478 480 482 485 499 500 502 502 503 503 504
Woche 2 – Rückblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
505
Projekt 2: Die Textverarbeitung erweitern. . . . . . . . . . . . . . . . . . MDI hinzufügen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . E/A hinzufügen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Druckfunktionen hinzufügen . . . . . . . . . . . . . . . . . . . . . . . . . . .
505 505 507 511
11
Inhaltsverzeichnis
Woche 3 – Vorschau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
513
Tag 15
Webdienste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
515
15.1
Was sind Webdienste? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Simple Object Access Protocol (SOAP). . . . . . . . . . . . . . . . Andere Protokolle für Webdienste. . . . . . . . . . . . . . . . . . . . . . . . Mit ASP.NET Webdienste erstellen. . . . . . . . . . . . . . . . . . . . . . . Webmethoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Dienstbeschreibung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Webdienste unter ASP.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . Webdienste in Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . Webdienste suchen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Empfehlungen für den Einsatz von Webdiensten. . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Übung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
516 519 520 520 523 524 526 526 534 535 536 537 538 538 538
Windows-Dienste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
539
16.1 16.2 16.3
Was sind Windows-Dienste? . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einen Windows-Dienst erzeugen . . . . . . . . . . . . . . . . . . . . . . . . Dienste zum Zusammenspiel mit Windows bringen . . . . . . . . . Windows-Dienste starten und beenden. . . . . . . . . . . . . . . . . . . . Ihre Dienste überwachen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Schnittstellen für Windows-Dienste . . . . . . . . . . . . . . . . . . . . . . In Protokolldateien schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Übung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
540 542 549 552 553 555 560 562 563 564 564 564
Fortgeschrittene Techniken für Steuerelemente in Windows Forms .
565
15.2
15.3 15.4 15.5 15.6 15.7 15.8
Tag 16
16.4 16.5 16.6 16.7 16.8
Tag 17
17.1 17.2
12
Noch einmal: Menüs und die Steuerelemente Listbox, ComboBox und TabControl . . . . . . . . . . . . . . . . . . . . . DrawMode festlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Steuerelemente ListBox und ComboBox erweitern . . . . . . Das Steuerelement TabControl erweitern . . . . . . . . . . . . . . . . .
566 568 570 578
Inhaltsverzeichnis
17.3 17.4 17.5 17.6
Menüs: Eine Frage des Besitzes . . . . . . . . . . . . . . . . . . . . . . . . . Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fragen und Antworten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workshop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Quiz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Übung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
581 586 587 588 588 588
Tag 18
Benutzerdefinierte Steuerelemente in Windows Forms . . . . . . . . . . . 18.1 Wozu benutzerdefinierte Steuerelemente erzeugen? . . . . . . . . . 18.2 Benutzerdefinierte Steuerelemente . . . . . . . . . . . . . . . . . . . . . . . Rekapitulation der Architektur für 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. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
589 590 591 592 594 599 605 609 610 611 613 617 618 618 619 619
Tag 19
Multithreading-Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19.1 Einführung 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. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
621 622 626 627 628 635 645 652 653 654 654 654
Tag 20
Windows Forms konfigurieren und bereitstellen. . . . . . . . . . . . . . . . . 20.1 Einführung in die .NET-Konfiguration. . . . . . . . . . . . . . . . . . . . 20.2 So konfigurieren Sie Ihre Anwendungen . . . . . . . . . . . . . . . . . .
655 656 659
13
Inhaltsverzeichnis
Konfigurationsabschnitte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der Abschnitt . . . . . . . . . . . . . . . . . . . . . . . . . Der Abschnitt . . . . . . . . . . . . . . . . . . . . . . . . . . . . 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
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. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
681 682 689 690 694 696 702 703 704 704 704
Woche 3 – Rückblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
705
Projekt 3: Das Textprogramm vervollständigen . . . . . . . . . . . . . . Eine Klasse für eine neue Seite erzeugen . . . . . . . . . . . . . . . . . . Der weitere Weg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
705 705 722
Anhang A. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A.1 Antworten auf die Quizfragen und Übungen . . . . . . . . . . . . . . .
723 724
Stichwortverzeichnis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
809
20.3 20.4 20.5 20.6 20.7 20.8
Tag 21
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 Menüs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ContextMenu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . MainMenu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . MenuItem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.6 Das Steuerelement DataGrid . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.7 DateTimePicker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.8 Bildlauffähige 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
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
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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
71 72 72 73 75 77 79 81 85 86 87 88 88 90 92 93 94 96
1.20 1.21 1.22 1.23 1.24 1.25 1.26
16
Einleitung Willkommen bei .NET Windows Forms in 21 Tagen! Dieses Buch wird Sie Schritt für Schritt von den Grundlagen in Microsoft .NET Windows Forms zu recht fortgeschrittenen Themen führen. Während der nächsten 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 leistungsfähige Windows-Anwendungen zu erstellen, wobei Sie fast jede beliebige Programmiersprache verwenden können, die Sie kennen. Vom einfachen Taschenrechner bis hin zu Datenbank-gestützten multithreaded Webdiensten können Sie praktisch alles erstellen (wenn Sie von Multithreading oder Datenbankzugriffen keine Ahnung haben, dann lesen Sie am besten weiter). Einfach ausgedrückt: Wenn Sie künftig Windows-Anwendungen entwickeln wollen, werden Sie Windows Forms benutzen. Während Sie sich durch die Lektionen dieses Buches arbeiten, werden Sie entdecken, auf welch einfache Art und Weise sich diese Aufgaben bewältigen lassen. Sie werden nicht nur Beispiele sehen und lernen, wie Sie diese und andere Anwendungen erzeugen, sondern werden auch ein Verständnis dafür entwickeln, das Sie in die Lage versetzt, bei jedem künftigen 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 leistungsfähigen 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 können, ganz gleich, ob Sie bereits Erfahrung mit ihrer Erstellung in einer anderen Umgebung haben oder nicht. Da aber Microsofts Zukunft auf .NET fußt, wird jeder Windows-Anwendungsentwickler früher oder später auf Windows Forms umsteigen müssen. Selbst wenn Sie Windows Forms bereits kennen, wird Ihnen dieses Buch ein unschätzbares Hilfsmittel sein, das dazu beiträgt, vergessenes Grundlagenwissen aufzufrischen und Sie auf fortgeschrittenere Projekte vorzubereiten. Wer bereits mit anderen Methoden der Anwendungsentwicklung für Windows vertraut ist, wird Windows Forms als Erleichterung empfinden, da es bislang lästige 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 schließlich: Wenn Sie einfach nur neugierig auf das .NET Framework sind, dient Ihnen dieses Buch als ausgezeichnete Einführung und führt 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 äußerst hilfreich erweisen, ist aber keine Voraussetzung. Dieses Buch führt 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 können – 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 gründlich mit dem Framework und wird nötigenfalls auf weitere Ressourcen verweisen.
Software für die Beispiele Die einzige Software, die Sie neben Windows NT 4.0 mit Service Pack (SP) 6, Windows 2000 oder Windows XP benötigen, ist das .NET Framework und der Windows-Editor (NotePad). Das .NET Framework ist notwendig, um Windows Forms-Anwendungen erstellen zu können, und lässt sich kostenlos von Microsofts Website http://www.microsoft.com/net herunterladen. Außerdem 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 für diesen Zweck hervorragend. Wenn Ihnen ein anderes Textprogramm wie etwa Word, WordPad oder gar FrontPage eher behagt, dann können Sie selbstverständlich auch dieses benutzen. Visual Studio .NET wird hier nicht benötigt. In der Tat wird es im ganzen Buch recht selten verwendet. Während es zutrifft, dass Visual Studio .NET eine Menge ausgezeichneter Funktionen für die Anwendungsentwicklung bereitstellt, sind wir doch der Meinung, dass
18
Wie dieses Buch aufgebaut ist
es am besten ist, die Aufgaben »zu Fuß« zu bewältigen, bevor man sie von einer solchen Entwicklungsumgebung erledigen lässt. Auf lange Sicht werden Sie dafür dankbar sein. Um schließlich die Datenbank-bezogenen Beispiele verwenden zu können, benötigen Sie irgendeine Form von Datenbanksystem, das zu OLE DB konform ist, beispielsweise Microsoft Access oder SQL Server. Ohne diese Werkzeuge werden Sie die diesbezüglichen Beispiele nicht nutzen können.
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 für Schritt vorzugehen, wenn auch nicht zwingend. Nach der Erörterung des Themas folgen jeweils ein paar Beispiele, die von Analysen begleitet werden. Jedes Kapitel endet mit Antworten auf häufig gestellte Fragen, einem kurzen Quiz und einer Übung. Diese Bestandteile sind sorgfältig ausgewählt, so dass sie Ihr Wissen erweitern und Ihre Erfahrung mit der Technologie vertiefen können. Das Buch ist in drei logische Abschnitte aufgeteilt, von denen sich jeder über eine Woche erstreckt, sowie in einen Block aus drei Anhängen: 쐽
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 gehört, 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 nächsten zwei Wochen.
쐽
Während 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 höchstwahrscheinlich bei der Anwendungsentwicklung benötigen.
쐽
In der dritten Woche reichen die Windows Forms-Themen schon ein gutes Stück tiefer. Sie lernen, wie Sie Ihre Anwendungen vollständig anpassen, angefangen vom Aufbau leistungsfähiger (und vermarktbarer) Steuerelemente bis hin zur Konfiguration von Installationsoptionen und Sprachen. Sie werden sich einige Techniken aneignen, mit denen Sie die Leistung Ihrer Anwendungen beträchtlich erhöhen können: 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 während dieser Woche erworben haben, anzuwenden und zu festigen. 쐽
Schließlich erhalten Sie mit den Anhängen eine vollständige Referenz für die in dem vorliegenden Buch behandelten Themen. Um Antworten auf die Quizfragen zu erhalten, können Sie hier nachschlagen. Damit können 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 vollständigen Code für alle Beispiele des Buches in der amerikanischen Originalversion. Die im Buch wiedergegebenen Listings unterscheiden sich hiervon nur darin, dass Beschriftungen von sichtbaren Elementen der Benutzeroberfläche sowie die Kommentare ins Deutsche übersetzt wurden. Bei eventuellen Problemen mit der Lokalisierung Ihres eigenen Codes können Sie so durch Vergleich mit dem Originalcode die Fehlerursachen schnell einkreisen. Den Code für dieses Buch können 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 können. 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 häufig in Fettschrift dargestellt.
쐽
Platzhalter in Syntaxbeschreibungen werden kursiv gedruckt. Ersetzen Sie den Platzhalter durch den tatsächlichen Dateinamen, Parameter oder das Element, das Sie verwenden möchten.
쐽
Manchmal sind Codezeilen zu lang, als dass sie auf eine einzelne Zeile auf der Seite passen. An der fehlenden Zeilennummer können Sie erkennen, wenn eine Codezeile noch zur darüber liegenden Zeile gehört. Die Analyseabschnitte nach Codelistings besprechen den Code im Detail. Hier finden Sie heraus, was ein bestimmtes Stück Code bewirkt und wie es funktioniert, sowie häufig eine Betrachtung Zeile für Zeile.
쐽
Ferner enthält dieses Buch Hinweise, Tipps und Warnungen, die Ihnen dabei helfen sollen, wichtige oder hilfreiche Informationen schneller auszumachen. Einige stellen nützliche Hilfestellungen zum effizienteren Arbeiten dar. Außerdem finden Sie nützliche Gegenüberstellungen der Art »Tun Sie dies/Tun Sie dies nicht«. Hier finden Sie Vorschläge über den richtigen Weg, eine Aufgabe zu lösen (und Warnungen vor dem falschen).
Und zu guter Letzt... Ich hoffe, Sie haben viel Spaß beim Erlernen dieser interessanten Technologie. Sie wird es Ihnen ermöglichen, mit Windows viele verblüffende Dinge, die auf dem heutigen Markt sehr gefragt sind, anzustellen. Als Leser dieses Buches sind Sie für 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 könnten oder was Ihnen sonst am Herzen liegt. Wenden Sie sich bitte an den Lektor Rainer Fuchs, [email protected], der Ihnen weiterhilft oder Ihre Anfrage weiterleitet.
21
Tag 1
Mit Windows Forms beginnen
25
Tag 2
Windows Forms-Anwendungen erstellen
45
Tag 3
Mit Windows Forms arbeiten
77
Tag 4
Menüs und Symbolleisten
111
Tag 5
Ereignisse in Windows Forms
151
Tag 6
Windows Forms mit Steuerelementen erweitern
177
Tag 7
Mit Dialogfeldern arbeiten
231
Tag 8
Datenbindung in Windows Forms
281
Tag 9
ADO.NET einsetzen
309
Tag 10
MDI-Anwendungen erstellen
349
Tag 11
Arbeiten mit der Windows-Ein-/Ausgabe
377
Tag 12
Formulare Internet-fähig machen
415
Tag 13
Grafische Anwendungen mit GDI+
439
Tag 14
ActiveX
477
Tag 15
Webdienste
515
Tag 16
Windows-Dienste
539
Tag 17
Fortgeschrittene Techniken für Steuerelemente in Windows Forms
565
Benutzerdefinierte Steuerelemente in Windows Forms
589
Tag 19
Multithreading-Anwendungen
621
Tag 20
Windows Forms konfigurieren und bereitstellen
655
Tag 21
Debugging und Profiling
681
Tag 18
W O C H E
W O C H E
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 können. 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 darüber erfahren, wie Sie diese Anwendung kompilieren und ausführen. 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 »Menüs 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 Schaltflächen oder Menüs, reagieren können. An Tag 6, der den Titel »Windows Forms mit Steuerelementen erweitern« trägt, werden Sie Ihr Repertoire an Windows Forms-Steuerelementen beträchtlich aufbessern: Sie lernen alle wichtigen Steuerelemente kennen, die an Tag 4 nicht behandelt wurden. Tag 7, »Mit Dialogfeldern arbeiten«, bringt Ihnen schließlich alles über eine besondere Art von Windows Forms bei. Es gibt eine ganze Reihe von Dialogfeldtypen, die in der Windows-Programmierung sehr nützlich sind. Am Ende der Woche werden Sie das Gelernte rekapitulieren und es dazu verwenden, eine funktionierende Anwendung zu erzeugen. Lassen Sie uns ohne weiteren Verzug anfangen!
24
Mit Windows Forms beginnen
1
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 für 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
Einführung in die Windows-Programmierung
Das Wichtigste zuerst: Was ist ein Windows-Programm? Vielleicht sollten wir noch einen weiteren Schritt zurück tun und fragen: Was ist Microsoft Windows? Da Sie nun mal auf dem Weg sind, ein Entwickler zu werden, müssen 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 auszuführen, im Internet zu surfen, Dateien auszudrucken und so weiter. Wenn Sie dieses Buch lesen, dann behagt Ihnen diese Beschreibung höchstwahrscheinlich nicht, denn Sie wollen mehr wissen: wie alles unter der Motorhaube funktioniert und wie Sie Windows dazu bringen können, bestimmte Dinge für Sie zu erledigen. Unter seinem nett anzusehenden Äußeren ist Microsoft Windows – genau wie jedes beliebige andere Betriebssystem – eine Umgebung für Ü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 – nämlich 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
Einführung 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 könnte in einem Tastendruck bestehen, einem Mausklick oder auch einfach in einem Programmstart. Durch Verwendung einer Programmiersprache – einer Sammlung von Schlüsselwörtern, Anweisungen, Begriffen und so weiter, die für den Computer von besonderer Bedeutung sind – schreibt ein Programmierer Befehle für 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 näher unter die Lupe nehmen, wenn Sie Ihre ersten Anwendungen heute und morgen auf die Beine stellen.
Programmiersprachen Wie bereits erwähnt, ist eine Programmiersprache das, womit ein Programmierer das Betriebssystem instruiert. Sie enthält bestimmte Schlüsselbegriffe und eine Syntax. Auch wenn diese Elemente für den Laien wenig Sinn ergeben mögen, entsprechen sie einer wohldefinierten Logik. Selbst ohne Erfahrung auf diesem Gebiet haben Sie wahrscheinlich schon einmal von einigen Programmiersprachen gehört: 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 Wahlmöglichkeiten bereit; ihre Anwendungen ähneln gesprochenen Sprachen sehr. Beispielsweise kennt ein Eskimo (Inuit) zehn Ausdrucksweisen für den Begriff »Schnee«, wohingegen die englische Sprache nur wenige besitzt. In ähnlicher Weise verfügt C++ über verschiedene Möglichkeiten, »Funktionszeiger« auszudrücken, während 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. Darüber 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 häufig die
27
Mit Windows Forms beginnen
Microsoft Foundation Classes (MFC), wohingegen Visual Basic seinen eigenen Formulardesigner besitzt. Das führte dazu, dass das Erlernen einer neuen Sprache häufig auch bedeutete, eine neue Methode zur Erstellung von Windows-Anwendungen zu erlernen (was inzwischen in .NET nicht mehr der Fall ist; mehr darüber später). 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 könnte theoretisch ebenfalls in Maschinensprache schreiben, doch die meisten Menschen verstehen Binärbefehle nicht. Beispielsweise dürfte die Zeichenfolge »010101111« nach Unsinn aussehen, ergibt aber für den Computer tatsächlich einen Sinn. Die Sprachen, die Sie in diesem Buch benutzen werden, sind C# und Visual Basic .NET (VB .NET) – die erste, weil sie speziell für den Einsatz in der .NET-Umgebung entworfen wurde, und die zweite, weil die meisten Anfänger diese leicht erlernbare Sprache verwenden. Es ist meistens einfach, die eine in die jeweils andere zu übersetzen. Beispielsweise zeigt das folgende Stück 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 wählen können. Ich halte es für 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 würden viele Elemente entgehen, die Sie sonst beim separaten Erlernen dieser Programmiersprachen erhalten würden.
Win32-Programmierung Man hört häufig den Begriff »Win32«, mit dem Entwickler um sich werfen. Win32Anwendungen sind einfach Anwendungen, die für 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 Verfügung und gestattet Ihnen mehr Kontrolle über den Computer. Win16-Programme laufen auf einem Win32-Betriebssystem, das gilt aber nicht umgekehrt wegen beschränkter Verarbeitungsleistung und fehlender Abwärtskompatibilität.
28
Was ist .NET?
Sehr einfach ausgedrückt sind also 32 Bit besser als 16 Bit, weil Sie damit mehr in der gleichen Zeit verarbeiten können. Für einen Computerprozessor heißt 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 »Vermächtnis«-Programme, weil sie noch aus der Frühzeit 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. Während .NET ein Konzept ist, bringt das .NET Framework es zum Laufen. Sie werden das Framework bei der Arbeit mit Windows Forms ausgiebig nutzen. Einfach ausgedrückt ist das .NET Framework eine Architektur, auf deren Grundlage sowohl Internet- als auch Desktop-basierte Anwendungen erstellt und ausgeführt werden können. Für die Arbeitsweise von Windows stellt es eine völlig neue Welt dar, indem es ein standardisiertes System bereitstellt, das alle Anwendungen nutzen können, anstelle der vielen unterschiedlichen Frameworks, die heute verfügbar sind. .NET stellt für diese Anwendungen auch eine neue Umgebung bereit, in der sie ablaufen können. Das ist effizienter, sicherer und leistungsfähiger. Kurz und gut: Mit Hilfe von .NET können 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 Verfügung steht und sich direkt oder von anderen Anwendungen nutzen lässt. Diese Dienste wären für jeden verfügbar, der sie braucht; man wählt sich einfach ins Web ein und stellt die Verbindung zum Dienst her. Stellen Sie sich vor, Sie hätten 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 befände es sich auf Ihrem Computer. Abbildung 1.2 illustriert dieses Konzept.
29
Mit Windows Forms beginnen
Ihr Computer
Befehle senden
Internet
gelieferte Daten senden
Dienst
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 müssen sich keine Sorgen machen, ob ihre Installation klappen wird oder ob sie ihre Anwendung pflegen, also aktualisieren müssen. Der Entwickler muss sich nicht sorgen wegen Installationsproblemen oder der Pflege mehrerer Programmversionen auf möglicherweise Tausenden von Anwendercomputern. Er erstellt das Programm einfach und stellt es über das Internet zur Verfügung, so dass Anwender vorbeischauen können und es einsetzen, wann sie es benötigen. Wenn der Entwickler eine neue Version erstellt, stellen die Benutzer eine Verbindung nur deshalb her, um die neuen Funktionen zu nutzen. In den nächsten Abschnitten erfahren Sie mehr über die Komponenten von .NET und wie sie zusammenwirken, um Ihre Arbeit als Entwickler zu vereinfachen. Es mag zwar zunächst 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 folgendermaßen: Sie wird von einem Entwickler in einer Programmiersprache geschrieben und dann zu einer ausführbaren Anwendung kompiliert (das ist ein sehr wichtiges Konzept). Das Betriebssystem stellt die Umgebung für die Ausführung der Anwendung bereit und bietet ihr je nach Bedarf Zugriff auf seine Ressourcen. In einem Multitasking-Betriebssystem wie Windows lassen sich mehrere Anwendungen gleichzeitig ausführen, 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 heißt sie wird ausgeführt und räumt 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 beschäftigt und kümmern sich nicht darum, was andere Anwendungen so treiben. So könnte Anwendung A beispielsweise abstürzen, während Anwendung B weiterläuft, 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 nötig ist. Das kann zu einem recht komplizierten Registrierungsvorgang führen, 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 lästigen Code schreiben, nur um dafür 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 ausführbaren 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 später Ihr Programm ausführen, wird es von einem Just-In-Time (JIT) -Compiler in Maschinencode übersetzt, welcher wiederum von der CLR ausgeführt wird. Dieser zweistufige Vorgang ist zwar langsamer als der einstufige vor der Einführung von .NET, aber nicht so viel, wie Sie jetzt annehmen würden. Der JIT kann die MSIL sehr leicht verstehen. Daher lässt sie sich effizienter kompilieren als eine traditionelle Sprache. Und zum anderen bietet dieser Vorgang einen großen Vorteil gegenüber der ersten Methode: nämlich plattformübergreifende Kompatibilität. Maschinensprachen hängen 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 abschließenden Schritt des Kompilierens in Maschinensprache ausführt; aber darum haben Sie sich in der Regel nicht zu sorgen. Große Unternehmen wie Microsoft bieten höchstwahrscheinlich so einen Compiler für jede Plattform, bevor Sie eine Anwendung portieren müssen. Ein weiterer Vorteil des .NET-Paradigmas gegenüber dem herkömmlichen besteht darin, dass MSIL spezielle Attribute enthält, die als Metadaten bezeichnet werden und die es einem Programmcode erlauben, sich selbst gegenüber 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 nötig, denn alle wichtigen Informationen liegen der Anwendung bei. Zu
31
Mit Windows Forms beginnen
solchen Informationen könnte gehören, nach welchen Abhängigkeiten man suchen soll, wo Sicherheitsanforderungen zu finden sind, Versionsnummern, Autoren usw. Die Bündelung 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 unterstützt. Dadurch können alle Ihre bevorzugten Programmiersprachen .NET unterstützen. Mit der künftigen Verbreitung von .NET dürfen Sie weitere Compiler von anderen Unternehmen erwarten. Lassen Sie uns nun mal darauf achten, was nach dem Kompilieren passiert: Das Programm wird ausgeführt.
Die Common Language Runtime (CLR) Die CLR bildet das Zentrum des .NET Frameworks. Stellen Sie sie sich wie den Hauptprozessor für Ihre Anwendungen vor; sie behandelt die gesamte Ausführung und Verwaltung Ihrer Anwendungen. Sie hat zwar eine Menge Funktionen, doch Sie brauchen vorerst nur einige davon zu kennen. Zunächst einmal steuert die CLR den Ressourcenbedarf Ihrer Anwendung. Sie teilt deren Komponenten Speicher und Prozessorzeit zu und nimmt sie nach der Nutzung wieder zurück. Dieser Vorgang wird als Garbage Collection (Müllbeseitigung) bezeichnet, also als Speicherbereinigung. Entwickler mit einer gewissen Erfahrung, besonders in C und C++, werden sich an all die lästigen Routinen erinnern, die man schreiben musste, um Speicherressourcen zu verwalten. Diese Prozedur ist zum Glück nicht mehr nötig. Als zweiten Aspekt stellt die CLR eine vereinheitlichte Architektur bereit. Ganz gleich, welche Programmiersprache Sie nutzen, können Sie sich immer auf das gleiche Framework beziehen. C++-Anwendungen können 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 Ausführung zu gewährleisten. 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 für die CLR geschrieben wird, ist als verwalteter Code (Managed Code) bekannt: CLR verwaltet jeden Aspekt seiner Ausführung. Code, der nicht für 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 lässt sich weiterhin in der CLR ausführen, aber dafür müssen 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 Sicherheitsprüfungen Ausführung
Nichtverwalteter Code Import in .NET
Garbage Collection (Müllbeseitigung)
Abbildung 1.3: Die CLR verwaltet die komplette Ausführung von verwaltetem Code und sorgt so für Sicherheit, Kompatibilität und richtige Funktionsweise.
Das .NET Framework installieren Bevor Sie die CLR einsetzen und Windows Forms schreiben können, müssen Sie zunächst 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 können 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, führen 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 zurück, während sich Ihnen die Tore zur .NET-Welt öffnen (in anderen Worten: während das SDK installiert wird). Nach dem Abschluss der Installation erscheint ein Verknüpfungssymbol zu einer SDKÜbersicht auf Ihrem Desktop. Diese Webseite hat Verknüpfungen, um die .NET-Musterbeispiele einzurichten (falls Sie sie in einem vorhergehenden Schritt installiert haben) wie auch Verknüpfungen zu weiterer Dokumentation.
33
Mit Windows Forms beginnen
Abbildung 1.4: Der Installationsvorgang für 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. Für die Entwicklung mit Windows Forms brauchen Sie jedoch lediglich ein Textprogramm, um Code zu schreiben. Zusätzlich zum Textprogramm bieten viele Entwicklungsumgebungen ausgetüftelte Benutzeroberflächen, die fortgeschrittene Fähigkeiten für die Verwaltung von Code und Projekten besitzen. Diese Funktionen sind häufig nützlich, 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 können. (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 für die Anwendungen, die Sie erstellen. Es zeichnet Ihren Code in Farbe aus und stellt kontextabhängige Funktionen bereit, so etwa kleine Popup-Felder, die für Sie Sätze vervollständigen. Darüber hinaus stellt Visual Studio .NET zahlreiche Assistenten zur Verfügung, die Ihnen beim Erstellen von Windows Forms-Anwendungen beistehen. Obwohl es zahlreiche für Entwickler wertvolle Funktionen in Visual Studio .NET gibt, wird sich dieses Buch nicht darauf konzentrieren. Vielmehr beschäftigt es sich mit der Windows Forms-Technologie. Schließlich besteht die beste Methode, das Programmieren von Windows Forms zu erlernen, darin, sie selbst zu erstellen, und nicht, sie von einer grafischen Entwicklungsumgebung für Sie erstellen zu lassen. Sobald Sie darin versiert sind, selbst Quellcode zu schreiben, werden Sie die Leistungsmerkmale von Visual Studio .NET umso mehr zu schätzen wissen. Für dieses Buch brauchen Sie lediglich Notepad.
34
Was ist .NET Windows Forms?
In diesem Buch legen wir für 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 für 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, können Sie dem weiteren Vorgehen leicht folgen.
1.3
Was ist .NET Windows Forms?
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 für die Entwicklung von Windows-Anwendungen, die auf dem .NET Framework basieren. Ein Blick auf die beiden Wörter »Windows Forms«: Sie kennen ja Windows bereits als Betriebssystem, das Benutzereingaben entgegennimmt und entsprechende Arbeiten ausführt. Ein Formular (form) ist genauso wie seine Papierversion etwas, das man mit Informationen ausfüllt, um damit etwas Bestimmtes zu erreichen. Ein Papierformular lässt sich beispielsweise dazu verwenden, einen Pass zu beantragen, eine Prüfung 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 für eine Dienstleistung zu registrieren. Wahrscheinlich haben Sie bereits Dutzende, wenn nicht Hunderte solcher Formulare ausgefüllt. Abbildung 1.5 zeigt ein solches Formular. Der Vorteil eines digitalen Formulars gegenüber einem Papierformular besteht darin, dass das digitale mit Ihnen interagieren kann. Sobald Sie Informationen eintragen, kann das Formular die Eingabe verarbeiten oder Ihnen weitere Auswahlmöglichkeiten anbieten. Genau auf dieser Idee fußt 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 lässt sich für das Sammeln oder Anzeigen von Daten verwenden, für die Ausgabe von Alarmmeldungen usw. (Bitte beachten Sie, dass wir im Folgenden den Begriff sowohl für die Technologie als auch für das eigentliche Windows Forms-Fenster (= Formular) verwenden. Das ist zulässig, denn die Technologie besteht hauptsächlich aus diesen Fenstern.)
35
Mit Windows Forms beginnen
Abbildung 1.5: Ein typisches Webformular enthält Textfelder und eine Schaltfläche.
Diese Beschreibung könnte den Eindruck erwecken, dass ein Windows Form nicht sonderlich funktionsreich sei, doch in Wirklichkeit stellt es eine Menge Leistung und Flexibilität bereit. Weil die Windows Forms-Technologie auf dem .NET Framework beruht, steht ihr eine umfangreiche Bibliothek von nützlichen Objekten und Methoden zur Verfügung, die es einem Windows Forms-Fenster gestatten, so ziemlich alles auszuführen, was Sie wünschen. 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 Leistungsfähigkeit.
Integration mit .NET .NET und die CLR bieten Ihnen eine Fülle 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 für 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 enthält fast alle Objekte, die Sie jemals für Ihre Anwendungen brauchen werden, in vorgefertigter und einsatzbereiter Form. Sie brauchen eine Komponente, die auf Datenbanken zugreift? .NET stellt Ihnen mehrere zur
36
Was ist .NET Windows Forms?
Auswahl. Wie wär's mit XML-Dateien? Die hat .NET ebenfalls. Das Erlernen der Windows Forms-Programmierung besteht also zum Teil aus dem Aufbau eines möglichst großen Repertoires solcher Objekte. Das ist der Faktor, der die Experten von den Neulingen unterscheidet. Und das Beste dabei: Dieses Framework steht Ihnen zur Verfügung, gleichgültig, welche Programmiersprache Sie wählen. Apropos Datenbankzugriff: Mit Windows Forms verfügen Sie über die Leistungsfähigkeit von ADO.NET, der nächsten Generation von ActiveX Data Objects (= ADO). Diese Weiterentwicklung führt viele Leistungsmerkmale ein, die die Reichweite und Flexibilität Ihrer Anwendung erhöhen. Sie können auf vorhandene Datenquellen zugreifen oder eigene erzeugen, können unverbundene Datensätze nutzen, XML-Dateien lesen und schreiben und anderes. Mehr über diese Leistungsmerkmale erfahren Sie an Tag 9. In das .NET Framework sind auch leistungsfähige Sicherheitsmerkmale integriert. Diese gestatten es dem Betriebssystem bereits dann zu erkennen, wie sicher Ihre Anwendung ist, wenn diese noch gar nicht ausgeführt 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 auszuführen. Auch das Konfigurieren und Installieren Ihrer Anwendungen ist ein Kinderspiel. Die Konfiguration erfordert häufig 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, entfällt. All dies ist dank CLR und Metadaten möglich. 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 können, um so deren Funktionsumfang zu nutzen. Daher brauchen Sie diese Funktionen nicht mehr selbst zu erstellen. GDI+ (Graphical Device Interface: Schnittstelle zu Grafikgeräten) erlaubt Ihnen, die grafischen Funktionen von Windows zu nutzen, um Ihre Anwendungen für die visuelle Interaktion fit zu machen. So können Sie mit GDI+ beispielsweise Anwendungen einfärben, Grafiken laden und bearbeiten und sogar Fenster transparent machen. Mehr zu GDI+ finden Sie an Tag 13. Wir werden alle diese Funktionen in den nächsten 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 für sich allein nicht sonderlich interaktiv. Wie Sie später an diesem Tag sehen werden, ist die Zahl der Möglichkeiten dessen, was ein Benutzer mit einem Formular tun kann, recht begrenzt. Windows Forms-Steuerelemente – die es alle in der
37
Mit Windows Forms beginnen
Klassenbibliothek des .NET Framework gibt – können Ihrer Anwendung erheblich mehr Dynamik verleihen, indem sie Ihnen interaktive Objekte bereitstellen, wie zum Beispiel Schaltflächen, Textfelder, Menüs und Statusleisten. Alle Windows Forms-Steuerelemente (Controls) arbeiten in einer gemeinsamen Architektur – das macht das Erlernen neuer Steuerelemente so einfach. Jedes Steuerelement lässt sich durch seine Eigenschaften vollständig steuern. Sollte es noch keine Steuerelemente geben, die Ihnen zusagen, so können Sie leicht Ihre eigenen erstellen. Die meisten verbreiteten HTML-Steuerelemente haben in Windows Forms ein Gegenstück. 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 vollständig objektorientiert. Und was bedeutet das? Objektorientierte Programmierung (OOP) ist ein Programmierparadigma, das eine logische Möglichkeit zur Anwendungsentwicklung bietet; es verknüpft Programmierbegriffe mit der Realität. In echter OOP ist alles ein »Objekt«, genauso wie alles, mit dem Sie täglich interagieren, ein Objekt ist. Ihr Auto, Ihre Kaffeemaschine, Ihr Stuhl – alle sind Objekte. Jedes Objekt verfügt über Eigenschaften, die es definieren. Ihre Auto etwa hat eine Farbe, gefahrene Kilometer, die Eigenschaft »Hersteller« und so weiter. Mit all diesen Eigenschaften lässt 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 verfügen auch über Methoden bzw. Aktionen oder Verhaltensweisen. Ihr Auto hat Methoden anzuspringen, zu bremsen, anzuhalten usw. Ein Windows Form hat Methoden zu starten, zu schließen, in der Größe verändert zu werden, die Farbe zu ändern und viele weitere Verhaltensweisen. Abbildung 1.6 zeigt Beispiele von Objekten und einige ihrer Eigenschaften und Methoden. Darüber 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 Käfer vom ursprünglichen Käfer ab. Dies sind Prinzipien (nämlich Schnittstellen bzw. Vererbung), die sich auch in der OOP wiederfinden. Sie bieten Ihnen die Flexibilität, um Ihre vorhandenen Objekte zu erweitern, wenn sie nicht genau Ihre Wünsche erfüllen.
38
So erstellen Sie Ihre erste Anwendung
“Auto”-Objekt Eigenschaften: Farbe, Hersteller Methoden: Start, Tür öffnen
“Scheinwerfer”-Objekt Eigenschaften: Helligkeit, Farbe Methoden: ein-/ausschalten
“Rad”-Objekt Eigenschaften: Größe, 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 verfügen.
Windows Forms basiert auf Prinzipien der OOP: Jeder Teil einer Windows Forms-Anwendung ist ein Objekt, vom sichtbaren Fenster bis hin zu den anklickbaren Schaltflächen, den ausfüllbaren Textfeldern und sogar bis zur Tageszeit, zu der Sie die Anwendung nutzen. Selbst wenn Sie noch nie OOP eingesetzt haben, dürfte Ihnen dies einleuchten. Solange Sie sich alles als ein selbstständiges 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 für Objekte in Windows Forms gesehen haben.
1.5
So erstellen Sie Ihre erste Anwendung
Höchste 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 auszuwählen und nicht TXT-Dateien. Sonst wird nämlich 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
Mit Windows Forms beginnen
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 genügen: Die Zeilen 2 und 3 verwenden eine spezielle Syntax, um Ihrer Anwendung zu gestatten, die Namensräume oder Objektgruppen (aus der .NET-Klassenbibliothek) System und System.Windows.Forms zu nutzen. Das Schlüsselwort Imports referenziert diese Namensräume zwecks einfacherer Verwendung. In Zeile 4 deklarieren Sie Ihre Klasse bzw. Ihr Objekt. Die Zeilen 6-8 stellen den Startpunkt für Ihre Anwendung dar und die Zeilen 10-12 sind ein so genannter Konstruktor. In Zeile 14 schließen Sie Ihre Klasse ab. Ein Großteil dieses Codes konfiguriert Ihre Anwendung. Die einzige echte Ausführungsanweisung finden Sie in Zeile 11, die aussieht, als ob sie irgendwo in der Anwendung den Gruß »Hallo Welt!« anzeigen würde. Der nächste Schritt besteht darin, Ihre Anwendung zu MSIL zu kompilieren. Öffnen Sie ein Fenster mit einer Befehlseingabeaufforderung (START / (ALLE) PROGRAMME / ZUBEHÖR / EINGABEAUFFORDERUNG) und navigieren Sie zu dem Ordner, in welchem Sie diese Datei gespeichert haben. Geben Sie den folgenden Befehl in das Fenster ein und drücken Sie (¢): vbc /t:winexe /r:System.dll /r: System.Windows.Forms.dll helloworld.vb
Kümmern Sie sich hier noch nicht um die Syntax. Es genügt, dass Sie wissen, dass dieser Befehl eine Visual Basic .NET-Anwendung zu einer ausführbaren 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 Ausführung 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 Glückwunsch 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 später 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 können 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 ausführbaren Datei. MSIL enthält Metadaten, die wiederum der CLR Informationen über Ihre Anwendung, darunter Versionsnummer und Sicherheitsangaben, zur Verfügung stellen. Die Metadaten befreien Sie von der Notwendigkeit, Ihre Anwendung bei einem Betriebssystem anzumelden. Windows Forms ist als Teil von .NET ein Framework (Gerüst) für die Erstellung von Windows-Anwendungen, die die CLR nutzen. Sein Vorteil gegenüber herkömmlicher 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 lässt. Er muss zu MSIL kompiliert werden, bevor man ihn verwenden kann; Sie haben das getan, indem Sie einen Compiler an der Eingabeaufforderung benutzten.
41
Mit Windows Forms beginnen
1.7 F
Kann ich wirklich jede gewünschte Programmiersprache benutzen, um Windows Forms zu erstellen? A
F
Fragen und Antworten
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 Unterstützung für viele weitere Sprachen gerade entwickelt wird.
Was versteht man unter ASP.NET? A
1.8
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, während Windows Forms für Windows-Anwendungen eingesetzt wird.
Workshop
Dieser Workshop soll Ihnen helfen, sich besser an die heute behandelten Begriffe zu erinnern. Es hilft Ihnen sehr, die Antworten vollständig 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 darüber, in welcher Umgebung eine Anwendung erstellt wurde. 3. Auf welche Weise ermöglicht MSIL plattformübergreifende 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 würde der folgende Code bewirken, sobald er kompiliert und ausgeführt würde? 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
2
Windows Forms-Anwendungen erstellen
Nachdem Sie die Grundlagen verstanden haben, ist es nun an der Zeit, sich kopfüber in die Erstellung von Windows Forms-Anwendungen zu stürzen. 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 für 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 können. Heute lernen Sie, 쐽
was Klassen, Assemblies und Namensräume 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:
46
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!"
Ein weiterer Blick auf Ihre Anwendung
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 näher auf den Code ein, aber Ihnen werden einige Ähnlichkeiten auffallen. Es finden sich Namensräume, 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, dürfte Ihnen der obenstehende Code merkwürdig erscheinen. Lassen Sie uns zunächst Zeile 4 in beiden Listings betrachten, denn sie enthält 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 für 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 benötigt: wohin die Türen und die Lampen kommen, die Zimmergröße, die Leitungen und das ganze übrige Innenleben eines Hauses. Ein Bauleiter benutzt die Blaupause bzw. einen Bauplan, um das tatsächliche Haus zu
47
Windows Forms-Anwendungen erstellen
erbauen, das ein gebrauchsfertiges Objekt darstellt: Sie können die Türen öffnen und schließen, die Wandfarbe ansehen (und ändern) usw. Ähnlich wie eine Blaupause legt eine Klasse das ganze Innenleben eines Objekts fest. In unserem Fall entspräche der Bauleiter der CLR, denn sie untersucht die Blaupausen und wandelt sie zu etwas Brauchbarem um: zu einem Objekt oder einer Anwendung. Somit können die Benutzer Ihres Objekts Methoden ausführen, die Sie festgelegt haben, und verfügbare Eigenschaften untersuchen. Kurz und gut: Sie erstellen eine Klasse, die von der CLR in etwas Nützliches umgewandelt wird. Der jeweilige Benutzer des Objekts braucht sich nicht darum zu kümmern, 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 zuverlässig ihren Dienst versieht. Diese Abstraktion von Komplexität wird als Kapselung bezeichnet. Mit Hilfe von Klassen kapseln Sie die Einzelheiten und Implementierungsdetails, so dass sich der Benutzer nicht darum zu kümmern 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 Klassenbaupläne in einem Objekt.
Wenn Ihnen diese Vorstellung immer noch nebulös vorkommt, sorgen Sie sich nicht. Wenn wir diese und andere Klassen untersuchen, werden Sie rasch ein grundlegendes Verständnis entwickeln. Die Wörter »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. Zurück zu Zeile 4: Wir müssen noch zwei Teile untersuchen. Das Schlüsselwort Public bedeutet, dass diese Klasse für andere Klassen zugänglich ist. Wenn Sie umgekehrt das Schlüsselwort Private benutzen, kann keine andere Klasse diese Klasse sehen oder benutzen. Wenn sie nicht öffentlich wäre, könnte sie Ihre Anwendung nicht nutzen. Es lassen sich hier ein paar weitere Schlüsselwörter verwenden, so etwa Protected oder Friend, aber wir werden diese zu gegebener Zeit betrachten.
48
Ein weiterer Blick auf Ihre Anwendung
Der letzte Bestandteil von Zeile 4, nämlich Inherits Form, ist etwas Besonderes für objektorientierte Programme (die C#-Version verwendet das Schlüsselwort 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 für alle Windows FormsAnwendungen: Sie enthält 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 Schlüsselwort Inherits teilt der CLR mit, dass alle Eigenschaften und Methoden in dieser Form-Klasse automatisch Ihrer Klasse HelloWorld hinzugefügt 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 Fähigkeit, 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 enthält Eigenschaften, die alle anderen Klassen gemeinsam nutzen. Wenn Sie also wissen, wie Sie mit einem Objekt interagieren, können Sie demzufolge auch mit allen seinen Abkömmlingen interagieren. Jeder Abkömmling erbt Merkmale von allen seinen Vorgängern. 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 wäre Ihre Klasse HelloWorld nicht in der Lage, darauf zuzugreifen. Nur nicht-Private Mitglieder der Form-Klasse werden vererbt. Nicht nur Klassen können 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, fällt Ihnen der Rest wesentlich leichter. Über diese Themen erfahren Sie mehr im ganzen restlichen Buch.
Namensräume und Assemblies Die Zeilen 1 und 2 in Listing 2.1 enthalten ein weiteres wesentliches Element von Windows Forms-Anwendungen: das Schlüsselwort Imports (in C# lautet es using, wie Sie in Listing 2.2 sehen). Wie Sie bereits erfahren haben, erlaubt Ihnen dieses Schlüsselwort, Sammlungen anderer Klassen in Ihrer Anwendung zu verwenden. Solche Sammlungen werden als Namensräume bezeichnet. Sie dienen dazu, miteinander verwandte Klassen zu gruppieren.
49
Windows Forms-Anwendungen erstellen
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 gebräuchlichen 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 enthält. Der Forms-Namensraum ist einer von vielen im Windows-Namensraum, und dieser ist wiederum nur einer von vielen im System-Namensraum. Namensräume sind hierarchisch organisiert, um ihre Nutzung intuitiv und einfacher zu machen, insbesondere dann, wenn man schon die OOP-Grundbegriffe versteht. Ein paar der gebräuchlicheren Namensräume 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 Namensräume hierarchisch untereinander angeordnet sind, bedeutet nicht notwendigerweise, dass der eine irgendetwas vom anderen erbt. Namensräume sind im Unterschied zu Klassen lediglich Sammlungen von Objekten – aus ihnen werden keine nutzbaren Objekte erstellt. Man verwendet sie lediglich aus organisatorischen Gründen. Natürlich können Sie leicht Ihre eigenen Namensräume erstellen. Es mag an diesem Punkt noch nicht nötig 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
Ein weiterer Blick auf Ihre Anwendung
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 können ihn auch vorhandenen Namensräumen hinzufügen: Namespace System.Windows.Forms
Es hängt alles davon ab, wie Sie diese Dinge gruppieren möchten. Wie gesagt, brauchen Sie Namensräume nicht unbedingt zu importieren. Dieses Vorgehen erlaubt Ihnen jedoch, weiter unten in Ihrem Code Kurzbefehle, also Abkürzungen, zu verwenden. Wenn Sie beispielsweise Zeile 2 aus Listing 2.1 entfernen würden, müssten Sie Zeile 4 von Public Class HelloWorld: Inherits Form
in Public Class HelloWorld: Inherits System.Windows.Forms.Form
ändern. Mit anderen Worten: Sie hätten dann den gesamten Namensraum-Namen für die Form-Klasse zu spezifizieren. Das Gleiche gilt für die Klasse System: Wenn Sie sie nicht importieren, würden Ihre Datentypen wie System.Integer statt nur wie Integer aussehen. Ich empfehle
Bitte beachten Sie
Importieren Sie Namensräume mit dem Schlüsselwort Imports, wenn Sie Klassen verwenden werden, die in diesem Namensraum enthalten sind; das hilft bei der Organisation und spart Zeit.
Verlassen Sie sich nicht auf die Verwendung des kompletten Namensraum-Namens für alle Ihre Objekte, selbst wenn Sie meinen, dass Ihnen das hilft, Klassen zu unterscheiden. Dieses Vorgehen bläht 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. Namensräume sind also logische Gruppierungen verwandter Klassen, aber das sagt noch lange nichts über ihre physische Position aus. Sie können diverse Quellcode-Dateien in verschiedenen Teilen Ihrer Festplatte abgelegt haben, aber alle können demselben Namensraum angehören. Um mehrere Dateien und Namensräume 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 können mehrere Klassen oder Namensräume in einer einzelnen Assembly unterbringen.
51
Windows Forms-Anwendungen erstellen
Beispielsweise werden Sie in Ihrem Ordner c:\winnt\Microsoft.NET\Framework\version\ die Datei system.dll entdecken. Diese Assembly enthält die Namensräume System, System.CodeDom (und dessen Unternamensräume), System.ComponentModel, System.Net (und dessen Unternamensräume) und noch ein paar andere. Wie man sie verwendet, untersuchen wir etwas später heute im Abschnitt »Das Kompilieren von Windows Forms«. Tabelle 2.1 listet die verschiedenen .NET-Assemblies und die darin enthaltenen Namensräume auf. Assembly
Namensräume
custommarshalers.dll
Runtime.InteropServices.CustomMarshalers
mscorlib.dll
Collections, Configuration.Assemblies, Diagnostics.SymbolStore, Globalization, IO, IO.IsolatedStorage, Reflection, Reflection.Emit, Resources, alle Runtime.*-Namensräume (außer 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.dll
System, CideDom, CodeDom.Compiler, Collections.Specialized, ComponentModel, ComponentModel.Design, Configuration, Diagnostics, Net, Net.Sockets, Text.RegularExpressions, Timers
system.configuration.install.dll
Configuration.Install
system.data.dll
Data, Data.Common, Data.OleDb, Data.SqlClient, Data.SqlTypes
system.design.dll
ComponentModel.Design.Serialization, Web.UI.Design, Web.UI.Design.WebControls, Windows.Forms.Design
system.directoryservices.dll
DirectoryServices
system.drawing.dll
Drawing,Drawing.Drawing2D, Drawing.Imaging, Drawing.Printing, Drawing.Text
system. drawing.design.dll
Drawing.Design
system.enterpriseser- EnterpriseServices, System.EnterpriseServices.CompensatingResourcevices.dll Manager system.management.dll Management, Management.Instrumentation system.messaging.dll
Messaging
Tabelle 2.1: NET-Assemblies und -Namensräume
52
Ein weiterer Blick auf Ihre Anwendung
Assembly
Namensräume
system.runtime. remoting.dll
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
Security.Cryptography.Xml
system.serviceprocess.dll
ServiceProcess
system.web.dll
Web, Web.Caching, Web.Configuration, Web.Hosting, Web.Mail, Web.Security, Web.SessionState, Web.UI, Web.UI.HtmlControls, Web.UI.WebControls
system.web.services.dll
Web.Services, Web.Services.Configuration, Web.Services.Description, Web.Services.Discovery, Web.Services.Protocols
system.windows.forms.dll
Windows Forms
system.xml.dll
Xml, Xml.Schema, Xml.Serialization, Xml.Path, Xml.Xsl
(Soweit nicht anders spezifiziert, sind alle Namensräume Sub-Namensräume des Namensraums System.) Tabelle 2.1: NET-Assemblies und -Namensräume (Forts.)
Es gibt eine Menge Namensräume in Tabelle 2.1, von denen Sie manche in diesem Buch nie verwenden werden. Häufig müssen Sie aber wissen, zu welchen Assemblies sie gehören, um Ihre Anwendungen kompilieren zu können. Wenn Sie mit älteren Methoden der Windows-Programmierung vertraut sind, dürften Sie die .dll-Endung wiedererkennen, die für 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 völlig 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 für das Gruppieren von Namensräumen. Sie sind eine wichtige Komponente des .NET Frameworks, da sie die Grenzen zwischen Anwendungen darstellen, mit denen die CLR die Gültigkeitsbereiche Sicherheit, Versionierung und Metadaten erzwingt. Beim Entwickeln mit Windows Forms werden Sie Assemblies sehr häufig verwenden.
53
Windows Forms-Anwendungen erstellen
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 Hälfte verstanden. Eine Methode ist ein Codestück, das eine Funktion ausführt; sie bewirkt etwas. Code, der irgendeine Funktion ausführt, 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 zurück, die die Methode aufgerufen hat. (Nichts hindert Sie, eine Function ohne Rückgabewert aufzusetzen; aber das Umgekehrte geht nicht: Eine Sub-Methode kann keine Daten zurückgeben.) In C# hingegen ist eine Methode eine Methode. Es wird keine Unterscheidung danach gemacht, ob die Methode Daten liefert oder nicht. Sie müssen in C# jedoch den Datentyp der zurückzugebenden Daten spezifizieren oder void, wenn keine Daten zurückgegeben 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 zurückgibt: 6:
public static int Main() {
Sie können automatisch ein paar Schlüsse 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 können. Das Schlüsselwort static (bzw. Shared) ist hingegen etwas Neues. Um es zu verstehen, müssen wir wieder zurückgehen 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 – wäre eine Instanz des Auto-Konzepts oder der Klasse. Man kann also ein Objekt haben, aber viele Instanzen: einen Mercedes SLK, einen VW Käfer 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
Ein weiterer Blick auf Ihre Anwendung
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 können unterschiedliche Eigenschaften besitzen.
Das Gleiche lässt 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 darüber). Wenn Sie vor einer Methode das Schlüsselwort Shared oder static verwenden, bedeutet dies, dass die Methode oder Eigenschaft allen Instanzen dieses Objekts zur Verfügung steht und für alle Instanzen gleich ist. Beispielsweise sind alle Autos aus Blech gefertigt und der Einfachheit halber sagen wir, dass das Blech das gleiche für jedes Auto ist. Dies wäre eine static-Eigenschaft: Die Metallart ändert sich nicht von Auto zu Auto. Alle Autos nutzen außerdem das Konzept der Farbe gemeinsam, haben aber nicht alle die gleiche Farbe; dies wäre dann nicht static. Die Schlüsselwörter sind selbsterklärend: Einzelwerte oder einzelne Methoden können 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 nächsten ändern. Die Begriffe Shared und static sind im .NET Framework recht gebräuchlich. Daher ist es sehr wichtig, dass Sie ein solides Grundverständnis dafür erwerben. Für den Moment mag es genügen 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 ausgeführt. Verfügt Ihr Programm über keine Main-Methode, wird es einfach nichts tun (man bekommt eine Fehler-
55
Windows Forms-Anwendungen erstellen
meldung wohl schon lange, bevor man es ausführen will). Die Main-Methode wird auch als letztes ausgeführt. Wenn Ihr Code mit der Ausführung fertig ist, kehrt er stets zu dieser Methode zurück. Der Main-Methode kommt also eine hohe Bedeutung zu. Entweder lässt sich der gesamte Programmcode in der Main-Methode unterbringen oder Main kann andere Methoden aufrufen. Von Main aus können Sie bestimmen, welches Formular anzuzeigen ist (viele Anwendungen können mehr als ein Windows Form-Objekt enthalten), Variablen festlegen, die von der restlichen Anwendung verwendet werden, oder beliebige weitere Vorbereitungsschritte ausführen. In unserer Main-Methode wird eine einzige Codezeile ausgeführt: 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-Schlüsselwort erstellt eine Objektinstanz.) Das weist die Run-Methode an, Ihr Formular auf dem Bildschirm für den Dialog mit dem Benutzer anzuzeigen. Moment mal! Warum müssen wir eine Instanz der HelloWorld-Klasse an die Run-Methode übergeben? Dürfte das nicht zu einer Endlosschleife führen? Schließlich wird die MainMethode erneut ausgeführt, übergibt eine neue Instanz und so weiter. Nicht ganz. Um dies zu verstehen, müssen Sie zwischen einer Klasse und einer Anwendung unterscheiden. Wenn eine neue Instanz einer Klasse erzeugt wird, passiert nichts (es sei denn, man hätte 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 ausgeführt, wenn Ihre Anwendung gestartet wird, und danach nicht mehr. Anders ausgedrückt, wird Main bei jeder Anwendungsausführung gestartet, aber nicht immer dann, wenn eine Klasse erzeugt wird. Obwohl die Main-Methode ganz normal aussieht, führt 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
Ein weiterer Blick auf Ihre Anwendung
Abbildung 2.3: Eine Fehlermeldung erfolgt, wenn man versucht, die Main-Methode im Code auszuführen.
Obwohl nun Zeile 7 in Listing 2.1 Application.Run(New HelloWorld)
eine neue Instanz der Klasse HelloWorld erzeugt, wird die Main-Methode nicht erneut ausgeführt. Um die Trennung zwischen der HelloWorld-Klasse und der Main-Methode noch weiter zu unterstreichen, könnten Sie die Main-Methode in eine völlig andere Klasse stecken, und sie würde weiterhin funktionieren, wie Sie in Listing 2.3 sehen. Kurz und gut, Sie brauchen für eine Anwendung eine Main-Methode, die sich in einer Klasse befinden muss – doch diese Klasse können Sie willkürlich auswählen. Listing 2.3: Die Main-Methode lässt 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 völlig 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
Windows Forms-Anwendungen erstellen
Die Methode New (oder HelloWorld in C#) im Schlussteil von Listing 2.3 wird als Konstruktor bezeichnet. Das ist eine Methode, die ausgeführt wird, sobald eine neue Instanz einer Klasse erzeugt wird. Sie hat eine »Partner«-Methode namens Destruktor. Wir sprechen im nächsten 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: Application.Run(New HelloWorld)
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 Schlüsselwörter, 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 lässt sich leicht auf das umschließende 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
Ein weiterer Blick auf Ihre Anwendung
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 für 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, nämlich 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 können von bestimmten Variablen abhängen, 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 erhält man eine Fehlermeldung (schließlich lässt sich die Hintergrundfarbe nicht auf »nichts« setzen). Die Farbe-Eigenschaft würde im Konstruktor Ihrer übergeordneten Klasse initialisiert werden. Daher müssen Sie den Konstruktor der Basisklasse aufrufen, damit die Farbe-Eigenschaft eine Bedeutung erhält. Diese Abhängigkeit von Basisklassen besagt zweierlei. Erstens hängen 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 müssen, 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 Ausführen der Methode base() veranlassen: 'VB .NET Public Sub New() MyBase.New End Sub
59
Windows Forms-Anwendungen erstellen
'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 nächsten Abschnitt), ruft die CLR automatisch den Konstruktor der Basisklasse auf. Daher können Sie diese Zeilen weglassen.
Konstruktoren überladen Manchmal möchten Sie mehr als einen Konstruktor haben. Ein nützliches Beispiel dafür bestünde darin, dass Sie dem Benutzer erlauben möchten, auf mehr als eine Weise zu initialisieren: so etwa eine, die einen Wert für eine Variable erfordert, und eine, die keinen Wert erfordert. Sie können dies durch einen Vorgang namens Überladen erledigen. Zum besseren Verständnis 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 zunächst 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. Schließlich ruft dieser Konstruktor mit der base()-Methode den Konstruktor der Basisklasse auf. Soweit also nichts Neues.
60
Ein weiterer Blick auf Ihre Anwendung
In Zeile 10 stoßen wir auf etwas, das wie ein weiterer Konstruktor aussieht. Doch dieser übernimmt keine Parameter und verfügt ü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 Ausführung 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, könnte 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 könnte sogar seine eigenen Initialisierungsroutinen ausführen 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
Windows Forms-Anwendungen erstellen
In Zeile 11 verwenden Sie das Schlüsselwort 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 müssen. Wenn Sie keinen erzeugen, dann erzeugt VB .NET (oder C#) einen für Sie. Dieser automatisch generierte Konstruktor ruft nur den Konstruktor der Basisklasse auf. Konstruktoren sind nicht die einzigen Methoden, die Sie überladen können. Doch in VB .NET müssen Sie das Schlüsselwort Overloads vor jede Methode stellen, die überladen wird (Konstruktoren natürlich ausgenommen), und zwar vor dem Schlüsselwort Public.
Ein abschließender 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 Namensräume, die in Ihre Anwendung importiert werden. Die Mitglieder dieser Namensräume stehen Ihrer Anwendung in Form ihrer Kurznamen (also Form anstelle von System.Windows.Forms.Form) zur Verfügung. Zeile 4 deklariert Ihre Klasse und die Tatsache, dass sie von der Form-Klasse erbt, der Basisklasse für 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 für 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, können Sie erkennen, wie einfach dieser Quellcode war. Jetzt kennen Sie alle Komponenten, die für die Erstellung von Windows Forms notwendig sind, und können anfangen, Ihre eigene Windows Forms-Anwendung zu erstellen!
2.2
Das Kompilieren von Windows Forms
Der nächste 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ü auswählen. 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
Windows Forms-Anwendungen erstellen
Wählen Sie mit Hilfe dieses Dialogs eine Anzahl verschiedener Optionen sowohl für C# als auch für Visual Basic .NET. Klicken Sie in der linken Fensterhälfte auf VISUAL BASICPROJEKTE und in der rechten auf WINDOWS-ANWENDUNG. Wählen Sie einen passenden Namen und einen Speicherplatz für dieses Projekt und klicken Sie auf OK. 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).
PEN-EXPLORER
Zunächst finden Sie einen Ordner namens VERWEISE, der alle Namensräume anzeigt, die Ihre Anwendung verwenden wird; beachten Sie bitte, dass sich innerhalb des Ordners (auf das Plus-Zeichen klicken, um ihn aufzuklappen) bereits einige Namensräume befinden, die für Sie vorgegeben sind. Wenn Sie mit den Statements using oder Imports einen Namensraum haben wollen, der sich nicht hier befindet, müssen Sie den Namensraum hinzufügen, indem Sie mit der rechten Maustaste auf den Ordner klicken und VERWEIS HINZUFÜGEN auswählen. Daraufhin erscheint ein Dialogfenster, das Ihnen bei der Auswahl einer Assembly hilft. Die nächste ist die Datei AssemblyInfo.vb, die verwendet wird, um Informationen über Ihre Assembly bereitzustellen. Schließlich 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
Das Kompilieren von Windows Forms
machen. Beachten Sie auch, dass VS .NET etwas Code für 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 durchblättern, 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 löschen könnten, wenn Sie wollen.) Sie können nun Ihren Code an beliebiger Stelle zwischen den Zeilen Public Class und End Class einfügen. Sie können 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, wählen Sie im Menü ERSTELLEN den Befehl ERSTELLEN, um Ihre Anwendung zu erzeugen. Befinden sich Fehler im Code, werden sie in einem Ausgabe-Fenster angezeigt. Läuft alles erfolgreich ab, dann erzeugt VS .NET eine .EXE-Datei (der Dateiname hängt vom gewählten Projektnamen ab), die Sie wie jede beliebige Anwendung ausführen können. VS .NET enthält 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, können Sie Ihren Code mit dem jeweils nötigen Befehlszeilen-Compiler kompilieren. Das ist ein einfaches Programm, das einige Parameter übernimmt (darunter Ihre QuellcodeDatei) und eine kompilierte EXE-Datei »ausspuckt«. Der nötige Compilerbefehl ist entweder vbc.exe (für Quellcode in Visual Basic .NET) oder csc.exe (für Quellcode in C#). Für 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 führt die gebräuchlichen Befehlszeilenoptionen auf, die Sie nutzen können. Geben Sie vbc /? oder csc /? In der Befehlszeile ein, um alle Optionen anzusehen. Option
Beschreibung
@
Spezifiziert eine Textdatei, die die für den Befehl zu verwendenden Optionen enthält. Sie müssen einen Dateinamen angeben: @dateiname.
/bugreport
Erzeugt eine Fehlerberichtsdatei. Sie müssen einen Dateinamen angeben: /bugreport:dateiname.
Tabelle 2.2: Gebräuchliche Befehlszeilen-Optionen für den Compiler
65
Windows Forms-Anwendungen erstellen
Option
Beschreibung
/debug
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 enthält. Verwenden Sie /m als Kurzform.
/nologo
Unterdrückt das Microsoft-Logo.
/optioncompare
Verwenden Sie binary oder text, um anzugeben, wie alle Zeichenfolgenvergleiche in Ihrem Code durchgeführt werden sollen.
/optionexplicit
Erfordert die explizite Deklaration aller Variablen vor dem Einsatz. Verwenden Sie /optionexplicit+ oder /optionexplicit-.
/optionstrict
Erzwingt strikte Befolgung der Sprachsemantik. Verwenden Sie /optionstrict+ oder /optionstrict-.
/out
Gibt die Ausgabestandort und den Namen Ihrer kompilierten MSIL-Datei an.
/reference
Gibt zu referenzierende Assemblies in Ihrer Anwendung an (jene, die durch die Schlüsselwörter using oder Imports spezifiziert wurden). Verwenden Sie /r als Kurzform.
/target
Gibt den Typ der zu generierenden Ausgabedatei an. Verwenden Sie /t als Kurzform. Setzen Sie ein: 왘 /t:exe für eine ausführbare Konsolen-Anwendung; 왘
/t:library für eine DLL;
왘
/t:winexe für eine ausführbare Windows-Anwendung;
왘
/t:modul für ein Modul.
/win32icon
Gibt das zu verwendende Symbol (.ico-Datei) für das Anwendungssymbol an.
/win32resource
Gibt die zu verwendenden Ressourcen-Dateien (.res-Dateien) an.
Tabelle 2.2: Gebräuchliche Befehlszeilen-Optionen für den Compiler (Forts.)
Für 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 müssen Referenzen auf die Assemblies hinzufügen, die gebraucht werden (je nach den Namensräumen, die wir importiert
66
Eine vollständige Anwendung
haben). Wenn wir auf unseren Quellcode und die Tabelle 2.1 zurückblicken, sehen Sie, dass wir die Namensräume System und System.Windows.Forms verwenden. Sie befinden sich jeweils in den Assemblies system.dll und system.windows.forms.dll. Daher sieht unsere Befehlszeile schließlich 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 Verfügung: Sie ist die grundlegende Assembly für .NET. Aus diesem Grund brauchen Sie keinen expliziten Verweis dafür einzufügen. Von Ihrer Eingabeaufforderung aus veranlasst würde der Befehl die in Abbildung 2.6 sichtbare Ausgabe erzeugen.
Abbildung 2.6: Eine erfolgreiche Kompilierung führt zu diesem Ergebnis.
Welchen Weg Sie auch wählen, 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 können Sie leicht bestimmen, welche Referenzen Sie Ihrem VS .NET-Projekt hinzufügen müssen.
2.3
Eine vollständige Anwendung
Da Sie nun mit allen Bestandteilen einer Windows Forms-Anwendung ausgestattet sind, können Sie mit dem Aufbau einer Applikation beginnen, die etwas nützlicher 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
Windows Forms-Anwendungen erstellen
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 (möglicherweise an der gleichen Stelle),
쐽
eine oder mehrere Schaltflächen, die es ihm erlauben, mathematische Operationen auszuführen. Der Einfachheit halber beschränken wir uns hierbei auf die Addition.
Diese Komponenten werden von Windows Forms-Steuerelementen (Controls) bereitgestellt: interaktiven Elementen der Benutzeroberfläche (englisch User Interface, abgekürzt UI). Ab Tag 4 werden wir diese Steuerelemente genauer unter die Lupe nehmen, so dass wir uns hier nicht allzu lange damit aufhalten müssen. Zunächst wollen wir einmal den grundlegenden Rahmen für Ihre Anwendung erstellen. Dazu gehören alle Bestandteile, über die Sie heute etwas erfahren haben. Werfen Sie einen Blick auf Listing 2.7 (der komplette C#-Code wird später gezeigt). Listing 2.7: Das Fundament für 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 gehört.
68
Eine vollständige Anwendung
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 Kürze fügen wir den entsprechenden Code hinzu. In dieser Anwendung benötigen wir vier Windows Forms-Steuerelemente: zwei Textfelder (TextBox) für die Zahleneingabe, ein Bezeichnungsfeld (Label) für die Ergebnisanzeige und eine Schaltfläche (Button) für die Erledigung der Addition. Alle diese Steuerelemente gehören dem Namensraum System.Windows.Forms an, so dass Sie sie genau wie die FormKlasse verwenden können. 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 Schlüsselwort WithEvents bedeutet im Grunde, dass ein bestimmtes Steuerelement Aktionen ausführen kann. Listing 2.8 zeigt die vollständige 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
Windows Forms-Anwendungen erstellen
28: 29: 30: 31:
Me.Controls.Add(tbNumber1) Me.Controls.Add(tbNumber2) Me.Controls.Add(lblAnswer) End Sub
Fügen Sie diesen Code Ihrer Datei Listing 2.7.vb hinzu. Wir gehen auch hier noch nicht auf die Spezifika der einzelnen Steuerelemente ein, sondern kümmern 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 nötig sind, wo wir doch die Variablen schon zuvor deklariert haben. Der Grund: Im vorhergehenden Codestück 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 möglich, beide Schritte in einer einzigen Zeile auszuführen: 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«) für 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 für Point übernimmt wiederum zwei Parameter (eine x- und eine y-Koordinate). Man kann zwar Steuerelemente übereinander legen, aber das ist meist nicht sonderlich nützlich. Wir gehen morgen auf dieses Thema ein. Sie sollten bereits wissen, was Zeile 22 bewirkt: Sie setzt die Text-Eigenschaft der Schaltfläche auf den Wert »Addieren«. Erinnern Sie sich, dass die Text-Eigenschaft des Formulars eine Titelzeile festlegt. Die gleiche Eigenschaft für einen Button legt den Text fest, der darauf angezeigt wird. Zeile 23 bringt etwas Neues. Was sie genau bedeutet, erfahren wir an Tag 5. Für den Augenblick genügt es zu wissen, dass diese Zeile der CLR mitteilt, dass die Add-Methode (siehe Listing 2.9) ausgeführt werden soll, wenn diese Schaltfläche angeklickt wird.
70
Eine vollständige Anwendung
Die Zeilen 27-30 schließlich fügen Ihrem Formular die einzelnen Steuerelemente hinzu. Dieser Schritt ist notwendig, sonst würde die CLR nicht wissen, wo sie die Steuerelemente anzeigen soll. Sie würden nur im Speicher existieren und wertvolle Ressourcen belegen. Listing 2.9 zeigt Ihnen den Schlussteil unseres Codes: die Add-Methode. Fügen 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 für den Augenblick ignorieren, da sie für diese einfache Anwendung nicht von großem 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 könnte das Zeichen 9 als Zahl oder Zeichenfolge interpretiert werden, also müssen wir einen expliziten Datentyp dafür bereitstellen. Zeile 34 führt 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 gegenüber einer Ganzzahl verweigert). Das war's auch schon. Speichern Sie den zusammengefügten 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 ausführbare 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
Windows Forms-Anwendungen erstellen
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:
72
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);
Eine vollständige Anwendung
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 Schlüsselwort WithEvents aus Zeile 8 verschwunden ist. C# setzt eine andere Methode ein, um Objekte Aktionen ausführen 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 für 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 für 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 verfügt hingegen über alle nötigen 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
Windows Forms-Anwendungen erstellen
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, Namensräume, Assemblies und Methoden. Klassen sind Baupläne für Objekte. In einer Klasse definieren Sie die Eigenschaften, Methoden und Ereignisse, die ein Objektbenutzer verwenden kann. Diese offen gelegten – also für die Allgemeinheit bereitgestellten – Elemente werden mit Hilfe des Schlüsselworts public deklariert. Elemente, die Sie nicht offen legen möchten, erfordern das Schlüsselwort 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 verfügen ü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 erhält den gleichen Namen, allerdings mit einer vorangestellten Tilde. VB .NET hingegen verfügt über keine Destruktoren und der Konstruktor trägt immer den Namen New. Namensräume sind Gruppierungen von Klassen, und Assemblies sind physische Dateien, die Namensräume 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 gleichgültig, 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 zusammenfügt, indem Sie eine funktionierende Windows Forms-Anwendung erstellten. Mit diesem Wissen können Sie nun beinahe jeden Bestandteil einer Windows Forms-Anwendung identifizieren und Ihre eigene Anwendung erstellen.
2.5 F
Bedeutet der Import von Namensräumen zusätzlichen Verwaltungsaufwand und somit Speicherbedarf für meine Anwendung? A
74
Fragen und Antworten
Nicht unbedingt. Die Objekte in importierten Namensräumen werden nur bei Bedarf geladen und nicht alle auf einmal. Daher benötigt die Verwendung externer Objekte zwar schon etwas (Speicher-) Ressourcen, aber nur in recht geringem Umfang.
Workshop
2.6
Workshop
Dieser Workshop soll Ihnen helfen, sich besser an die heute behandelten Begriffe zu erinnern. Es hilft Ihnen sehr, die Antworten vollständig zu verstehen, bevor Sie weiterlesen. Die Antworten zu den Quizfragen und den Übungen finden Sie in Anhang A.
Quiz 1. Wie heißt die Basisklasse, von der alle anderen Klassen erben? 2. Was bewirken die Schlüsselwörter shared und static? 3. Wahr oder falsch? Man kann vorhandene Namensräume um eigene Klassen erweitern. 4. Wahr oder falsch? Die Main-Methode wird jedes Mal ausgeführt, wenn eine neue Instanz ihrer Klasse erzeugt wird. 5. Aus welchem Grund ist der folgende Code nicht ausreichend? Was muss außerdem 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. Fügen Sie weitere Schaltflächen hinzu, mit denen sich arithmetische Operationen ausführen lassen: Subtraktion, Multiplikation und Division. Versuchen Sie, die Anwendung sowohl in C# als auch in Visual Basic .NET zu erstellen. Verschönern Sie die Benutzeroberfläche Ihres Taschenrechners durch den großzügigen Gebrauch von Bezeichnungsfeldern (Label-Steuerelementen).
75
Mit Windows Forms arbeiten
3
Mit Windows Forms arbeiten
An den ersten zwei Tagen haben Sie eine ganze Menge über die Funktionsweise von Windows Forms-Anwendungen gelernt. Sie können jeden ihrer Bestandteile identifizieren und beschreiben, wissen, wie er mit .NET zusammenarbeitet, und Sie können auf die Verwendung derjenigen Teile schließen, die Ihnen noch unbekannt sind. Da Sie nun über das Grundlagenwissen verfügen, 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 Möglichkeiten, mit denen Sie Ihre Anwendungen anpassen können. 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 können die Farbe des Fensters (bzw. seines Rahmens) und seine Transparenz ändern, den Typ der Handgriffe und des Glases sowie die Vorhänge usw. Sie können praktisch alles, was Ihnen einfällt, mit Ihrem Fenster anstellen (vorausgesetzt, Sie verfügen über die entsprechenden Mittel). Das Gleiche gilt auch für Windows Forms. Aus der gestrigen Lektion wissen Sie, dass Sie die Titelzeile und die Größe eines Formulars ändern können. Das trifft auch auf die Titelleiste zu wie auch auf die Anordnung der Objekte im Formular, die Farbe, Transparenz und Sichtbarkeit, die Umrisslinien, die Schaltflächen 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 gewünschten Weise bearbeiten und anpassen lassen. Sie können quasi in den »Laden« der .NET-Klassenbibliothek gehen und sich ein Form-Objekt heraussuchen. Dann schneiden Sie es sich nach Ihren Wünschen zu.
78
Das objektorientierte Windows-Formular
Abbildung 3.1: Formulare können 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 einschließlich 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 darüber zu erfahren, insbesondere über die Methoden, die es Ihnen zur Verfügung stellt. Object ist die allgemeinste Klasse, die Sie in .NET verwenden können. 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 Funktionalität, die Sie durch das Deklarieren eines expliziten Datentyps gewinnen würden. So könnten Sie etwa einem Integer einen weiteren Integer hinzufügen, aber Sie können keine Objects aneinander hängen; ungeachtet Ihrer guten Absicht würde dies zu einer Fehlermeldung führen. Daher empfiehlt es sich, stets einen spezifischen Typ anzugeben, statt ein Object als Mädchen für alles zu verwenden. Standardmäßig müssen Ihre Anwendungen stets einen Typ für Ihre Variablen deklarieren. Das verhindert den falschen Einsatz der Variablen und verbessert das Leistungsverhalten. Sie können aber diese Sicherheitsfunktion durch Deaktivieren des Merkmals Option Strict abschalten. Um Näheres darüber zu erfahren, lesen Sie bitte in Tag 2 den Abschnitt »Das Kompilieren von Windows Forms«.
79
Mit Windows Forms arbeiten
Sie werden in der Windows Forms-Programmierung viele Funktionen kennen lernen, die für 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 zurückgegebenen Ergebnissen machen werden. Wird aber ein Object geliefert, können Sie die Ergebnisse durch Typumwandlung (Casting) in jeden gewünschten Datentyp transformieren. In C# wandeln Sie den Typ einer Variablen folgendermaßen um: myDataType myVariable; // Variable vom Typ myDataType deklarieren myVariable = (myDataType) ConfigurationSettings.GetConfig ("some setting"); // Einstellungen abrufen und in myDataType umwandeln
Das Objekt Object verfügt über fünf Hauptmethoden: Equals, ReferenceEquals, GetHashCode, GetType und ToString. Sie sind allesamt nützlich, 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 Verfügung stehen. Die Equals-Methode ist sowohl ein statisches als auch ein nicht-statisches Element. Sie können 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, während Zeile 9 Equals von der Object-Klasse selbst aus aufruft. Sehr häufig werden Sie zwei Objekte miteinander vergleichen müssen, so dass sich diese Methode als nützlich erweisen dürfte. 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 zusätzlich angegebenen Parameter verweisen sollte: {0} bedeutet also »Gib den nächsten Parameter aus«, {1} bedeutet »Gib den darauf folgenden Parameter aus« usw. Man könnte anstelle der numerischen Bezeichner auch einfach den Parameter selbst verwenden.
80
Das objektorientierte Windows-Formular
Um diese Methode verwenden zu können, müssen Sie Ihre Anwendung als reguläre ausführbare 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 lässt 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 können 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 zurück, weil a und c zwei unterschiedliche Objekte sind. Zeile 7 sieht aus, als würde 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 verfügen, wissen Sie, woher der Name ReferenceEquals kommt: Diese Methode vergleicht die Speicheradressen (bzw. Referenzen) der Variablen statt ihre Werte miteinander. In den meisten Fällen genügt die Equals-Methode, aber es ist hilfreich, auch über die ReferenceEquals-Methode verfügen zu können. Die nächsten drei Methoden sind alle nicht-statisch. GetHashCode liefert einen Hash-Code für Ihr Objekt. Ein Hash-Code ist eine numerische Darstellung eines Objekts und hat darüber hinaus keine Bedeutung an sich. Die Objekte A und B können unterschiedliche
81
Mit Windows Forms arbeiten
Objekte sein, aber den gleichen Hash-Code generieren, wie etwa in Zeile 7. Sie können diesen Vorgang nicht umkehren und von der Zahl 7 auf ein Objekt schließen; Hashing ist ein Einbahnstraßen-Mechanismus. Wie ihr Name schon sagt, liefert die Methode GetType einfach nur den spezifischen Datentyp eines Objekts. Das ist sehr nützlich, 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 Codestück wird System.String liefern, den Datentyp der Variablen a. Beachten Sie, dass diese Methode einen Datentyp zurückgibt, nicht etwa nur den Namen des Typs: Sie liefert einen Typ und keine Zeichenfolge. Diese Methode wird häufig 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 prüft, 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 gebräuchlichste Methode zu sprechen: ToString liefert die Zeichenfolgendarstellung eines Variablentyps. Das folgende Codefragment würde 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 für eine bestimmte Klasse überschrieben. Der string-Datentyp überschreibt beispielsweise ToString, so dass er den tatsächlichen 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 verfügt über genau 101 Eigenschaften, die es Ihnen gestatten, beinahe jeden Aspekt des Formulars zu steuern. Da dies zu viele Eigenschaften für nur einen Tag sind, lassen Sie uns nur auf ein paar der nützlicheren Aspekte einen Blick werfen, gruppiert nach Funktion.
82
Das objektorientierte Windows-Formular
Größe und Position steuern Ihnen sind bereits zwei Möglichkeiten, die Formulargröße festzulegen, bekannt: die Eigenschaften Width und Height (Breite bzw. Höhe). Diese Eigenschaften übernehmen lediglich Zahlenwerte, um die Formulargröße in Pixelwerten festzulegen. Zum Beispiel: form1.Width form1.Height = 200
Sie können die Größe 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 können die Größe auch abhängig von der Bildschirmgröße des Benutzers festlegen, und zwar, indem Sie das Screen-Objekt verwenden. Listing 3.3 zeigt dafür ein Beispiel. Listing 3.3: Das Festlegen der Formularhöhe abhängig von der Bildschirmgröße (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 dürfte Ihnen mittlerweile vertraut sein, daher betrachten wir lediglich Zeile 7 etwas genauer. Die Methode GetWorkingArea des ScreenObjekts liefert ein Rectangle-Objekt, das für den Benutzerbildschirm steht. Sie übergeben das aktuelle Formularobjekt (mit Hilfe des Me-Schlüsselworts), um der CLR mitzuteilen, welchen Bildschirm sie verwenden soll (nur für 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
Mit Windows Forms arbeiten
Höhe und Breite des Bildschirms beschreiben. Danach teilen wir den Höhe-Wert durch 2. Kompilieren Sie diese Anwendung und führen Sie sie aus. Beachten Sie, dass das Fenster jetzt die halbe Höhe Ihres Bildschirms beansprucht. Um festzulegen, wo das Fenster sich öffnet, können 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 können, die sich weit außerhalb 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 Funktionalität: Form1.DesktopLocation = New Point(100,300) Form1.Location = New Point(100,300) Location ist eine Eigenschaft, die von Control, der Urgroßelternklasse 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 für das Formular einfach der Benutzerbildschirm. Sie könnten die Location-Eigenschaft für jedes beliebige Objekt verwenden, das vom Control-Objekt erbt, etwa für 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 für das Form-Objekt. Der Einheitlichkeit halber werden wir ab jetzt die Eigenschaft Location verwenden. Daher brauchen Sie nur eine Eigenschaft für 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 können. Die Eigenschaft Font legt die Schriftart fest, die im Formular benutzt wird, es sei denn, die Font-Eigenschaft eines Steuerelements hätte Priorität. 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
Das objektorientierte Windows-Formular
Möglichkeiten, 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 enthält. Der zweite Parameter besteht in der Größe der Schriftart (in der Maßeinheit »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 müssen 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 müssen 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 müssen, um sie verwenden zu können. 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 können. Eine weitere Bildeigenschaft, die Sie anpassen können, 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
Mit Windows Forms arbeiten
Abbildung 3.3: Sie können eine Grafik dazu verwenden, den Hintergrund Ihres Formulars damit zu kacheln.
Sie müssen eine neue Instanz des Icon-Objekts erzeugen, wobei Sie einen gültigen Pfad zu einer Grafik angeben. Die Grafik, die Sie auswählen, muss eine Icon-Datei (.ico) sein, sonst erzeugt Ihre Anwendung eine Fehlermeldung. Das Bild des Mauszeigers lässt sich durch die Cursor-Eigenschaft steuern: Me.Cursor = Cursors.Hand
Das Cursors-Objekt verfügt über eine Menge Eigenschaften für den Standardsatz an Windows-Mauszeigern, darunter Arrow, IBeam, WaitCursor und Help. In der .NET-Dokumentation finden Sie weitere Mauszeiger. Sie können 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 unterstützt. 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 Schaltfläche in der Taskleiste). Der Standardwert lautet true (wahr). Unter bestimmten Gegebenheiten möchten Sie diese Einstellung vielleicht ändern, um einen Anwender daran zu hindern, ein Formular auszuwählen. Wenn Sie etwa einen so genannten »Splash Screen« erzeugen, der etwa das Logo Ihrer Firma anzeigt, wollen Sie wahrscheinlich nicht, dass der Benutzer es auswählt (es verschwindet ja auch sofort). Setzen Sie dann einfach die Eigenschaft ShownInTaskBar auf false, und der Benutzer kann es nicht mehr aus der Taskleiste auswählen. Die Eigenschaft FormBorderStyle legt das Aussehen der Umrisslinie einer Windows FormsFormulars fest. Hauptsächlich ändern Sie diese Eigenschaft, um die Größenänderung 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
Das objektorientierte Windows-Formular
Die Aufzählung für FormBorderStyle (nicht zu verwechseln mit der Eigenschaft Form.FormBorderStyle) führt sieben verschiedene Typen von Umrisslinien auf, wie in Tabelle 3.1 zu sehen. (Eine Aufzählung 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
Beschreibung
Fixed3D
Nicht skalierbar. Dreidimensionale Umrisslinie.
FixedDialog
Nicht skalierbar. Dicke Umrisslinie.
FixedSingle
Nicht skalierbar. Dünne Umrisslinie.
FixedToolWindow
Formular mit schmalerer Titelleiste. Nützlich für die Anzeige von QuickInfos und Hilfefenstern. Nicht skalierbar. Enthält keine Maximieren- oder Minimieren-Schaltflächen.
None
Nicht skalierbar. Keine Umrisslinie.
Sizable
Skalierbar. Standardstil.
SizableToolWindow
Formular mit schmalerer Titelleiste. Nützlich für die Anzeige von QuickInfos und Hilfefenstern. Skalierbar. Enthält keine Maximieren- oder MinimierenSchaltflächen.
Tabelle 3.1: Stile für FormBorderStyle
87
Mit Windows Forms arbeiten
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 für 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 geöffnet lassen wollen, sie aber nicht mit der Benutzeroberfläche interferieren soll. Standardmäßig ist ein solches Formular nicht sichtbar. Um ein Formular teilweise sichtbar zu machen (mit anderen Worten: transparent), müssen Sie die Eigenschaft Visible auf true (wahr) setzen und die Eigenschaft Opacity (Undurchsichtigkeit) verwenden. Diese Eigenschaft übernimmt einen Wert zwischen 1 (= völlig undurchsichtig, also völlig sichtbar) und 0,0 (= unsichtbar bzw. völlig durchsichtig). Um ein paar wirklich interessante Transparenztechniken vorzuführen, können Sie die Eigenschaft TransparencyKey so einstellen, dass eine bestimmte Farbe durchsichtig sein soll. Der folgende Code macht beispielsweise alle grauen Flächen im Formular unsichtbar, während alles andere undurchsichtig bleibt: Form1.TransparencyKey = Color.Gray
Wenn Sie nun auch noch die BackColor des Formulars auf Grau setzen, erhalten Sie schließlich 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.
Interaktivität steuern Wenn Sie eine Windows-Anwendung betrachten, dann sehen Sie an deren Fenstern die Standardmerkmale: In der oberen rechten Ecke befinden sich Schaltflächen für das Minimieren und Maximieren sowie das Schließen des Fensters, manchmal auch eine HILFESchaltfläche. Rechts unten befindet sich oft ein Anfasser, damit man mit der Maus die Fenstergröße verändern kann. Diese Systemmenüfelder sehen Sie in Abbildung 3.6.
88
Das objektorientierte Windows-Formular
Jedes Systemmenüfeld lässt sich mit Hilfe der folgenden Eigenschaften in Ihrem Formular verstecken oder anzeigen: 쐽
MaximizeBox
쐽
MinimizeBox
쐽
HelpButton
쐽
ControlBox
쐽
SizeGripStyle
Abbildung 3.6: Diese Systemmenüfelder gehören zu den Standardmerkmalen von Windows.
Die ersten vier Eigenschaften nehmen lediglich den Wert true oder false an. ControlBox legt fest, ob die vorhergehenden Schaltflächen überhaupt angezeigt werden sollen. Seien Sie hier jedoch vorsichtig: Wenn Sie ControlBox auf false setzen, könnte es sein, dass Sie Ihre Anwendung nicht mehr schließen können!
Die HILFE-Schaltfläche taucht nur auf, wenn die MINIMIEREN- und MAXIMIEREN-Schaltflächen nicht sichtbar sind. Dies ist ein Standardmerkmal von .NET.
Die Eigenschaft SizeGripStyle nimmt einen SizeGripStyle-Aufzählungswert an: Auto, Hide oder Show. Auto zeigt den Skalierungsanfasser an, falls nötig (also abhängig vom FormBorderStyle), während Hide und Show die Größenziehpunkge (Skalierungsanfasser) jeweils verbergen oder zeigen. Mit einer Anwendung sind häufig zwei besondere Tasten verbunden: (¢) und (ESC). Viele Anwendungen werden geschlossen, wenn Sie die (ESC)-Taste drücken. Sie können diese Funktionen mit den Eigenschaften AcceptButton und CancelButton steuern. Listing 3.4 zeigt in C# ein Beispiel, wie man diese Eigenschaften verwendet.
89
Mit Windows Forms arbeiten
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:
90
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 für 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 gedrückt"; } public void CancelIt(Object Sender, EventArgs e) { lblMessage.Text = "Der Abbrechen-Button wurde gedrückt"; } } public class StartForm { public static void Main() { Application.Run(new Listing34());
Das objektorientierte Windows-Formular
45: 46: 47: 48:
} } }
Ein Großteil dieses Codes dürfte bereits vertraut aussehen, daher können wir das meiste davon überfliegen. Die Zeilen 1 bis 3 importieren die notwendigen Namensräume. Zeile 5 deklariert den Namensraum, zu dem diese Anwendung gehört; gemäß unserem Bezeichnungsschema heißt 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 außerhalb 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 Großteil des Geschehens statt. Der Code in den Zeilen 13 bis 22 setzt einfach ein paar Eigenschaften für unsere Steuerelemente. Beachten Sie insbesondere die Zeilen 18 und 22, die auf Methoden zeigen, die ausgeführt werden, sobald eine der beiden Schaltflächen 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 fügen dem Formular die Steuerelemente hinzu. Die Zeilen 24 und 25 legen die Eigenschaften AcceptButton und CancelButton für die jeweilige OK- oder Abbrechen-Schaltfläche fest. Im Wesentlichen bewirkt das Anklicken der OK- oder Abbrechen-Schaltfläche das Gleiche wie das Drücken der (¢)- oder der (ESC)-Taste. Schließlich 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 Drücken der (ESC)-Taste wird in der Schaltfläche AcceptButton und Abbildung 3.7 gezeigt. Erhält die Abbrechen-Schaltfläche im Formular den Fokus, veranlasst das Drücken der (¢)-Taste das »Anklicken« oder Niederdrücken dieser Schaltfläche und folglich das Auslösen der CancelIt-Methode. Mit anderen Worten: Die Schaltfläche erhält die Eingabe noch vor dem eigentlichen Formular. Leider gibt es für diese missliche Tatsache keinen einfachen Ausweg. Manche Steuerelemente, wie etwa die Button- und RichTextBox-Steuerelemente, behandeln das Drücken der (¢)-Taste automatisch, wenn sie den Fokus haben, also noch bevor irgendetwas anderes ausgeführt 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 Ausführung der CancelIt-Methode.
91
Mit Windows Forms arbeiten
Falls es Sie interessiert, können 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 müssen, beachten Sie bitte, dass diese Buttons nicht unbedingt für den Benutzer zu sehen sein müssen. Indem man die Visible-Eigenschaft auf false setzt, macht man die Schaltflächen unsichtbar, ohne ihre Funktionalität zu verlieren. Die Eigenschaft AllowDrop schließlich 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« lässt. Diese Eigenschaft kann einen true- oder false-Wert annehmen. Wie Sie Ihr Formular dazu bringen, etwas bei einem solchen Ereignis auszulösen, besprechen wir heute später im Abschnitt »Ereignisse im Formular«.
Abbildung 3.7: Das Drücken der (ESC)-Taste hat die gleiche Wirkung wie das Anklicken der ABBRECHEN-Schaltfläche.
Um eine vollständige Liste der Eigenschaften des Form-Objekts nachzuschlagen, lesen Sie Anhang B »Windows Forms-Steuerelemente«.
Formular-Methoden Das Form-Objekt verfügt 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 Verfügung 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 verändern das Formular selbst nicht – etwa das Entfernen aus dem Speicher oder der Aufruf anderer Funktionen –, sondern nur, ob der Benutzer es sehen kann.
92
Das objektorientierte Windows-Formular
Die Close-Methode jedoch entsorgt ein Formular (und seine Steuerelemente) vollständig durch das Entfernen aus dem Speicher. Setzen Sie diese Methode ein, wenn Sie Ihre Anwendung schließen wollen oder wenn Sie einfach kein Formular mehr brauchen. Da Windows ja ein Multitasking-Betriebssystem ist, dürfen viele Fenster gleichzeitig geöffnet sein. Jedes Fenster muss um die Aufmerksamkeit des Benutzers wetteifern. Das FormObjekt verfügt über einige Methoden, die Ihnen helfen, diese Schwierigkeit zu bewältigen. 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 gebräuchlichste Verwendung findet sich bei Instant-Messaging-Anwendungen. Hat Ihnen jemand eine Instant Message (IM) gesendet, während Sie gerade in einer anderen Anwendung arbeiten, öffnet sich plötzlich 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 nützlich, 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 häufig benutzt, ist aber für alle Fälle vorhanden. Sie können die Eigenschaft TopMost auf true setzen, um dafür zu sorgen, dass Ihr Formular immer im Vordergrund steht. Besonders nützlich ist dieses Leistungsmerkmal, wenn Alarm- oder Fehlermeldungen ausgegeben werden sollen. Schließlich funktioniert die Refresh-Methode ähnlich wie die Schaltfläche AKTUALISIEREN in Ihrem Web-Browser: Sie zeichnet alles im Formular neu und aktualisiert mitunter sogar dessen Inhalte. Wir werden näher auf diese Methode zu sprechen kommen, wenn wir GDI+ an Tag 13 durchnehmen.
Eigenschaften zurücksetzen Das Form-Objekt verfügt über eine Reihe von Reset-Methoden, mit denen Sie geänderte Eigenschaften auf ihre Vorgabewerte zurücksetzen können. Alle diese Methoden folgen dem Bezeichnungsschema ResetEigenschaft. Einige der gebräuchlicheren sind: 쐽
ResetBackColor
쐽
ResetCursor
93
Mit Windows Forms arbeiten
쐽
ResetFont
쐽
ResetForeColor
쐽
ResetText
Diese Methoden sind sehr nützlich, wenn man etwas geändert hat und alles wieder rückgängig machen muss, man aber nicht weiß oder sich nicht darum kümmert, welches jeweils der ursprüngliche Wert war. Wenn der Benutzer beispielsweise in einem Textprogramm mehrmals die Schriftart ändert, aber dann wieder zu den Standardwerten zurückkehren möchte, könnte man ResetFont einsetzen.
3.2
Ereignisbehandlung
Ein Ereignis (event) ist etwas, das als Ergebnis einer Aktion oder Aktivität passiert. Greifen Sie auf die Auto-Analogie zurück und stellen Sie sich bitte vor, dass Sie auf die Bremse treten (eine Aktion). Der Wagen hält an (ein Ereignis). Treten Sie auf das Gaspedal (Aktion), fährt der Wagen wieder an (Ereignis). Ein Ereignis ist stets die Folge einer Aktion, die stattgefunden hat. Auch Windows Forms verfügen über Ereignisse, obwohl so manches davon nicht besonders augenfällig ist. Öffnen und Schließen 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 verlässt, findet ein weiteres Ereignis statt. Ohne Ereignisse wären Windows Forms ziemlich fade, denn sie würden nie etwas bewirken, ganz gleich, wie sehr der Anwender das auch erzwingen wollte.
Die Nachrichtenschleife Ereignisse eignen sich in wunderbarer Weise dafür, 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 zunächst die ereignisgesteuerte Anwendung vor. Unter »ereignisgesteuert« versteht man, dass die Anwendung auf Ereignisse reagiert, die auf Benutzeraktionen hin erfolgen. Ohne diese Ereignisse würde die Anwendung in der Tat überhaupt nichts tun. Die Ereignisse treiben die Anwendung quasi an. In diesem Modell ist die Anwendung untätig und wartet darauf, dass etwas passiert. Sie verwendet Ereignisse als ihr Stichwort, eine Aktion auszuführen. Ein Benutzer drückt beispielsweise eine Taste. Die Anwendung merkt, dass ein Ereignis stattgefunden hat
94
Ereignisbehandlung
(Tastendruck), führt eine Aktion aus, um das entsprechende Zeichen anzuzeigen, und wartet dann auf das nächste Ereignis. Eine Anwendung, die nicht ereignisgesteuert ist, gestattet dem Benutzer nicht die gewünschte 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 wäre. Sobald Sie die Anwendung gestartet haben, holt sie zwei Werte aus den Textfeldern, führt 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 geändert hat, da er keine Ereignisse erkennt. Jedes Mal, wenn Sie die Zahlen ändern, um einen anderen Wert zu berechnen, müssen Sie zuerst die Zahlen ändern und dann die Anwendung erneut ausführen. Klassische Active Server Pages (also ASP als Vorgänger von ASP.NET) funktionieren auf diese Weise. Eine ASP-Anwendung wird ausgeführt, sobald ein Benutzer die Seite von seinem Browser aus anfordert, dann gibt sie den nötigen HTML-Code aus und hält an. Um das, was danach passiert, kümmern 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 häufig reaktionsfähiger und interaktiv. Da aber Interaktion eine zwingende Eigenschaft einer jeden Windows-basierten Anwendung ist, werden alle Ihre Programme das ereignisgesteuerte Modell verwenden.
95
Mit Windows Forms arbeiten
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. Während dieser Schleife tut die Anwendung nichts, außer auf eine Benutzereingabe zu warten (die Spanne der Nicht-Aktivität wird Leerlauf bzw. idling genannt). Sobald eine Eingabe entgegengenommen wird, verrichtet die Anwendung ihr Werk und fällt dann wieder zurück 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 darüber, zu welcher Anwendung das Ereignis gehört, 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 drücken, findet ein Ereignis statt, eine Methode wird ausgeführt (um das Zeichen am Bildschirm anzuzeigen), dann fällt Word wieder in die Nachrichtenschleife zurück, um weiteren Input abzuwarten. Jedes Mal wenn Sie eine Taste drücken, hält die Nachrichtenschleife für einen Augenblick an, um etwas zu verarbeiten, und setzt dann das Warten fort. Abbildung 3.9 illustriert diesen Zyklus. Windows Forms sind üblicherweise die primäre Benutzeroberfläche 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 fürs Erste einen Blick auf einige der 71 Ereignisse des Form-Objekts werfen.
Die Ausführung steuern Um Ihnen als Entwickler die größtmögliche Kontrolle über Ihre Anwendung zu verleihen, werden manche Ereignisse sowohl vor als auch nach dem Eintreten einer Aktion gestartet. Wenn Sie beispielsweise Ihr Formular schließen, findet das Closing-Ereignis direkt vor dem Schließen des Formulars statt, das Closed-Ereignis direkt danach. Diese Arten von Ereignisnamen folgen stets den Regeln für das Partizip Präsens bzw. Partizip Perfekt, daher »Closing« (»sich gerade schließend«) und »Closed« (also »geschlossen«). Nicht alle Ereignisse treten in solchen Paaren auf. Wenn Sie jedoch einen –ing-Ereignisnamen lesen, können Sie sicher sein, dass auch ein –ed-Ereignis folgt; das gilt aber nicht umgekehrt. Was ist der Grund für die Methode, zwei Ereignisse pro Aktion zu verwenden? Stellen Sie sich bitte einen großen Gemüseladen vor, der um 20:00 Uhr schließt. Fünf Minuten, bevor der Laden eigentlich zumacht, wird über die Lautsprecheranlage eine Ansage zu hören sein, die die Kunden bittet, dass sie sich zu den Kassen begeben möchten. Dieses Vor-Schließen-Ereignis dient dazu, die Kunden zu warnen, dass etwas geschehen wird. Um 20:00 Uhr schließt der Laden, und alle Kunden werden zum Verlassen des Ladens aufgefordert, alle Türen werden verriegelt. Diese zweistufige Vorgehensweise erlaubt es sowohl dem Ladeninhaber oder Filialleiter als auch den Kunden, sich auf das tatsächliche eintretende Ereignis des Ladenschlusses vorzubereiten. Bei Windows-Anwendungen verhält es sich ähnlich. Wenn z.B. ein Benutzer eine große Zahl von Änderungen an einem Word-Dokument vornimmt, dann die Anwendung mit Hilfe des SCHLIEßEN-Steuerelements schließt, aber das Speichern seines Dokuments vergisst, was würde dann geschehen? Wenn man auf das Closed-Ereignis warten würde, bevor man etwas unternähme, wäre es bereits zu spät: Das Dokument wäre schon geschlossen worden, und alle Änderungen wären verloren. In .NET jedoch wird das Closing-Ereignis ausgelöst, bevor das eigentliche Schließen des Dokuments eintritt. In diesem Fall können 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
Mit Windows Forms arbeiten
wird das Closed-Ereignis ausgelöst. Danach können Sie jede Verarbeitungsmöglichkeit nutzen, die Sie benötigen (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 Programmausführung 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 für 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 schließt 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 verfügt über Objekte, die Ereignisse betreffen, die man weiter unten im Code benötigt. 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) auszuführen, wenn die Closing- und Closed-Ereignisse jeweils ausgelöst werden. Wir springen in Zeile 15 zur Closing-Methode, die ausgeführt wird, sobald das Closing-Ereignis ausgelöst worden ist und sich das Formular tatsächlich schließt. Sehen Sie sich zunächst 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 für Ereignisse gilt, insbesondere für Closing-Ereignisse. Es verfügt über eine besondere Eigenschaft namens Cancel, um damit den Vorgang – in diesem Fall das Schließen des Formulars – zu unterbrechen, falls dies nötig sein sollte (wie etwa im Beispiel des Textprogramms). Wenn Sie festlegen, dass das Schließen 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 Schließen innehalten und in die Nachrichtenschleife zurückkehren. 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 präsentiert 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 hätten importieren können.) In Zeile 19 beginnt die Methode ClosedMsg. Sie wird ausgeführt, nachdem das Formular sich geschlossen hat. Beachten Sie, dass sie als zweiten Parameter ein EventArgs-Objekt statt CancelEventArgs übernimmt. Den Grund dafür besprechen wir an Tag 5. Diese Methode wiederum ruft die MsgBox-Funktion auf, um eine weitere Meldung anzuzeigen, die den Benutzer darüber 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
Mit Windows Forms arbeiten
neuen Assemblies referenzieren müssen. Abbildung 3.10 zeigt die Ausgabe, nachdem das Steuerelement zum Schließen 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
Beschreibung
Closed
Erfolgt beim Schließen eines Formulars
InputLanguage- Erfolgt, sobald der Benutzer die Sprache des Formulars zu ändern versucht Changed Validated
Erfolgt, sobald die Eingabe eines Steuerelements auf Gültigkeit geprüft 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 ausgelöst, sobald sich ein Formular schließt. Es gibt weiter ein Load-Ereignis, das sofort ausgelöst wird, noch bevor ein Formular zum ersten Mal angezeigt wird. Der Ereignishandler für dieses Ereignis ist häufig eine geeignete Stelle, um Komponenten für 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 erhält und zur aktiven Anwendung wird – es korrespondiert mit der Activate-Methode. Dementsprechend wird
100
Ereignisbehandlung
Deactivate ausgelöst, sobald Ihr Formular deaktiviert wird, also den Fokus verliert, oder wenn eine andere Anwendung die aktive wird.
Maus- und Tastaturereignisse Maus- und Tastaturaktionen gehören zu den wichtigsten Arten von Ereignissen. Schließlich sind dies wesentliche Formen von Benutzereingaben. Daher gibt es eine ganze Reihe von Ereignissen, die mit diesen zwei Eingabegeräten verbunden sind. Lassen Sie uns mit Tastaturereignissen anfangen. Zuerst an der Reihe ist das KeyPress-Ereignis. Es erfolgt jedes Mal, wenn eine Taste gedrückt wird, ganz gleich welche (wir sehen gleich noch, wie man feststellt, welche Taste es war). Falls dieses Ereignis nicht genügend Kontrollmöglichkeiten eröffnet, gibt es noch die Ereignisse KeyDown und KeyUp, die jeweils ausgelöst werden, sobald eine Taste heruntergedrückt und dann wieder losgelassen wird. Diese Ereignisse liefern zusätzliche Informationen (etwa welche Taste gedrückt wurde), die Sie in Ihrer Anwendung nutzen können. Ihre Ereignishandler, also diejenigen Methoden, die ausgeführt werden, sobald das Ereignis ausgelöst 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# müssen Sie jedoch die spezialisierten Handler berücksichtigen. Statt EventHandler in Zeile 18 von Listing 3.4 wie gewohnt zu verwenden 18:
btAccept.Click += new EventHandler(this.AcceptIt);
müssen 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 ausgelöst 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
Mit Windows Forms arbeiten
schaft auf true setzen, es sei denn, Sie wünschen explizit, dass das Betriebssystem diesen speziellen Tastendruck verarbeitet (wenn Sie etwa die Taste (Druck) nicht handhaben müssen, leiten Sie dies an das Betriebssystem weiter). Die Eigenschaft KeyChar liefert einfach die Taste, die gedrückt wurde. Listing 3.6 zeigt ein Beispiel in VB .NET. Listing 3.6: Verarbeitung von Tastenbetätigungen 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 stoßen 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 gedrückte 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 große A gedrückt wurde ((ª) + (a)). Beachten Sie jedoch, dass lediglich Buchstaben, Zahlen und die (¢)-Taste das KeyPressEreignis auslösen. Um andere Tasten wie etwa (Strg), (Alt) und die Funktionstasten (F1) bis (F12) zu handhaben, müssen 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, führt jeder Tastendruck die KeyPressed-Methode aus.
Das Objekt KeyEventArgs verfügt über mehrere Eigenschaften, die sich als nützlich erweisen, um festzustellen, welche Taste gedrückt wurde: 쐽
Alt: Wahr- oder Falsch-Wert, der anzeigt, ob die (Alt)-Taste gedrückt wurde
쐽
Control: zeigt an, ob die (Strg)-Taste gedrückt wurde
쐽
Handled: entspricht der Handled-Eigenschaft des Objekts KeyPressEventArgs
쐽
KeyCode: der Tastaturcode für die gedrückte Taste
쐽
KeyData: die Tastendaten für die gedrückte Taste
쐽
KeyValue: der Tastaturcode für die gedrückte Taste
쐽
Modifiers: gibt Flags zurück, die anzeigen, welche Tasten und Zusatztasten (wie etwa (ª), (Strg) oder (Alt)) gedrückt wurden
쐽
Shift: zeigt an, ob die (ª)-Taste gedrückt 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
Mit Windows Forms arbeiten
schiedlich bei Zusatztasten (eine vollständige Referenz finden Sie bei der Keys- bzw. Tasten-Aufzählung 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 drückt 5. MouseUp: wenn man die Maustaste wieder löst 6. MouseLeave: wenn der Mauszeiger das Formular wieder verlässt (sich vom Formular wegbewegt) Die Ereignisse MouseEnter, MouseHover und MouseLeave liefern keine besonderen Informationen und verwenden daher den standardmäßigen 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 gedrückt wurde usw. Die Eigenschaften sind in Tabelle 3.3 zusammengefasst. Eigenschaft
Beschreibung
Button
Holt die Information ein, welche Maustaste gedrückt wurde (MouseButtons.Left, MouseButtons.Middle, MouseButtons.None, MouseButtons.Right, MouseButtons.XButton1 oder MouseButtons.XButton2)
Clicks
Die Anzahl von Mausklicks (ein Integerwert)
Delta
Die Anzahl von Drehungseinheiten, um die sich das Mausrad bewegt hat
X
Die x-Bildschirmkoordinate des Mauszeigers
Y
Die y-Bildschirmkoordinate des Mauszeigers
Tabelle 3.3: Eigenschaften von MouseEventHandler
104
Ereignisbehandlung
Drag & Drop Das mit Windows eingeführte Merkmal des Drag & Drop, also des Klickziehens, erlaubt es dem Anwender, eine Art Abkürzung 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 geöffnet 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 für Drag & Drop fit zu machen. Als Erstes müssen Sie die Eigenschaft DragDrop des Formulars auf true setzen und dann den Code für 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 können. Wenn Sie etwa versuchen, eine Datei, die nur gelesen werden darf, zu ziehen und abzulegen, können Sie diese Datei nur kopieren, nicht aber verschieben. Die Aktionen werden durch die DragDropEffects-Aufzählung 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 aufgeführten DragDropEffects-Werte. Wenn der Benutzer etwa eine Datei zieht, während er die (Strg)-Taste gedrückt hält, wird versucht, eine Kopieroperation durchzuführen, und die Effect-Eigenschaft wird DragDropEffects.Copy anzeigen. Die Data-Eigenschaft enthält 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. (Nähere Informationen hierzu finden Sie in der Dokumentation zum .NET Framework.) Die Eigenschaft KeyState verrät Ihnen, ob jeweils die Taste (ª), (Strg) oder (Alt) gedrückt ist, genau wie die Alt-, Control- und Shift-Eigenschaften der KeyUp- und KeyDownEreignisse. Die X- und Y-Eigenschaften schließlich sind die gleichen wie jene für Mausereignisse. Sie zeigen an, an welcher Stelle (im Koordinatensystem) sich zum Zeitpunkt des Ereignisses ein Element befand.
105
Mit Windows Forms arbeiten
Ä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 ausgelöst. Meist werden diese Ereignisarten für Validierungsroutinen verwendet. Wenn Sie etwa die Zahl der in Ihrem Formular verwendbaren Schriftarten begrenzen wollen, könnten Sie einen Handler für das FontChanged-Ereignis erzeugen, der ungültige Benutzerauswahlen überschreibt. Ich werde hier nicht alle diese Ereignisse aufführen. Sie können feststellen, welche das sind, indem Sie einfach das Wort »Changed« (geändert) an die jeweiligen Eigenschaften anhängen, über die Sie heute gelesen haben: TextChanged, CursorChanged, VisibleChanged usw. Alle diese Methoden verwenden Handler vom Typ EventHandler.
3.3
Zusammenfassung
Das Basisobjekt für alle anderen Objekte ist im .NET Framework – nomen est omen – das Object-Objekt. Da es so allgemeingültig gefasst ist, wird es an verschiedenen Stellen verwendet, an denen ein spezialisiertes Objekt entweder nicht gebraucht wird oder sich nicht genauer bestimmen lässt. Object verfügt über fünf 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 für weitere Bestandteile der Benutzerschnittstelle bereit und enthält selbst eine reiche Palette an Funktionen. Das Form-Objekt besitzt 101 Eigenschaften, mit denen Sie praktisch jeden einzelnen Aspekt der Benutzeroberfläche steuern können. Sie können Ihr Formular mit Hilfe der Opacity-Eigenschaft transparent machen, es mit der Eigenschaft FormBorderStyle nichtskalierbar machen, und Sie können die Art und Weise der Benutzerinteraktion mit Hilfe der Eigenschaften MaximizeBox, MinimizeBox, HelpButton, SizeGripStyle und ControlBox kontrollieren. Form verfügt zudem über zahlreiche Methoden wie etwa BringToFront oder Focus, die Sie zur Steuerung der Bildschirmanzeige ausführen können.
Sie haben etwas über Ereignisse und die Nachrichtenschleife erfahren, die einer Anwendung das Untätigsein erlaubt, bis ein Benutzer eine Eingabe vornimmt. Das Form-Objekt verfügt über Ereignisse, die anlässlich zahlreicher Benutzeraktivitäten ausgelöst werden, darunter Mausklick, Tastendruck und Drag & Drop.
106
Fragen und Antworten
3.4 F
Fragen und Antworten
Kann ich von einem selbst erstellten Formular erben? Wie werden dabei Eigenschaften behandelt? A
Das ist zutreffend; Sie können von jeder Klasse erben, es sei denn, sie ist mit dem Schlüsselwort NonInheritable (in C# heißt es sealed) deklariert. Der Umgang mit geerbten Eigenschaften ist häufig 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 ausführen, wird das von ClassB definierte Formular angezeigt. Beachten Sie, dass in dieser Klasse nirgends die Text-
107
Mit Windows Forms arbeiten
Eigenschaft des in Zeile 18 deklarierten Bezeichnungsfelds (Label) gesetzt wird. Wenn Sie jedoch die Anwendung ausführen, enthält 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 wäre, sondern vielmehr, weil im Konstruktor von ClassA ein Bezeichnungsfeld mit dem fraglichen Text erstellt und dem Formular hinzugefügt wird. Erinnern Sie sich daran, dass in jedem Konstruktor als Erstes ein Aufruf an den Konstruktor seiner Basisklasse erfolgt. Daher ist zur Ausführungszeit des Konstruktors von ClassB bereits ein Bezeichnungsfeld mit den Worten »Hello World!« vorhanden. Sie können jedoch von ClassB aus dieses Bezeichnungsfeld nicht bearbeiten. Es ist nämlich in Zeile 6 als private deklariert und daher nur für ClassA zugänglich. Würden Sie es in public ändern, erhielten Sie eine Fehlermeldung, denn ClassB hätte das Bezeichnungsfeld lblMessage geerbt und Zeile 18 würde versuchen, es zu redeklarieren – das ist leider keine gültige Operation. Unterm Strich lässt 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
Dieser Workshop soll Ihnen helfen, sich besser an die heute behandelten Begriffe zu erinnern. Es hilft Ihnen sehr, die Antworten vollständig zu verstehen, bevor Sie weiterlesen. Die Antworten zu den Quizfragen und den Übungen finden Sie in Anhang A.
Quiz Die Fragen 1 bis 3 beziehen sich auf das folgende Codefragment: 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11:
108
using System; using System.Windows.Forms; using System.Drawing; public class MyForm : Form { private Label lblMessage = new Label(); public MyForm() { this.Text = "Hello World!"; } }
Workshop
12: 13: 14: 15: 16: 17:
public class StartForm { public static void Main() { Application.Run(new MyForm()); } }
1. Was würde das folgende Statement liefern, wenn man es unter Zeile 9 platzieren würde? Console.Write(this.ToString());
2. Was würde der folgende Code liefern, wenn man ihn unter Zeile 9 platzieren würde? Label lblTemp = new Label(); Console.Write(lblTemp.Equals(this.lblMessage).ToString());
3. Was würde der folgende Code liefern, wenn man ihn unter Zeile 9 platzieren würde? 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 fünf Eigenschaften des Objekts MouseEventArgs. 6. Schreiben Sie ein einzelnes Statement in VB .NET, das die Breite eines Formulars auf ein Drittel der Bildschirmhöhe festlegt. 7. Welche Eigenschaft kontrolliert, welche Schaltfläche aktiviert wird, sobald der Benutzer die (ESC)-Taste gedrückt hat? 8. Welches ist der Standardwert von FormBorderStyle? 9. Welche drei Ereignisse verwenden das Paradigma, dass mit einer einzelnen Aktion zwei Ereignisse verknüpft 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 Drücken einer EINGEBEN-Schaltfläche anpassen können.
109
Menüs und Symbolleisten
4
Menüs und Symbolleisten
Mittlerweile dürften Sie mit dem Form-Objekt und dem Erstellen von Windows FormsAnwendungen vertraut sein. Sie haben bereits gelernt, wie Sie die Benutzeroberfläche verändern, indem Sie einige Steuerelemente wie etwa Label oder TextBox einfügen sowie die Eigenschaften des Formulars verändern. Schauen wir uns einmal einige trickreichere Steuerelemente an. Menüs und Symbolleisten gehören zur Standardausstattung einer Benutzeroberfläche. Praktisch jede Windows-Anwendung weist sie auf, und die Benutzer wissen sie zu bedienen. Darüber hinaus verleihen sie Ihrer Anwendung ein vollständigeres und gepflegteres Aussehen. Dieses Kapitel zeigt, wie Sie diese gebräuchlichen UI-Elemente erstellen und dem Benutzer gestatten, sie zu bedienen. Heute lernen Sie, 쐽
was Windows Forms-Steuerelemente sind,
쐽
wie Sie Ihren Formularen interaktive Menüs hinzufügen,
쐽
wie Sie Ihre Anwendung kontextabhängig machen,
쐽
wie Sie Schaltflächen in eine Symbolleiste einfügen,
쐽
wie man Informationen in der Statusleiste anzeigt,
쐽
wie Sie Ihrer Anwendung Bildlaufleisten hinzufügen.
4.1
Einführung 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 zurücktreten und uns ansehen, was Steuerelemente (Controls) sind und warum und wozu man sie verwendet. Für den Benutzer ist ein Windows Forms-Steuerelement ein selbstständiger Bestandteil der Benutzeroberfläche. Schaltflächen, Menüs und Listenfelder sind allesamt Steuerelemente. Manche davon, wie etwa Schaltflächen, sind interaktiv, während andere, wie etwa LabelSteuerelemente (Bezeichnungsfelder), es nicht sind. Den Benutzer kümmert 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 Äußere der Uhr und daher nur äußere Eigenschaften, wie etwa die Farbe oder die Uhrzeit. Der Benutzer kann die Standuhr verschieben und Dinge darauf platzieren, denn sie ist eine physische Entität, die sich manipulieren lässt.
112
Einführung 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 Zahnräder verändern, das Pendel in Gang setzen usw. Die »Uhr« steht immer noch für einen Teil der Benutzeroberfläche, doch sie ist auch ein Gegenstand mit Eigenschaften, Methoden und Ereignissen. Ein Steuerelement lässt 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 präsentiert Ihnen ebenso wie Windows Forms-Steuerelemente zwei »Gesichter« (vgl. Abbildung 4.1): ein äußeres für den Benutzer, ein tiefer reichendes inneres für den Entwickler. (Es gibt sogar noch tiefer reichende. Schließlich kann der Hersteller der Zahnräder 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 können. 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 für die Verwendung aller Steuerelemente. Auch Steuerelemente werden im Namensraum System.Windows.Forms gespeichert.
Entwickler kann mit Innenleben arbeiten
Benutzer sieht Äußeres
Abbildung 4.1: Ein Steuerelement stellt ein inneres und ein äußeres 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 möglichen Typen von Steuerelementen (wir untersuchen sie detaillierter an Tag 6):
113
Menüs und Symbolleisten
쐽
Containersteuerelement e: Eine Reihe von Steuerelementen wurde exklusiv dafür entworfen, andere Steuerelemente aufzunehmen. Steuerelemente wie etwa das PanelSteuerelemente gruppieren Elemente nicht nur, um die Benutzeroberfläche aufzuräumen, sondern um dem Entwickler ihre Bearbeitung zu erleichtern. Fügen Sie etwa einem Panel weitere Steuerelemente hinzu, können Sie deren gemeinsame Eigenschaften mit einem einzigen Befehl ändern, statt für jedes Steuerelement einen Befehl auszugeben.
쐽
Schaltflächen-Steuerelemente: Sie haben bereits mit dem Steuerelement Button gearbeitet. Diese Kategorie umfasst weitere Steuerelemente wie etwa CheckBox und RadioButton, die zwar nicht wie Schaltflächen aussehen mögen, sich aber tatsächlich so verhalten. Eine CheckBox etwa, also ein ankreuzbares Kästchen wie jene in Web-Formularen, lässt sich anklicken, verfügt über eine zugeordnete Textmeldung und kann auf einen Klick hin eine Aktion ausführen – genau wie ein regulärer Button. Diese Steuerelemente gehören zu den gebräuchlichsten in Windows Forms.
쐽
Listen-Steuerelemente: Listen-Steuerelemente werden üblicherweise verwendet, um Daten, meist aus Datenbanken, anzuzeigen. Zu dieser Kategorie gehören 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 nähere Betrachtung, bis Sie an Tag 9 lernen, wie Sie mit Daten und Datenbanken arbeiten.
쐽
Menü-Steuerelemente: Menüs gehören neben Schaltflächen zu den gebräuchlichsten Steuerelementen in einer Anwendung: von normalen Symbolleisten-Menüs bis hin zu Kontextmenüs. Der Rest dieses Kapitels beschäftigt sich mit der Funktionsweise dieser Steuerelemente.
쐽
Weitere Steuerelemente: Zu den Steuerelementen, die nicht in die obigen Kategorien passen, gehören etwa das Label-Steuerelement, Zeit- und Datum-Steuerelemente sowie das Steuerelement TreeView (Strukturansicht). Das bedeutet nicht, dass sie weniger wichtig wären, im Gegenteil: Wie Sie bereits gesehen haben, ist das Label-Steuerelement eines der gebräuchlichsten überhaupt.
Lassen Sie uns ohne weiteren Verzug lernen, wie man Menüs erstellt!
4.2
Menüs hinzufügen
Wir alle können uns etwas unter Menüs 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 Hauptmenüs dient lediglich der Gruppierung der Kategorien und führt ansonsten keine Funktionen
114
Menüs hinzufügen
aus. Die Unterelemente sind die eigentlichen Arbeitsbienen unter den Menüs. Manchmal können sogar Unterelemente als Menüs 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 für ein Befehlsmenü.
In Abbildung 4.2 beachten Sie bitte die waagrechten Linien, die Menügruppen im DATEI-Menü voneinander trennen. Diese Zeilen werden Separatoren oder Trennlinien genannt und sie helfen dem Benutzer bei der Navigation in den Anwendungsmenüs. Wie Sie Trennlinien in Ihre Menüs integrieren, lernen Sie im heutigen Abschnitt »Menüs anpassen« weiter unten. In .NET werden die Menükopfzeilen 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 für 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
Menüs und Symbolleisten
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 Gerüst für das Einfügen weiterer Menüs. Dies und entsprechende Befehle folgen später. 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 können Sie so viele Menüs erzeugen, wie Sie wünschen, 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 lässt sich sehr vielseitig verwenden; es kann jedes Menüelement (MenuItem) darstellen, ganz gleich, ob es sich in der Menühierarchie auf oberster oder drittklassiger Ebene befindet. Sie verwenden die AddMethode des MainMenu-Objekts, um der MenuItems-Auflistung neue Menüelemente hinzuzufügen. Dieses MenuItem wird die oberste Ebene oder Kopfzeile für ein Menü bilden. In diesem Fall haben wir es »Datei« genannt, ein sehr gebräuchliches Menü in WindowsAnwendungen.
116
Menüs hinzufügen
Das kaufmännische Und-Zeichen (&, auch »Ampersand« genannt) im Menünamen bedeutet, dass das Zeichen, das unmittelbar darauf folgt, durch die Tastatur zugänglich 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 Menüelement geben. Auch nach dem Erstellen eines Menüelements können Sie dessen Titelzeile noch mit Hilfe der Text-Eigenschaft ändern. In Zeile 15 fügen Sie dem in Zeile 14 erzeugten MenuItem-Objekt ein weiteres hinzu. Weil dieses MenuItem zu einem anderen MenuItem-Objekt statt zum MainMenu-Objekt gehört, wird es als Menüelement im Menü statt in der Hauptmenüleiste erscheinen. Das neue MenuItem heißt »Öffnen«. Abbildung 4.3 zeigt das Ergebnis dieses Codes.
Abbildung 4.3: Listing 4.1 erzeugt ein DATEI-Menü mit einem Menüelement namens ÖFFNEN.
Wenn Sie auf das Menüelement klicken, passiert nichts; das liegt daran, dass wir noch einen Handler für dieses Menüelement erstellen müssen. Dafür ä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. Fügen 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
Menüs und Symbolleisten
Statt die vertraute AddHandler-Methode zu verwenden, legen Sie einfach nur die Methode fest, die nach der Menüauswahl ausgeführt werden soll – ein weiterer Parameter bei der Erstellung des Menüelements (wenn Sie wollen, könnten Sie auch AddHandler verwenden). Abbildung 4.4 zeigt das geänderte Ergebnis.
Abbildung 4.4: Das Hinzufügen eines Handlers verleiht den Menüelementen Funktionsfähigkeit.
Lassen Sie uns einen Blick auf ein weiteres Beispiel werfen, diesmal für die Erstellung von Untermenüs. 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:
118
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("&Menüs")); 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"));
Menüs hinzufügen
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 fügen dem MainMenu genau wie zuvor weitere MenuItem-Objekte hinzu. An diesem Punkt haben Sie zwei Hierarchieebenen: die Kopfzeile des Menüs (die wir 'Item A' nennen wollen) und ein einzelnes Menüelement, »Fenster« (das wir 'Item B' nennen wollen). Denken Sie daran, dass die MenuItems-Eigenschaft eine Auflistung ist: Sie können 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 fügen Sie genau wie zuvor ein weiteres MenuItem hinzu. Weil Sie das MenuItem 'Item C' hinzugefügt haben, wird es zu einem weiteren Untermenü. Jetzt verfügen wir über drei Menüebenen: Fenster, Formulare und Menüs. Um auf ein Mitglied in einer Auflistung in VB .NET zuzugreifen, benötigen 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 fügen ein neues MenuItem ein, so dass Sie eine vierte Menüebene erhalten. Zeile 18 tut das Gleiche, indem sie der vierten Ebene ein weiteres MenuItem hinzufügt. Die Zeilen 19 und 20 führen diesen Vorgang fort, indem sie dem zweiten Element (wie durch den Index 1 angezeigt) weitere Untermenüs hinzufügen. Als Ergebnis unserer Bemühungen erhalten wir fünf Menüebenen, wie in Abbildung 4.5 zu sehen ist. Der Vorgang des Verschachtelns von Menüs mag zunächst ein wenig verwirrend erscheinen, aber denken Sie einfach daran, dass das erste MenuItem, das Sie einem anderen MenuItem hinzufügen, stets ein Untermenü erzeugt.
119
Menüs und Symbolleisten
Abbildung 4.5: Das Verschachteln von Menüs erzeugt einen interessanten Quellcode.
Sie können auch Untermenüs dadurch hinzufügen, dass Sie für 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"); miMenüs = miFormulare.MenuItems.Add("&Menüs"); miSind = miMenüs.MenuItems.Add("Sind");
Die erste Zeile erzeugt ganz normal das Element für die Kopfzeile des Menüs. Das nächste Menüelement wird als neues MenuItem erzeugt und der MenuItems-Auflistung der vorhergehenden Ebene hinzugefügt, genau wie Sie das mit der Menükopfzeile gemacht haben. Beachten Sie, dass jede darauffolgende Zeile das neue MenuItem in die MenuItems-Auflistung der vorhergehenden Zeile hinzufügt. Beide Methoden zur Menüerzeugung erledigen diese Aufgabe effizient. Die zweite Methode weist jedoch eine Reihe von Vorteilen auf: Sie erzeugt für jedes Menüelement einen neuen Namen, so dass wir es notfalls später leicht wiederfinden können (statt seine Indexzahl zu benutzen); und der Code ist ebenfalls leichter zu lesen. Letztlich bleibt die Wahl Ihnen überlassen.
Menüs anpassen Menüs sind in höchstem Maß anpassungsfähig. Sie können Menüs zusammenfassen, visuelle Erweiterungen und Kurzbefehle hinzufügen und so weiter. Da diese Verschönerungen dem Endbenutzer eine bessere Bedienungserfahrung vermitteln, wollen wir einen Blick darauf werfen. Die einfachste Methode zur Anpassung Ihrer Menüs besteht darin, ähnliche Elemente zusammenzufassen. Das in Abbildung 4.2 gezeigte DATEI-Menü des Internet Explorers zeigt, wie sich ähnliche Menüelemente gruppieren lassen; eine Trennlinie (Separator)
120
Menüs hinzufügen
separiert eine Serie von Menüelementen von der nächsten. Das Einfügen einer Trennlinie ist problemlos und eine gute Möglichkeit, den Benutzern beim Navigieren durch die Menüs zu helfen. Sehen Sie sich bitte folgendes Stück Code an: MenuItem miDatei = mnuDatei.MenuItems.Add("&Datei"); MenuItem miÖffnen = miDatei.MenuItems.Add("&Öffnen"); MenuItem miSpeichern = miDatei.MenuItems.Add("&Speichern"); miFile.MenuItems.Add("–"); MenuItem miBeenden = miDatei.MenuItems.Add("Beenden");
Die ersten drei Zeilen fügen einem vorhandenen MainMenu-Objekt einfache Menüelemente hinzu. Um eine Trennlinie einzufügen, müssen Sie lediglich die Add-Methode aufrufen und ihr einen Gedankenstrich (–) übergeben. Die CLR versteht: Sie wollen die folgenden Menüelemente zu einer anderen Gruppe zusammenfassen und abtrennen. Diese einfache Erweiterung führt zu dem folgenden Menü in Abbildung 4.6.
Abbildung 4.6: Trennlinien helfen beim Organisieren Ihrer Menüs.
Zusätzlich zu den Zugriffstaten in den Menükopfzeilen können Sie auch Tastenkombinationen für Ihre Menüelemente 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-Menüs. (Strg) + (O) führt den Menübefehl DATEI/ÖFFNEN aus. MenuItem miÖffnen = miDatei.MenuItems.Add("&Öffnen", this.Öffnen_Clicked, Shortcut.CtrlO);
Der dritte Parameter, den Sie hier sehen, ist die Eigenschaft Shortcut. Sie können die Shortcut-Aufzählung verwenden, um die gewünschte Tastenkombination festzulegen. Diese Aufzählung verfügt über Werte für die meisten Tastenkombinationen, wie etwa Ctrlx wobei x eine beliebige Zahl oder ein beliebiges Zeichen sein kann; in Fx steht x für jede beliebige Zahl, und in CtrlShiftx ist x eine beliebige Zahl oder ein beliebiges Zeichen. In der .NET-Dokumentation erhalten Sie vollständige Informationen dazu.
121
Menüs und Symbolleisten
Wenn Sie während der Erstellung eines Menüelements keine Tastenkombination festlegen wollen, können Sie das auch noch später tun, indem Sie die Eigenschaft Shortcut des MenuItems nutzen: miDatei.Shortcut = Shortcut.ShiftF9
Setzen Sie die ShowShortcut-Eigenschaft auf true, wenn Sie die damit verknüpfte Tastenkombination im Menü neben dem Menüelement anzeigen lassen wollen: MiDatei.Shortcut = ShowShortcut = true
Schließlich gibt es noch ein paar einfache boolesche Eigenschaften, die Sie für jedes Menüelement anpassen können: 쐽
Enabled legt fest, ob der Benutzer das Menüelement auswählen kann oder nicht (deaktivierte Elemente erscheinen grau).
쐽
Visible zeigt an, ob der Benutzer das Element sehen kann (bedenken Sie, dass ein
Menüelement selbst dann noch per Tastenkombination aktiviert werden kann, wenn es nicht sichtbar ist; sorgen Sie dafür, dass sowohl Enabled als auch Visible auf false gesetzt sind, wenn Sie verhindern wollen, dass Benutzer ein Menüelement sehen oder auswählen). 쐽
Checked zeigt an, ob sich neben dem Menüelement ein Häkchen befindet. Das ist
nützlich, wenn Sie beispielsweise kenntlich machen wollen, ob ein Menüelement ausgewählt worden ist. 쐽
DefaultItem zeigt an, ob das Menüelement die voreingestellte Auswahl ist (Standardelemente erscheinen in fetter Schrift).
Um weitere Informationen über MenuItem-Eigenschaften zu erhalten, schlagen Sie bitte in Anhang B nach.
Kontextmenüs 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 häufig kontext-relevante Menüs zur Auswahl bereitstellt (etwa Ausschneiden, Einfügen usw.), bezeichnet man als Kontextmenü. Wenn Sie bereits einmal etwas länger mit WindowsAnwendungen gearbeitet haben, wissen Sie, dass solch ein Menü für produktives Arbeiten einfach unerlässlich ist. Zum Glück lassen sich Kontextmenüs ebenso einfach einem Formular hinzufügen wie normale Menüs. Alle Kontextmenüs werden durch das ContextMenu-Objekt dargestellt. Es ist dem MainMenuObjekt sehr ähnlich. Menüelemente im ContextMenu werden sogar als MenuItem-Objekte dargestellt. Folglich können Sie alles, was Sie bisher über Menüs gelernt haben, auch auf Kontextmenüs anwenden.
122
Menüs hinzufügen
Am einfachsten lässt sich ein Kontextmenü als Kopie des regulären Menüs anfertigen, das Sie bereits erzeugt haben. Dies können Sie mit der CloneMenu-Methode bewerkstelligen. Der folgende Code erzeugt ein neues ContextMenu-Objekt und fügt die Kopie eines vorhandenen Menüs hinzu: ContextMenu mnuContext = new ContextMenu(); Form1.ContextMenu = mnuContext; MenuItem miContext = miDatei.CloneMenu(); mnuContext.MenuItems.Add(miContext);
Sobald Sie Ihrem Formular diesen Code hinzugefügt 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 für diese Stelle ein spezialisiertes Menü bereitstellen. So kann etwa ein Rechtsklick auf eine leere Fläche im Formular das DATEI-Menü aufrufen, und ein Rechtsklick auf eine TextBox könnte ein spezielles Kontextmenü mit den Befehlsoptionen AUSSCHNEIDEN und EINFÜGEN darin aufrufen. Um dieses Funktionsmerkmal bereitzustellen, verfügt jedes Windows Forms-Steuerelement (inklusive des Form-Objekts) über die Eigenschaft ContextMenu, die das Menü angibt, welches geöffnet wird, wenn das Steuerelement rechts angeklickt wird. Dies macht es Ihnen recht leicht, Ihre Kontextmenüs anzupassen. Lassen Sie uns mit Listing 4.3 ein Beispiel dafür ansehen. Listing 4.3: Angepasste Kontextmenüs 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
Menüs und Symbolleisten
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 miÖffnen = 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ü für Ihre Anwendung (Sie haben diesen Code bereits in Listing 4.2 gesehen). Zeile 39 erzeugt ein neues MenuItem für 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ü lässt sich nun auf dieses Label anwenden (wenn Sie wollen, könnten Sie dieses Kontextmenü auch anderen Steuerelementen zuweisen).
124
Symbolleisten, Statusleisten und Bildlaufleisten hinzufügen
Die Zeilen 42 und 43 erledigen das Gleiche für das TextBox-Objekt, indem sie ein Menüelement erzeugen, das die Beschriftung »Textbox-Menü« trägt. Da Sie an keiner Stelle auch dem Form-Objekt ein ContextMenu zuweisen, wird ein Rechtsklick auf eine leere Formularfläche 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 verknüpftes Kontextmenü an: eines, das Befehlsoptionen für Ausschneiden und Einfügen anzeigt. Der Grund dafür ist, dass TextBox (und ebenso RichTextBox) bereits voreingestellte Kontextmenüs besitzen. Indem Sie Ihr eigenes Kontextmenü erzeugen, setzen Sie die vorhandenen Menüs außer Kraft.
4.3
Symbolleisten, Statusleisten und Bildlaufleisten hinzufügen
Symbolleisten, Statusleisten und Bildlaufleisten sind ebenso vertraute Bestandteile jeder Windows-Anwendung wie Menüs. Eine Symbolleiste befindet sich gewöhnlich am oberen Ende eines Anwendungsfensters, also direkt unter der Menüleiste, und enthält Schaltflächen mit Grafiken darauf, die die jeweilige Funktionalität in der Anwendung signalisieren. Word etwa hat eine Schaltfläche mit dem Bild eines geöffneten Ordners, um das Öffnen einer Datei zu bezeichnen, und ein Diskettensymbol für die Speichern-Funktion. Eine Statusleiste befindet sich am unteren Rand des Anwendungsfensters und stellt dem Benutzer Verarbeitungsinformationen zur Verfügung. Ihre einzige interaktive Funktion besteht darin, Meldungen anzuzeigen. Bildlaufleisten schließlich erlauben dem Benutzer, durch ein Formular zu blättern, falls nicht alle Steuerelemente in die vorhandene Fensterfläche passen. Abbildung 4.8 stellt alle drei Leistentypen dar.
125
Menüs und Symbolleisten
Abbildung 4.8: In den meisten Anwendungen finden sich Symbolleisten, Statusleisten und Bildlaufleisten.
Trotz ihrer Namensähnlichkeit erweisen sich die drei Steuerelemente bei der Implementierung als recht unterschiedlich. Die Symbolleiste agiert als selbstständiges Steuerelement (obwohl es weitere Steuerelemente enthält) und ist mit einem ImageList-Objekt verknüpft. Die Statusleiste hingegen agiert ähnlich einem Formular als Container für andere Steuerelemente. Die Bildlaufleiste ist wieder eine andere Angelegenheit und verfügt nur über wenige anpassbare Eigenschaften. Wir betrachten diese Steuerelemente der Reihe nach.
Symbolleisten Eine Symbolleiste besteht aus einer Sammlung von Schaltflächen (normalerweise durch Grafiken dargestellt), die Kurzbefehle (Shortcuts) zu den Funktionen Ihrer Anwendung anbieten. Wahrscheinlich arbeiten Sie bereits seit längerem mit Symbolleisten, so dass wir uns hier nicht bei konzeptionellen Details aufhalten. Die Symbolleiste und ihre Schaltfläche werden durch die Objekte ToolBar und ToolBarButton dargestellt. Diese beiden Objekte ähneln den Objekten MainMenu und MenuItem: Sie erstellen das zweite Objekt und fügen es dem ersten Objekt hinzu, die Schaltflächen also der Leiste. Lassen Sie uns einen Blick auf Listing 4.4 werfen, das Code zeigt, welcher eine einfache Symbolleiste erzeugt.
126
Symbolleisten, Statusleisten und Bildlaufleisten hinzufügen
Listing 4.4: Eine einfache Symbolleiste hinzufügen 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 fügen Sie es Ihrem Formular wie jedes andere Steuerelement hinzu. In Zeile 10 erstellen Sie ein neues ToolBarButton-Steuerelement: Darauf wird der Benutzer später klicken können. 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, wofür Sie sie halten). Schließlich fügen Sie das ToolBarButton-Steuerelement Ihrem ToolBarObjekt hinzu. Ohne diesen Schritt wäre Ihre Symbolleiste leer und würde in sich zusammenfallen. Kompilieren Sie diese Anwendung und führen Sie sie aus. Das Ergebnis sollte wie in Abbildung 4.9 aussehen. Wir haben zwar jetzt eine Symbolleistenschaltfläche, aber einige Dinge scheinen zu fehlen oder nicht zu stimmen. Augenfällig ist, dass sich ihr Text nicht in der Mitte befindet. Zweitens ist mit der Schaltfläche keine Grafik verknüpft. Und schließlich passiert nach einem Klick auf die Schaltfläche überhaupt nichts. Alle diese Mängel lassen sich leicht beheben.
127
Menüs und Symbolleisten
Abbildung 4.9: Listing 4.4 erzeugt eine einfache Symbolleiste mit nur einer Schaltfläche.
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 Schaltfläche. Die Text-Eigenschaft für den ToolBarButton hingegen wird verwendet, um die Grafik auf der Schaltfläche zu ergänzen (denken Sie mal an die ZURÜCK-Schaltfläche im Internet Explorer). Der Grund für das Erscheinen des Textes außerhalb des Zentrums ist also, dass er Platz lässt für die Grafik. Wenn wir der Schaltfläche eine Grafik zuweisen wollen, müssen 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 verknüpfen. ImageList verfügt über Methoden, um die Grafiken, die es enthält, hinzuzufügen, zu entfernen und neu zu sortieren. Nachdem Sie einer ImageList Grafiken hinzugefügt haben, werden die Schaltflächen 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 fügen 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 Symbolleistenschaltflächen verknüpfen 1: 2: 3:
128
private ImageList ilstToolbar =new ImageList(); public void AddToolbar(){
Symbolleisten, Statusleisten und Bildlaufleisten hinzufügen
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 glücklich!"; 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 fügen 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 tatsächlich besitzen!) Diese Methode lädt 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 könnten etwa folgenden Code am Anfang Ihrer Datei einfügen: using System.Drawing;
Die Zeilen 8 bis 18 erzeugen drei neue ToolBarButton-Objekte, wobei die Eigenschaften für Text und ImageIndex angegeben werden. Der ImageIndex zeigt auf den Index für diejenige Grafik in der ImageList, die Sie mit der Schaltfläche verknüpfen wollen (der erste Index lautet stets 0). In Zeile 20 verknüpfen Sie schließlich die in Zeile 1 erzeugte ImageList mit dem ToolBarObjekt. Dabei verwenden Sie die ImageList-Eigenschaft des Objekts. Die Zeilen 21 bis 23 fügen einfach die neu erstellten Schaltflächen der Symbolleiste hinzu. Abbildung 4.10 zeigt das Ergebnis dieser Datei.
129
Menüs und Symbolleisten
Abbildung 4.10: Jetzt verfügt die Symbolleiste über Schaltflächen mit Symbolen und Beschriftungen.
Die Anwendung sieht schon ein wenig besser gefüllt aus. Aber es gibt noch einiges zu tun: Die Schaltflächen sollten auch eine Funktion erfüllen. Erinnern Sie sich an meine Worte, wonach die ToolBar als ein einzelnes Steuerelement agiert? Gleich werden Sie den Grund dafür erkennen. ToolBarButton-Objekte verfügen ü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 möchte, sobald ein Benutzer auf eine Symbolleistenschaltfläche geklickt hat, muss man sich dem ToolBar-Objekt zuwenden. Das ToolBar-Steuerelement verfügt über ein ButtonClick-Ereignis, das ausgelöst wird, sobald eine der in ihm enthaltenen ToolBarButtons angeklickt wird. Daher müssen alle Ereignisse und Aktionen über die ToolBar erfolgen. Um Ihrer ToolBar einen Handler hinzuzufügen, 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:
130
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;
Symbolleisten, Statusleisten und Bildlaufleisten hinzufügen
11: 12: 13:
break; } }
Das Parameterobjekt ToolBarButtonClickEventArgs verfügt über eine Button-Eigenschaft, wie in Zeile 2 zu sehen ist. Sie gibt an, welche Schaltfläche angeklickt wurde. Wir verwenden die IndexOf-Eigenschaft der Buttons-Auflistung, um für jede Schaltfläche eine numerische Darstellung zurückzugeben, die wir für die Entscheidung darüber verwenden können, welcher Code auszuführen ist. Das switch-Statement (in VB .NET wird statt dessen Select Case verwendet) wertet die ihm gelieferte Bedingung gegenüber jedem einzelnen case-Element aus. Wenn die Werte übereinstimmen, wird der Code im betreffenden case-Zweig ausgeführt. 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 zurück. Break ist nötig, um der CLR mitzuteilen, nach der Ausführung des case-Statements keine weiteren mehr auszuführen 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 ausführen 5: Case 1 6: 'etwas Code ausführen 7: Case 2 8: 'etwas Code ausführen 9: end Select 10: End Sub
Symbolleisten anpassen ToolBar- und ToolBarButton-Steuerelemente verfügen ü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 Symbolleistenschaltflächen als normale dreidimensionale Objekte (erhabene Schaltflächen) 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
Menüs und Symbolleisten
Abbildung 4.11: Normale Symbolleistenschaltflächen sehen dreidimensional aus; flache Schaltflächen hingegen sind eben das: flach. Appearance lässt sich auf zwei Werte setzen: Normal (3D) oder Flat. Beide Werte gehören zur Aufzählung ToolBarAppearance. Das folgende Codefragment lässt die Schaltfläche 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 Größe der ToolBarButtons, die sie enthält, vergrößern und verkleinern soll. Dementsprechend gibt es auch eine ButtonSize-Eigenschaft, die die Größe der Schaltflächen in der ToolBar vorgibt. Die Standardgröße für eine Schaltfläche beträgt 24 (Breite) x 22 (Höhe) Pixel. Doch wenn ButtonSize nicht anderweitig angegeben ist, passen sich die Schaltflächen der größten Grafik und dem mit ihnen verknüpften Text an. Um die Begrenzung Ihrer Symbolleiste zu steuern, stehen Ihnen die Eigenschaften Divider und BorderStyle zur Verfügung. 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 für das Form-Objekt. Das Steuerelement ToolBarButton verfügt nur über eine Haupteigenschaft, nämlich Style, und über verschiedene weitere, die diese Eigenschaft unterstützen. Style gibt an, welche Art von Schaltfläche dem Benutzer gezeigt wird. Sie kann einen der Werte in der Aufzählung ToolBarButtonStyle annehmen:
132
Symbolleisten, Statusleisten und Bildlaufleisten hinzufügen
쐽
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 standardmäßige 3D-Schaltfläche, wie sie vom jeweiligen Betriebssystem definiert wird. (Die Schaltfläche kann in manchen Windows-Versionen flach statt dreidimensional erscheinen.)
쐽
Separator: Eine Trennlinie zwischen zwei Schaltflächen.
쐽
ToggleButton: Eine Schaltfläche, die, sobald sie angeklickt wurde, wie eingedrückt aussieht und so bleibt. Verwenden Sie die Pushed-Eigenschaft, um anzugeben, ob die Schaltfläche gerade gedrückt ist. PartialPush ähnelt Pushed, nur dass die Schaltfläche
nicht gedrückt, sondern vielmehr grau eingefärbt ist. Abbildung 4.12 zeigt Beispiele für all diese Stile.
Abbildung 4.12: Hier sind die Schaltflächenstile 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 verfügt ü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 hinzuzufügen – schließlich 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 dürften Sie sie leicht verstehen können. Wir wollen wieder in etwas Code eintauchen: Listing 4.8 (für dieses Beispiel verwenden wir VB .NET) zeigt, wie eine Statusleiste hinzugefügt wird.
133
Menüs und Symbolleisten
Listing 4.8: Ihrer Anwendung eine in VB .NET geschriebene Statusleiste hinzufügen 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
Symbolleisten, Statusleisten und Bildlaufleisten hinzufügen
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 für die Statusleiste in einer Methode namens AddStatusBar untergebracht, die in Zeile 13 aufgerufen wird. Zeile 21 fügt die Statusleiste dem Formular hinzu. Die erste Zeile der AddStatusBar-Methode (Zeile 26) erzeugt ein neues StatusBarPanelObjekt und fügt 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 Aufzählung StatusBarPanelBorderStyle; die anderen Werte, die Sie verwenden können, sind None oder Sunken, welches der Standardstil ist). In Zeile 30 wird ein weiterer StatusBarPanel-Bereich erzeugt. Die Text-Eigenschaft ist zunächst 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 zurückzugeben – der Standardrückgabetyp ist ein DateTime-Objekt). Zeile 32 setzt die AutoSize-Eigenschaft, welche angibt, wie sich der Bereich vergrößern bzw. verkleinern lässt, je nach seinem Inhalt und/oder der Größe des Formulars. Spring wirkt wie eine Feder, so dass der Bereich den gesamten verfügbaren Raum einnimmt, der noch nicht von anderen Bereichen belegt ist. AutoSize kann auch auf None oder Contents gesetzt sein, wodurch die Größe des Bereichs an seinen Inhalt angepasst wird. In Zeile 33 wird die Alignment-Eigenschaft verwendet, um den Inhalt des Bereichs rechtsbündig auszurichten. Dieser Wert kann Left, Center oder Right sein – die Werte stammen aus der Aufzählung 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 können Ihrer Statusleiste so viele Bereiche hinzufügen, wie Sie wünschen. 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 lässt 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 Hinzufügen des folgenden Codes zur AddStatusBar-Methode in Listing 4.8 erhält man einen neuen Bereich: dim sbpIcon as StausBarPanel = sbrMain.Panels.Add("") sbpIcon.AutoSize = StatusBarPanelAutoSize.Contents sbpIcon.Icon = new Icon("VSProjectApplication.ico")
135
Menüs und Symbolleisten
Abbildung 4.13: Ihre erste Statusleiste enthält 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 hinzufügen, 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
Symbolleisten, Statusleisten und Bildlaufleisten hinzufügen
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 für OK- und Abbrechen-Schaltflächen"; 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
Menüs und Symbolleisten
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 gedrückt"; } public void CancelIt(Object Sender, EventArgs e) { lblMessage.Text = "Der Abbrechen-Button wurde gedrückt"; } } 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 Schaltflächen-Steuerelemente an. Die Zeilen 32 bis 38 fügen diese Steuerelemente dem Formular hinzu, und die Zeilen 58 bis 65 behandeln die Ereignisse der Schaltflächen. (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 zunächst einmal unsichtbar lassen. Um die Dock-Eigenschaft kümmern wir uns an Tag 6. Halten wir erst einmal fest, dass unsere Bildlaufleisten am rechten und am unteren Rand unseres Formulars angedockt sind.
138
Symbolleisten, Statusleisten und Bildlaufleisten hinzufügen
In Zeile 31 behandeln Sie ein neues Ereignis des Form-Objekts: Resize. Dieses Ereignis wird natürlich ausgelöst, sobald die Größe des Formulars geändert wird. Zeile 31 besagt: Sobald dies passiert, führe die Methode Resized aus, wie in den Zeilen 43 bis 56 zu sehen. Diese Methode muss zwei Dinge tun: Erstens muss sie bei einer Größenänderung die Größe 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 gelöscht werden können. Die Mindesthöhe 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 Höhe. Das if-Statement in Zeile 44 führt den Vergleich zwischen der Höhe des Formulars und der Mindesthöhe aus. Ist die Formularhöhe niedriger, zeigt man die vertikale Bildlaufleiste an (Zeile 45). Umgekehrt gilt: Ist die Formularhöhe größer als die Mindesthöhe, verbergen Sie die Bildlaufleiste, wie in Zeile 47 zu sehen. Die Zeilen 50 bis 54 machen das Gleiche für 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 schließlich die Refresh-Methode auf. Kompilieren Sie diese Anwendung und versuchen Sie das Formular auf eine Größe 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 Formulargröße geändert wird.
Beachten Sie jedoch, dass auf einen Klick auf die Bildlaufleisten hin nichts passiert! Ihr Formular lässt sich nicht wie vorgesehen bewegen. Es gibt zwei Möglichkeiten, diesen Mangel zu beheben. Die erste und einfachere Möglichkeit besteht im Setzen der AutoScoll-Eigenschaft des Formulars auf true: this.AutoScroll = true;
Ihr Formular lässt sich nun wie erwartet bewegen. Die zweite Möglichkeit besteht in einer manuellen Vorgehensweise, wobei man die Ereignisse der Bildlaufleisten behandelt. Normalerweise nutzt man diese Möglichkeit nur dann, wenn man vorher nicht weiß, wie groß ein Formular werden kann (etwa wenn ein Benutzer die Größe dynamisch steigern kann).
139
Menüs und Symbolleisten
Lassen Sie uns untersuchen, wofür der Bildlauf auszuführen ist, wenn die Bildlaufleisten angeklickt werden. Zunächst würde man vermuten, es sei das Form-Objekt, doch das träfe nicht zu. Denken Sie daran, dass die Position des Formulars auf den Desktop bezogen ist; wenn Sie also einen Bildlauf bezüglich des Formular-Objekts versuchen, bewegt es sich nur auf dem Desktop, doch seine Inhalte würden an ihrem relativen Ort (im Formular) verbleiben. Entgegen unseren Erwartungen würden sich die Steuerelemente nicht bewegen. Wir wollen aber die Steuerelemente innerhalb des Formulars bewegen, nicht aber das Formular selbst. Wenn also der Benutzer den Abwärtspfeil auf der senkrechten Bildlaufleiste anklickt, müssen sich alle Steuerelemente nach oben bewegen. Das Entsprechende gilt, wenn der Benutzer in der waagrechten Bildlaufleiste nach rechts klickt: Alle Steuerelemente müssen sich nach links bewegen. Wenn man, wie wir in unserem Beispiel, nur drei Steuerelemente im Formular hat, hält 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 enthält, die bewegt werden müssen. Dann können 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, können Sie sie als eine Gruppe manipulieren – das ist genau das, was Sie ja beim Bildlauf erreichen wollen. Das Erzeugen des Panel-Steuerelements ist einfach; fügen 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 dafür sorgen, dass das Panel-Steuerelement die gleiche Größe besitzt wie das Formular, so dass alle Steuerelemente normal angezeigt werden. Fügen Sie dem Konstruktor folgenden Code hinzu: pnlForm.Height =this.Height; pnlForm.Width =this.Width;
Als Nächstes 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 verknüpft, sondern stattdessen mit dem Panel-Steuerelement. Als Nächstes fügen Sie das Panel-Steuerelement dem Konstruktor des Form-Objekts hinzu: this.Controls.Add(pnlForm);
140
Symbolleisten, Statusleisten und Bildlaufleisten hinzufügen
Um die Bildlaufereignisse zu behandeln, müssen Sie im Konstruktor Ereignishandler zum Scroll-Ereignis der Bildlaufleisten hinzufügen, 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 für Ihre Methoden verwenden. Zum Schluss müssen 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 abwärts 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 abwärts bewegt wird, sollte sich das Panel-Steuerelement von seiner ursprünglichen Position aus um x Raumeinheiten aufwärts bewegen. In diesem Fall entspricht die Anfangsposition des Panel-Steuerelements den X-Y-Koordinaten (0,0), was der Grund dafür 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 »abwärts«, also bewegen sich die Steuerelemente aufwärts). Tabelle 4.1 zeigt ein paar beispielhafte Situationen. Aktion
Ergebnisse
1. Der Benutzer klickt den AufwärtsPfeil um zehn Einheiten (Wert der Bildlaufleiste = 10)
Das Panel-Steuerelement bewegt sich 10 Einheiten abwärts. Der neue Panel.Top-Wert lautet –10, Panel.Left = 0.
Tabelle 4.1: Beispiele für Bewegungen beim Bildlauf
141
Menüs und Symbolleisten
Aktion
Ergebnisse
2. Der Benutzer verschiebt die Bildlaufleiste bis ganz nach unten (Wert der Bildlaufleiste = Form.Height)
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 heißt, 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 für 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; für die senkrechte Bildlaufleiste also ganz oben, für die waagrechte ganz links). Die Vorgabe für Maximum lautet 100, was bedeutet, dass sich die Bildlaufleisten um 100 Einheiten bewegen können, nicht mehr. Sie können 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 herbeigeführt hat). Gemäß den Zeilen 2 und 6 des Listings 4.10 sind ± 100 Einheiten auf- und abwärts, nach links oder rechts der maximale Bewegungsradius des Panel-Steuerelements. Hat ein Formular kompliziertere Anforderungen an seine Größe, müssen Sie vielleicht den Betrag erhöhen, um den sich ein Panel-Steuerelement bewegen kann. Sollte Ihr Formular also 1000 Pixel hoch sein, dann sind für Ihre vertikale Bildlaufleiste ± 100 Einheiten nicht ausreichend. Somit sollte jede Einser-Einheit der Bildlaufleiste sich um mehr als nur eine Einheit der Höhe des Panel-Steuerelements bewegen. Der folgende Code könnte 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 verfügen können; Sie können beinahe jedem gewünschten Steuerelement Bildlaufleisten hinzufügen, so etwa einer PictureBox oder sogar Schaltflächen. Dies stellt Ihnen vielfältige Entwurfsmöglichkeiten hinsichtlich der Interaktion Ihrer Anwendung mit dem Benutzer zur Verfügung.
142
Symbolleisten, Statusleisten und Bildlaufleisten hinzufügen
Wir wollen noch weitere Eigenschaften betrachten, die Sie im Zusammenhang mit Bildlaufleisten nutzen können. 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 drückt. LargeChange wird benutzt, wenn die Bildlaufleiste selbst angeklickt wird oder die (Bild½)und (Bild¼)-Pfeiltasten gedrückt werden. Die Type-Eigenschaft des Parameterobjekts ScrollEventArgs teilt Ihnen mit, was tatsächlich während des Bildlaufereignisses passiert ist, also etwa eine große oder kleine Bewegung oder wohin sich die Bildlaufleiste bewegt hat. Tabelle 4.2 führt diese Werte auf, von denen alle zur Aufzählung ScrollEventType gehören. Wert
Beschreibung
EndScroll
Das Bildlauffeld (Scroll-Box; das Kästchen, das die Position der Bildlaufleiste anzeigt) hat aufgehört sich zu bewegen.
First
Das Bildlauffeld hat sich zum Minimum-Wert bewegt.
LargeDecrement
Das Bildlauffeld hat sich um den LargeChange-Wert nach oben oder nach links bewegt (die Inhalte verschieben sich dann nach unten oder nach rechts).
LargeIncrement
Das Bildlauffeld hat sich um den LargeChange-Wert nach unten oder nach rechts bewegt (die Inhalte verschieben sich dann nach oben oder nach links).
Last
Das Bildlauffeld hat sich zu dem durch Maximum angegebenen Wert bewegt.
SmallDecrement
Das Bildlauffeld hat sich um den SmallChange-Wert nach oben oder nach links bewegt (die Inhalte verschieben sich dann nach unten oder nach rechts).
SmallIncrement
Das Bildlauffeld hat sich um den SmallChange-Wert nach unten oder nach rechts bewegt (die Inhalte verschieben sich dann nach oben oder nach links).
ThumbPosition
Das Bildlauffeld selbst wurde bewegt.
ThumbTrack
Das Bildlauffeld bewegt sich noch.
Tabelle 4.2: Werte für ScrollEventType
Listing 4.11 zeigt ein kurzes Beispiel (zumindest im Hinblick auf die Komplexität) für die Verwendung dieser Werte.
143
Menüs und Symbolleisten
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:
144
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 für 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();
Symbolleisten, Statusleisten und Bildlaufleisten hinzufügen
43: 44: 45:
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; }
46: 47: 48: 49: 50: 51: 52: 53: 54: 55: 56: 57: 58: 59: 60: 61: 62: 63: 64: 65: 66: 67: 68:
} } public class StartForm { public static void Main(){ Application.Run(new Listing410()); } } }
Der Konstruktor dürfte recht vertraut aussehen; er erzeugt einfach die Bildlaufleisten und ein Bezeichnungsfeld, danach fügt 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 aufgeführt sind. Für jeden Einzelfall gibt sie eine entsprechende Zeichenfolge an das Label-Steuerelement aus. Zu diesem Listing sind ein paar Bemerkungen angebracht. Erstens müssen 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 repräsentiert die angeklickte Bildlaufleiste (warum, verrate ich morgen) und sollte in dieser
145
Menüs und Symbolleisten
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 müssen, damit Sie die richtigen Eigenschaft erreichen können. (Mehr dazu morgen.) Als Zweites ist festzustellen, dass Sie in ein ScrollBar- und nicht in ein VScrollBaroder HScrollBar-Steuerelement umwandeln müssen (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 benötigen, 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 ausgeführt.
4.4
Zusammenfassung
Sie haben heute etwas über drei wichtige und häufig eingesetzte Arten von Steuerelementen gelernt: Menüs, Symbolleisten und Bildlaufleisten. Hinsichtlich ihrer Funktion sind sie sehr ähnlich und teilen sich sogar viele ähnliche Eigenschaften, doch hinsichtlich ihrer Implementierung sind sie völlig verschieden voneinander. Ein Steuerelement in Windows Forms ist ein Objekt, das dem Benutzer eine Schnittstelle präsentiert, mit der häufig eine Interaktion möglich ist. Es gibt unterschiedliche Arten von Steuerelementen, darunter Containersteuerelemente, Menüs und Schaltflächen (Buttons). Menüs lassen sich durch die Steuerelemente MainMenu und MenuItem darstellen. Das MainMenu nimmt Menüelemente (MenuItems) auf, welche wiederum die Beschriftungen präsentieren, die der Benutzer sieht und mit denen er in Menüs interagiert. Kontextmenüs, die sich öffnen, wenn der Benutzer auf ein Steuerelement rechtsklickt, verwenden ebenfalls MenuItem-Steuerelemente, setzen aber MainMenu anstelle von ContextMenu ein.
146
Fragen und Antworten
Eine Symbolleiste ähnelt einem Menü, nur dass man ein ToolBar-Steuerelement als übergeordnetes Objekt einsetzt und die ToolBarButton-Steuerelemente als untergeordnete Steuerelemente (ToolBarButtons können sogar MenuItem-Steuerelemente als untergeordnete Steuerelemente haben, wie es bei Dropdown-Schaltflächen der Fall ist). Von den beiden kann nur das ToolBar-Steuerelement verwendbare Ereignisse haben, so dass jeder Klick auf eine Schaltfläche 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 verfügen ü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 schließlich gibt es in zwei Varianten: HScrollBar und VScrollBar stellen waagrechte bzw. senkrechte Bildlaufleisten dar. Sie haben erfahren, dass es recht leicht ist, sie Ihrem Formular hinzuzufügen, dass jedoch die Behandlung ihrer Ereignisse eine sorgfältige Planung erfordert – insbesondere dann, wenn man herauszufinden versucht, für welche Elemente, um wie viele Einheiten und in welche Richtung der Bildlauf stattfinden soll. Beide Steuerelemente erben von der Basisklasse ScrollBar.
4.5 F
Gibt es ein Ereignis, das signalisiert, dass sich gleich ein Menü öffnen wird? A
F
Fragen und Antworten Ja, es gibt ein solches Ereignis: PopUp. Wenn Sie eine Aktion direkt vor dem Eintreten dieses Ereignisses ausführen lassen wollen – etwa das Verbergen oder Anzeigen von Menüelementen –können Sie für das Ereignis PopUp einen Handler erstellen.
Inwiefern unterscheidet sich die NewValue-Eigenschaft des ScrollEventArgs-Objekts von der Value-Eigenschaft? A
NewValue gibt den Wert an, um den sich die Bildlaufleiste während eines Ereignisses ändert. Value hingegen gibt den statischen Wert an. Häufig sind diese Werte identisch, manchmal aber auch nicht.
Wenn beispielsweise die Bildlaufleiste oder die Pfeile angeklickt werden, sind diese Werte identisch. Wenn jedoch das Bildlauffeld selbst mit der Maus bewegt wird, dann ist Value der vorhergehende Wert, während NewValue der aktuellen Position entspricht. Sobald das Bildlauffeld wieder losgelassen wird, nehmen beide Werte wieder den gleichen Wert an.
147
Menüs und Symbolleisten
4.6
Workshop
Dieser Workshop soll Ihnen helfen, sich besser an die heute behandelten Begriffe zu erinnern. Es hilft Ihnen sehr, die Antworten vollständig zu verstehen, bevor Sie weiterlesen. Die Antworten zu den Quizfragen und den Übungen finden Sie in Anhang A.
Quiz 1. Wahr oder falsch? Alle Steuerelemente inklusive des Form-Objekts erben von der Klasse Control. 2. Welches Objekt muss mit Symbolleisten verknüpft sein, damit Grafiken in den Symbolleistenschaltflächen angezeigt werden? 3. Wie heißen die drei optionalen Parameter für einen MenuItem-Konstruktor, und welches sind ihre Typen? 4. Welches Zeichen wird verwendet, um eine Tastenkombination für einen Buchstaben in der Beschriftung eines Menüelements bereitzustellen? 5. Schreiben Sie eine Zeile C#-Code, die ein ToolBarButton-Steuerelement namens MyFirstButton anweist, die vierte Grafik in der zugeordneten ImageList zu verwenden. 6. Wahr oder falsch? Das Ereignis, das für die Behandlung von Mausklicks auf Symbolleistenschaltflächen verwendet wird, heißt Click. 7. Welche sind die Standardwerte für die Eigenschaften Minimum, Maximum, SmallChange und LargeChange einer Bildlaufleiste?
Übung Erstellen Sie in VB .NET eine Anwendung, die ein personalisiertes Menü verwendet wie jene, die mit Microsoft Office 2000 und Windows 2000 eingeführt wurden. Diese Menüs zeigen nur die zuletzt benutzten Menüelemente, während sie die anderen verbergen und es dem Benutzer gestatten, auf einen Pfeil zu klicken, um weniger häufig ausgewählte Menüelemente anzuzeigen. Ihre Anwendung sollte ein Menü anbieten, das verborgene Menüelemente besitzt. Wird ein bestimmtes Menüelement angeklickt, sollen die verborgenen Elemente angezeigt werden. Kümmern Sie sich nicht um das Hinzufügen von Ereignishandlern für jedes Menüelement.
148
Workshop
Ihr Menü kann recht einfach sein: Es braucht sich nicht daran zu erinnern, welche Menüelemente der Benutzer am häufigsten auswählt, und es wird keine verborgenen Menüelemente anzeigen, nur weil der Mauspfeil über dem Menü schwebt. Sobald der Benutzer auf die Schaltfläche WEITERE... (More) klickt, muss er das Menü erneut öffnen, um die bislang verborgenen Elemente sehen zu können. (Sie werden sehen, wie man fortgeschrittenere Funktionen verwenden kann, wenn Sie an Tag 13 etwas über GDI+ erfahren.
149
Ereignisse in Windows Forms
5
Ereignisse in Windows Forms
Einer der wichtigsten Aspekte an einer Anwendung ist sicherlich – von der visuellen Oberfläche abgesehen – die Art und Weise, wie sie mit dem Benutzer interagiert. Wie Sie bereits wissen, wird diese Interaktion durch Ereignisse und deren Handler realisiert. Ein Ereignis ist das Resultat einer Aktion, also einer Meldung, die erzeugt wurde, um das Auftreten einer Aktion zu signalisieren. Die Aktion kann vom Benutzer oder von der Anwendung selbst verursacht worden sein. Ein Ereignishandler ist jene Methode, die reagiert, sobald ein Ereignis auftritt. Heute befassen wir uns mit Ereignissen und ihren Methoden, was sie für Ihre Anwendung bedeuten und warum man sie benötigt. Ich werde Ihnen eine neue Art von Klasse namens Delegate vorstellen, die Ihrer Anwendung bei der Ereignisbehandlung hilft. Heute lernen Sie, 쐽
was man in technischer Hinsicht unter einem Ereignishandler versteht,
쐽
wie Sie Ihre Ereignisse miteinander »verdrahten«,
쐽
wie Sie Delegaten verwenden,
쐽
wie Sie Ihre eigenen Ereignisse und Ereignisparameter erzeugen,
쐽
was jeder Parameter eines Ereignishandlers bewirkt, woher er stammt und wie man ihn einsetzt.
5.1
Was sind Ereignishandler?
Aus den vorausgegangenen Kapiteln verfügen Sie bereits über eine gewisse Erfahrung im Umgang mit Ereignissen. Sie wissen, was ein Ereignis ist und ungefähr, was ein Ereignishandler ist. Nun geht es um Letzteren. Um Ihre Anwendung zu einer Reaktion auf ein Ereignis zu veranlassen, müssen Sie einen Ereignishandler erstellen. Dieses Stück Code wird nur dann ausgeführt, wenn ein Ereignis eintritt. Wenn Sie beispielsweise Ihr Auto starten wollen, muss zwischen dem Gaspedal, dem Motor und dem Benzintank eine gewisse Verbindung bestehen, sonst erfolgt keine Aktion: es ist eine Verknüpfung nötig. Das Gleiche lässt sich für Ereignisse in .NET sagen. Eine Aktion mag erfolgen und ein Ereignis passieren, doch sofern es keine Verbindung dazwischen gibt, wird nichts stattfinden. Dementsprechend nennt man den Vorgang der Erstellung eines Ereignishandlers für ein Ereignis auch die Verknüpfung eines Ereignisses.
152
Was sind Ereignishandler?
Ereignisse behandeln Wir wollen uns zunächst eine Anwendung ansehen, die einige aus Menüelementen erzeugte Ereignisse verarbeitet, wie in Listing 5.1 zu sehen. Listing 5.1: Mit Ereignishandlern arbeiten 1: Imports System 2: Imports System.Windows.Forms 3: Imports System.Drawing 4: 5: Namespace TYWinForms.Day5 6: 7: public class Listing51 : Inherits Form 8: private mnuFont as new MainMenu 9: private lblMessage as new Label 10: 11: public sub New() 12: Me.Text = "Listing 5.1 " 13: Me.Menu = mnuFont 14: 15: lblMessage.Text = "Testen von Ereignissen" 16: lblMessage.Location = new Point(75,75) 17: lblMessage.Height = 50 18: lblMessage.Width = 150 19: lblMessage.BackColor = Color.LightBlue 20: 21: dim miFont as MenuItem = mnuFont.MenuItems.Add("Font") 22: dim miTimes as MenuItem = miFont.MenuItems.Add("Times Roman ") 23: AddHandler miTimes.Click,new EventHandler(AddressOf Me.TimesClicked) 24: 25: dim miArial as MenuItem = miFont.MenuItems.Add("Arial") 26: AddHandler miArial.Click, new EventHandler(AddressOf Me.ArialClicked) 27: 28: dim miWing as MenuItem = miFont.MenuItems.Add("Wingdings") 29: AddHandler miWing.Click, new EventHandler(AddressOf Me.WingClicked) 30: 31: Me.Controls.Add(lblMessage) 32: End Sub 33: 34: public sub TimesClicked(Sender as Object, e as EventArgs) 35: lblMessage.Font = new Font("Times",15) 36: mnuFont.MenuItems(0).MenuItems(0).Checked = True
153
Ereignisse in Windows Forms
37: 38: 39: 40: 41: 42: 43: 44: 45: 46: 47: 48: 49: 50: 51: 52: 53: 54: 55: 56: 57: 58: 59: 60:
mnuFont.MenuItems(0).MenuItems(1).Checked = False mnuFont.MenuItems(0).MenuItems(2).Checked = False end sub public sub ArialClicked(Sender as Object, e as lblMessage.Font = new Font("Arial", 15) mnuFont.MenuItems(0).MenuItems(0).Checked = mnuFont.MenuItems(0).MenuItems(1).Checked = mnuFont.MenuItems(0).MenuItems(2).Checked = end sub
EventArgs) False True False
public sub WingClicked(Sender as Object, e as EventArgs) lblMessage.Font = new Font("Wingdings",15) mnuFont.MenuItems(0).MenuItems(0).Checked = False mnuFont.MenuItems(0).MenuItems(1).Checked = False mnuFont.MenuItems(0).MenuItems(2).Checked = True end sub public Shared Sub Main() Application.Run(new Listing51) end sub end class End Namespace
Diese Anwendung zeigt etwas Text an und erlaubt dem Benutzer, die Schriftart – den Font – mit Hilfe eines Menüs zu ändern. Zunächst einmal die Grundelemente: Die Zeilen 1 bis 3 importieren die zu verwendenden Namensräume. In Zeile 8 und 9 werden die beiden Hauptsteuerelemente der Anwendung deklariert: ein MainMenu und ein Label. In Zeile 11 beginnt der Konstruktor für die Windows Forms-Klasse. Die Zeilen 15 bis 19 initialisieren die Eigenschaft des Label-Steuerelements, wobei sie seine Größe, Position und Text-Eigenschaften festlegen. Der nächste Codeabschnitt dürfte noch von gestern vertraut sein. Zeile 21 fügt dem MainMenu-Objekt ein Menüelement mit der Aufschrift »Font« hinzu. Dieses erste Menüelement wird die Kopfzeile des ganzen Menüs. Zeile 22 fügt dieser Kopfzeile ein Menüelement hinzu, nämlich die erste unserer zur Auswahl stehenden Schriftarten. Zeile 23 verwendet die AddHandler-Methode, um dem Click-Ereignis des Menüelements einen Ereignishandler hinzuzufügen. Das Click-Ereignis wird stets ausgelöst, wenn das zugehörige Menüelement angeklickt wird. Diese Zeile benachrichtigt die Anwendung von einem Ereignishandler namens TimesClicked, der für dieses Ereignis zu verwenden ist (mehr dazu heute im Abschnitt »Delegaten«). Die Zeilen 25 bis 29 erledigen die gleiche Aufgabe wie die Zeilen 22 und 23, nämlich weitere Menüelemente für weitere Fontoptionen zu erstellen (Arial und Wingdings) und den
154
Was sind Ereignishandler?
Click-Ereignissen dieser Menüelemente Ereignishandler zuzuweisen. Diese Zeilen ver-
knüpfen also die Ereignisse. Sobald eines dieser Menüelemente angeklickt wird, beginnt die Ausführung der jeweiligen Methode (TimesClicked, ArialClicked oder WingClicked). Dieser Ablauf ist recht simpel, obwohl der Code vielleicht ein wenig seltsam aussehen mag. Die TimesClicked-Methode in Zeile 34 ändert die Schriftart des Label-Steuerelements in Zeile 35. An Tag 3 haben wir untersucht, wie man Schriftarten mit Hilfe der Objekte Font und FontFamily ändert. Heute lernen wir eine neue Vorgehensweise. Statt das FontFamilyObjekt einzusetzen, übergeben wir einfach eine Zeichenfolge mit der Schriftart, zu der wir wechseln möchten – in diesem Fall Times. Der zweite Parameter ist wieder die anzuzeigende Schriftgröße. Um den Benutzer wissen zu lassen, welche Schriftart gerade benutzt wird, wollen wir die Menüelemente miTimes, miArial oder miWing mit Häkchen versehen, sobald sie jeweils ausgewählt sind. Die folgende Zeile bedeutet, dass das erste MenuItem, das dem MainMenuObjekt mnuFont hinzugefügt wurde, ein Häkchen erhalten soll – anders ausgedrückt, das miTimes-Menüelement: mnuFont.MenuItes(0).MenuItems(0).Checked = True
Die nächsten beiden Zeilen (37 und 38) verweisen auf die Elemente miArial und miWing (die zweiten und dritten Menüelemente, die nach dem ersten MenuItem dem MainMenuObjekt mnuFont hinzugefügt wurden). Da diese Optionen offensichtlich gerade nicht ausgewählt sind, sollten sie kein Häkchen aufweisen und ihre Checked-Werte auf False lauten: mnuFont.MenuItes(0).MenuItems(1).Checked = False mnuFont.MenuItes(0).MenuItems(2).Checked = False
Da Sie nicht wissen, welches dieser Menüelemente vorher mit Häkchen versehen war, setzen Sie beide auf False, um sicher zu gehen. Die ArialClicked- und WingClicked-Methoden in Zeile 41 bzw. 48 machen das Gleiche wie die TimesClicked-Methode, nur dass sie natürlich die Arial- bzw. Wingdings-Schriftarten anstelle von Times Roman verwenden. Zeile 55 schließlich deklariert den Eintrittspunkt zur Anwendung, nämlich die MainMethode. Sie ruft einfach die Run-Methode auf. Abbildung 5.1 zeigt diese Anwendung in Aktion. Lassen Sie uns kurz zur TimesClicked-Methode zurückkehren. Bitte beachten Sie die Signatur dieses Ereignishandlers: public sub TimesClicked(Sender as Object, e as EventArgs)
Es handelt sich hierbei um die Standardsignatur eines Ereignishandlers (anders ausgedrückt: seine Deklaration). Alle Ereignishandler weisen beinahe identische Signaturen auf. Es ändert sich jeweils nur der Methodenname (hier also TimesClicked) und in seltenen Fällen auch der abschließende Parametertyp EventArgs (Näheres dazu im Abschnitt »Delegaten«).
155
Ereignisse in Windows Forms
Abbildung 5.1: Die Schriftart ändert sich als Reaktion auf Ereignisse.
Der erste Parameter, Sender, stellt das das Ereignis erzeugende Objekt dar. In Listing 5.1 wäre dies das MenuItem-Objekt miTimes. Der zweite Parameter enthält jede nähere Information über das Ereignis. Diese Parameter werden eingesetzt, um den Ereignishandler bei seiner Aufgabe zu unterstützen. Meistens werden Sie diese Standardsignatur für alle Ihre Ereignishandler benutzen, wodurch sie nicht nur sehr leicht zu schreiben, sondern auch leicht aus bereits geschriebenem Code herauszugreifen sind. Dies war ein einfaches Beispiel, wie man Ereignishandler verwenden kann. Wir haben pro Ereignis, das uns interessierte, einen Ereignishandler erzeugt, sozusagen einen Draht pro Ereignis. Für alle anderen Ereignisse erzeugen wir keine Handler, wodurch diese praktisch ignoriert werden.
Mehrfache Ereignisse behandeln Ein sehr interessantes .NET-Merkmal besteht darin, dass ein Ereignis nicht unbedingt auch seinen eigenen Ereignishandler haben muss: Die Ereignisse können Handler gemeinsam nutzen! Eine Verknüpfung kann von einem Handler zu mehreren Ereignissen bestehen. Übertragen auf unseren Auto-Vergleich, hieße das, dass sich der Wagen auf mehrere Arten in Bewegung versetzen lässt, so etwa durch Anschieben oder durch das Loslassen der Bremse an einem abschüssigen Hügel. Da aber so viele Ereignisse einen Ereignishandler auslösen können, ist es umso wichtiger herauszufinden, welches Objekt das Ereignis erzeugt hat. An diesem Punkt kommt der Einsatz der Parameter eines Ereignishandlers unseren Wünschen entgegen. Listing 5.2 zeigt ein Beispiel eines mehrere Ereignisse verarbeitenden Ereignishandlers. Fertigen Sie von Listing 5.1 eine Kopie an und ersetzen Sie die Zeilen 34 bis 53 durch den Code in diesem Listing.
156
Was sind Ereignishandler?
Listing 5.2: Die Behandlung mehrerer Ereignisse mit nur einem Handler 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16:
public sub FontClicked(Sender as Object, e as EventArgs) dim item as MenuItem if Sender is mnuFont.MenuItems(0).MenuItems(0)then lblMessage.Font = new Font("Times ", 15) elseif Sender is mnuFont.MenuItems(0).MenuItems(1)then lblMessage.Font = new Font("Arial ", 15) elseif Sender is mnuFont.MenuItems(0).MenuItems(2)then lblMessage.Font = new Font("Wingdings ", 15) end if for each item in mnuFont.MenuItems(0).MenuItems item.Checked = False next item CType(Sender,MenuItem).Checked = True end sub
Die FontClicked-Methode ersetzt die Methoden TimesClicked, ArialClicked und WingClicked aus Listing 5.1 – sie erledigt die gleiche Aufgabe, doch auf etwas andere Weise. Beachten Sie die Signatur in Zeile 1: Sie ist immer noch die gleiche Standardsignatur. In Listing 5.1 verwendeten wir keinen dieser Parameter, doch diesmal verwenden wir sie, um zu bestimmen, welches Objekt das Ereignis erzeugt hat. In Zeile 2 deklarieren Sie ein neues MenuItem-Objekt; wir werden es gleich einsetzen. Die Zeilen 4 bis 10 stellen fest, welches Menüelement das Ereignis erzeugt hat, auf das diese Methode reagiert. Zu der Reaktion gehört die Auswertung des Sender-Parameters und dessen Vergleichen mit jedem der MenuItem-Objekte, die in der Auflistung miFont.MenuItems enthalten sind. Denken Sie daran, dass Sender das Objekt darstellt, das das Ereignis erzeugt hat. Die Schriftart im Label-Steuerelement ändert sich je nach dem Wert von Sender. Wir verwenden kein Gleichheitszeichen, um den Vergleich in den Zeilen 4, 6 und 8 zu bewerten, denn der Gleichheitsoperator funktioniert nur bei einfachen Datentypen wie etwa Zahlen oder Zeichenfolgen. Bei Objekten benötigen wir hingegen das Schlüsselwort is. Im nächsten Schritt verleihen wir dem aktuellen Menüelement ein Häkchen und entfernen die Häkchen bei den restlichen Menüelementen. Zu diesem Zweck verwenden wir eine for each-Schleife wie in Zeile 12. Sie nimmt jedes MenuItem aus der Auflistung miFont.MenuItems, weist es der Variablen item, die wir in Zeile 2 erzeugten, zu und setzt die Eigenschaft Checked dieser Variablen auf False, so dass die Häkchen aller anderen
157
Ereignisse in Windows Forms
MenuItems entfernt werden. Die for each-Schleife hätte man auch durch eine einfache forSchleife bewerkstelligen können, etwa so: for i = 0 to mnuFont.MenuItems(0).MenuItems.Count – 1 mnuFont.MenuItems(0).MenuItems(i).Checked = False next i
Die for-Schleife setzt eine Variable i ein, um durch die Gesamtzahl aller Menüelemente zu iterieren. Vergessen Sie nicht, die Variable i zu deklarieren, falls Sie diese Methode verwenden. Da nun alle MenuItems häkchenlos sind, brauchen wir nur das aktuelle Menüelement mit Häkchen zu versehen. Das erfolgt in Zeile 15. Mit Hilfe der CType-Methode konvertieren wir den Sender-Parameter zu einem MenuItem-Objekt (zum näheren Verständnis verweise ich auf den Abschnitt »Ereignishandler« später in diesem Kapitel). Da Sender das aktuelle Menüelement darstellt, können wir seine Checked-Eigenschaft auf True setzen. Zum Schluss müssen Sie die Zeilen 23, 26 und 29 in Listing 5.1 so ändern, dass sie Ihren neuen Allround-Ereignishandler nutzen: 23: ... 26: ... 29: ...
AddHandler miTimes.Click, new EventHandler(AddressOf Me.FontClicked) AddHandler miArial.Click, new EventHandler(AddressOf Me.FontClicked) AddHandler miWing.Click, new EventHandler(AddressOf Me.FontClicked)
Die Ausführung des geänderten Codes produziert die gleichen Ergebnisse wie das ursprüngliche Listing 5.1. Der einzige Unterschied: Ein Ereignishandler erledigt die Arbeit von dreien. Nun sind Sie schon fast ein Profi in der Ereignis-Behandlung. Aber es gibt noch ein paar andere Puzzlestückchen, die wir noch zusammensetzen sollten. Woher stammen beispielsweise die Parameter Sender und EventArgs?
5.2
Delegaten
Ein Ereignis ist also, dies nur zur Erinnerung, eine Meldung, die ein Objekt abschickt, um zu signalisieren, dass eine Aktion stattgefunden hat. Wenn also eine Schaltfläche angeklickt wird, schickt sie eine »Ich wurde angeklickt«-Meldung an die Common Language Runtime (CLR). Jedes Objekt hat die Verantwortung, die CLR über Ereignisse zu informieren – sonst würde nie etwas passieren. Das das Ereignis auslösende Objekt – etwa die Schaltfläche in obigem Beispiel – wird als Sender (sender) bezeichnet (jetzt wissen Sie, warum Sie einen Sender-Parameter bei der
158
Delegaten
Deklaration eines Ereignishandlers verwendet haben). Das Objekt, das die Meldung über das Ereignis erhält und darauf antwortet, wird als Empfänger (receiver) bezeichnet. Da nun in .NET alles etwas flexibler gehandhabt wird, kann auch jedes Objekt ein Ereignis auslösen und jedes Objekt kann ein Ereignis empfangen. Dafür bestehen kaum Einschränkungen. Diese Flexibilität fordert allerdings ihren Preis: Der Sender weiß vorher nie genau, wer der Empfänger sein wird, noch kümmert er sich darum. Der Sender weiß lediglich, das er ein Ereignis auslöst, das durch etwas anderes verarbeitet wird. Man braucht also eine Art Vermittler, etwas, das als Mittelsmann zwischen Sender und Empfänger fungiert. Zum Glück stellt die CLR einen Delegaten (Delegierter) zur Verfügung, eine speziellen Typ für einen solchen Vermittler. Ein Delegat ist eine Klasse, die einen Verweis auf eine Methode enthalten kann. Das mag noch nicht viel Sinn ergeben. Einfach ausgedrückt, agiert ein Delegat als Zeiger auf einen EreignisAbsender. Er zeigt den Weg zum Empfänger. In einem vereinfachten Football-Spiel beginnt das Spiel, sobald der Quarterback (der Absender) den Ball besitzt. Er muss den Ball zu jemand anderem (dem Empfänger) in seiner Mannschaft weiterspielen. Wenn das Spiel beginnt, verfügt der Quarterback über eine beliebige Zahl von möglichen Empfängern. Die Entwicklung des Spiels entscheidet darüber, wer den Ball tatsächlich erhält. Der Quarterback überschaut das Spielfeld, um zu entscheiden, wem er den Ball zuspielen soll. Manchmal versperren Spieler der gegnerischen Mannschaft die Sicht auf manche Empfänger, und zuweilen kann der Quarterback nicht alle der verfügbaren Empfänger sehen. Noch kurz bevor er den Ball wirft, weiß der Quarterback nicht, wer diesen empfängt (manchmal sogar noch nach dem Wurf). In unserem vereinfachten Spiel sieht jedoch der Trainer an der Seitenlinie alles aus einem besseren Blickwinkel. Daher sieht er (besser als es der Quarterback jemals können wird), wer der Empfänger sein soll. Durch einen Funkempfänger hinten am Helm des Quarterbacks ruft der Trainer: »Wirf den Ball Nummer 66 zu!« (Wir wollen die Frage mal ignorieren, ob dies legal ist.) Daraufhin wirft der Quarterback den Ball zum Empfänger, den der Trainer angegeben hat. Abbildung 5.2 illustriert dieses Konzept. In diesem Beispiel stellt der Trainer den Delegaten dar, den Vermittler zwischen Absender und Empfänger, wobei er das Ereignis (den Ball) in die richtige Richtung lenkt. In .NET kann ein Objekt (der Absender) ein Ereignis »werfen«. Der Ereignisempfänger kann in jedem anderen Mitglied der Absendermannschaft bestehen beziehungsweise der Klasse, der das Objekt angehört. Ein Delegat leitet die Ereignismeldung zum richtigen Empfänger. Wenn Sie in den Begriffen von Football denken, ergibt das durchaus einen Sinn!
159
Ereignisse in Windows Forms
Potenzielle Empfänger (Mannschaftsmitglieder des Quarterback)
22
66
8
17 Verteidigung
“Nummer 66”
13 Quarterback Trainer
Abbildung 5.2: Ein Football-Quarterback – der hier als Absender fungiert – hat eine beliebige Anzahl von Empfängern (für seinen Ball).
Wie sieht also ein Delegat in Codeform aus? Sie sind vielleicht überrascht zu erfahren, dass Sie bereits einige verwendet haben. Sehen Sie sich folgendes Codefragment an: 'VB .NET Addhandler Button.Click, new EventHandler(AddressOf method) //C# Button.Click += new EventHandler(this.method);
Sie erinnern sich, dass die Definition eines Delegaten in einer Klasse besteht, die eine Referenz auf eine Methode enthält. Die Implementierung einer Klasse ist ein Objekt. Die Delegaten in diesem Codestück sind die EventHandler-Objekte. Die Objekte ScrollEventHandler, ToolBarClickEventHandler und KeyPressEventHandler, die Sie bereits in vorhergehenden Lektionen benutzt haben, sind ebenfalls Delegaten. Tatsächlich ist jede Klasse in .NET, die das Wort EventHandler im Namen enthält, ein Delegat. Das Codestück dient also im Endeffekt dazu, dem Click-Ereignis des Button-Steuerelements Delegaten hinzuzufügen. Sie zeigen den Weg zum Empfänger des Ereignisses, in diesem Fall dem method-Parameter, welcher nur eine Methode ist.
160
Delegaten
Zu den unterschiedlichen Implementierungen in VB .NET und C#: In C# besteht die einzige Möglichkeit, einem Ereignis einen Delegaten hinzuzufügen, in dem Operator +=. (Für jene unter Ihnen, die mit C++ und C nicht vertraut sind, sei gesagt, dass += ein Kurzbefehl für das Summieren und Zuweisen ist.) Zum Beispiel ist myInteger += 1;
das Gleiche wie myInteger = myInteger + 1;
Um einen Delegaten von einem Ereignis zu lösen, verwenden Sie den Operator -= (oder in Visual Basic .NET die RemoveHandler-Methode).
In VB .NET verfügen Sie andererseits über eine Reihe weiterer Optionen. Die erste Wahlmöglichkeit – die Sie bereits eine Weile eingesetzt haben – besteht im Gebrauch der AddHandler-Methode. Die Syntax bietet kaum Schwierigkeiten. Diese Methode fügt den Delegaten (der auf method zeigt) dem Click-Ereignis des Button-Objekts hinzu. Der Operator AddressOf ist lediglich ein Schlüsselwort, das das Programmäquivalent eines Zeigers auf die bereitgestellte Methode erzeugt. Als zweite und weniger gebräuchliche Option gestattet VB .NET, das Schlüsselwort Handles zu verwenden. Wie in Listing 5.3 zu sehen, fügen Sie einer Methodendeklaration das Handles-Schlüsselwort hinzu, gefolgt vom Ereignis, das zu verarbeiten ist. Listing 5.3: Eine weitere Möglichkeit, Ereignisse zu verknüpfen 1:
public sub MyEventHandler(Sender as Object, e as EventArgs) Handles
btTemp.Click 2: 3:
'tu etwas end sub
Das funktioniert genauso gut wie die anderen Methoden. Ich empfehle
Bitte beachten Sie
Benutzen Sie in VB .NET möglichst immer die
Benutzen Sie die Handles-Methode bitte sparsam. Sie schränkt Ihre Möglichkeiten dadurch ein, dass man damit nur ein Ereignis pro Handler verarbeiten kann, und sie macht Code weniger gut lesbar.
AddHandler-Methode. Sie ist nicht nur die ver-
ständlichste Methode, sondern erlaubt Ihnen auch, denselben Handler für viele verschiedene Ereignisse zu verwenden. Benennen Sie Ihre Ereignishandler gemäß einer standardmäßigen Namenskonvention. Dies macht Ihren Code später viel einfacher zu lesen und zu verstehen.
161
Ereignisse in Windows Forms
5.3
Ereignisse und Objekte
Wir wollen uns nun der Implementierung von Delegaten zuwenden. Alle vordefinierten Delegaten in .NET besitzen zwei Parameter: ein Object, welches das Objekt darstellt, das das Ereignis erzeugte, und einen zweiten Parameter, der detaillierte Angaben über das erfolgte Ereignis bereitstellt. Der gebräuchlichste Delegat ist natürlich der altbekannte EventHandler. Sobald ein Ereignis auftritt, erzeugt dieser Delegat zwei Objekte (ein Object- und ein EventArgs-Objekt) und übergibt sie dem Ereignishandler oder Empfänger, der damit machen kann, was er will. Die folgenden Abschnitte befassen sich mit der Erstellung von Delegaten und benutzerdefinierten Ereignissen.
Ereignishandler Listing 5.4 zeigt einen typischen Ereignishandler in VB .NET. Er nimmt an, dass Sie bereits ein Button-Steuerelement erzeugt und ihm einen Delegaten hinzugefügt haben, der auf die HandleClick-Methode zeigt. Beachten Sie, dass das Ereignis Button.Click den standardmäßigen EventHandler-Delegaten verwendet. Listing 5.4: Ein typischer Ereignishandler 1: 2: 3:
private sub HandleClick(Sender as Object, e as EventArgs) Microsoft.VisualBasic.MsgBox(CType(Sender, Button).Text) end sub
Denken Sie daran, dass jeder Delegat zwei Objekte erzeugt und sie an den Ereignishandler weiterleitet. Dieser wiederum, egal ob er sie verwendet oder nicht, muss diese zwei Objekte als Parameter übernehmen, wie Zeile 1 zeigt. Das erste Objekt, das wir in Zeile 1 Sender genannt haben, stellt das Objekt dar, das das Ereignis erzeugt hat. In diesem Fall wäre das Objekt das zuvor erstellte Button-Objekt. Da der Delegat, der diese Methode aufruft, vom Typ EventHandler ist, ist der zweite Parameter vom Typ EventArgs. Dieser wird dazu verwendet, weitere Informationen über das Ereignis aufzunehmen, doch im Fall von EventArgs enthält er nichts; er wird nur als Platzhalter eingesetzt. Die Entwickler bei Microsoft, die für .NET und seine Klassenbibliotheken verantwortlich zeichnen, haben dankenswerterweise standardisierte Namenskonventionen verwendet. Egal wie der Name Ihres Delegaten lautet, der zweite Parameter folgt dem gleichen Namensschema. Beispiele dafür sind EventHandler und EventArgs, ScrollEventHandler und ScrollEventArgs etc.)
162
Ereignisse und Objekte
Sie könnten sich nun Folgendes fragen: Wenn der erste Parameter das das Ereignis erzeugende Objekt darstellt, warum erstellt dann nicht statt dessen der Delegat diesen Objekttyp? Zum Beispiel ein Button-Objekt in Listing 5.4 statt eines Object-Objekts? Der Grund liegt in der Flexibilität. Wenn der Delegat einen tatsächlichen Button-Typ weitergäbe, dann bräuchte man eine Menge Typen von Delegaten: einen für jeden Objekttyp, der ein Ereignis erzeugen könnte. Der Standard-EventHandler-Delegat wäre nicht ausreichend. Daher verkleidet der Delegat das Button-Objekt als ein Object. Eine weitere Analogie: Stellen Sie sich vor, Sie erhalten per Post ein Buch. Es dürfte sich in einer Schachtel befinden. Diese Schachtel stellt das Object dar. Das Transportunternehmen steckt das Buch in eine Standardschachtel, die sich für alles eignet. Das spart dem Unternehmen die Kosten für die Erzeugung einer jeweils anderen Schachtel für unterschiedliche Warentypen, die es transportiert. Sie zumindest wissen, dass sich in der Schachtel ein Buch befindet, auch wenn Sie mit der Schachtel wenig anfangen können, und lesen wollen Sie sie auch nicht. Sie müssen daher die Schachtel öffnen und das Buch herausholen. Grob gesagt, Sie transformieren die Schachtel in ein Buch. Etwas Ähnliches passiert in der Methode in Listing 5.4. Der erste Parameter wird als Object übergeben, welches über nur wenige nützliche Eigenschaften verfügt (siehe Tag 3). Wollen Sie also mit diesem ersten Parameter arbeiten, müssen Sie ihn daher erst in den notwendigen Typ umwandeln (mit anderen Worten: die Schachtel öffnen). In Zeile 2 des Listings 5.4 verwenden Sie die CType-Methode, um den ersten Parameter von einem Object in einen Button-Typ umzuwandeln, der dann über die gewünschte Text-Eigenschaft verfügt. In C# verwenden Sie den Casting-Operator. Das ist schlicht ein Klammernpaar, das den Zieltyp einklammert ((Button) Sender).Text;
Sie sollten das Absender-Objekt stets ganz explizit in den gewünschten Typ umwandeln. VB .NET kann (je nach der Komplexität des das Ereignis erzeugenden Objekttyps) diese Umwandlung automatisch ausführen, aber es wäre nicht besonders klug, sich darauf zu verlassen, dass VB .NET Ihre Arbeit verrichtet.
Benutzerdefinierte Ereignisse erstellen Mit unserem Wissen über das Wesen von Klassen, wie man sie einsetzt und wie man Ereignisse verarbeitet, wollen wir nun einen Schritt weitergehen. Im folgenden Abschnitt erzeugen wir eine eigene Klasse, die über ihre eigenen Ereignisse verfügt, für welche Sie – oder jeder andere Entwickler – Ereignishandler bereitstellen können. Da Sie noch nicht wissen, wie man seine eigenen UI-Steuerelemente erstellt, erscheint dieses Beispiel zwar etwas an den Haaren herbeigezogen, aber es ist dessen ungeachtet eine gute Lernübung (mehr über die Erstellung eigener Steuerelemente erfahren Sie an Tag 18).
163
Ereignisse in Windows Forms
In diesem Beispiel benötigen wir zweierlei: eine benutzerdefinierte Klasse, die das benutzerdefinierte Ereignis auslöst, und eine andere Klasse, die den Handler für das benutzerdefinierte Ereignis enthält (das kann eine gewöhnliche Windows Forms-Klasse sein). Wir erzeugen eine einfache Golfball-Klasse als Klasse, die unser benutzerdefiniertes Ereignis auslöst. Der Code dafür ist in Listing 5.5 zu finden. Listing 5.5: Die GlfBall-Klasse 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.Day5 { public class GolfBall { public event EventHandler Sunk; protected virtual void OnSunk(EventArgs e) { if (Sunk != null) { Sunk(this,e); } } public void Putt(int intStrength) { if (intStrength = 5) { OnSunk(new EventArgs()); } } }
In diesem Code gibt es eine Menge Neues zu entdecken. In Zeile 5 deklarieren Sie Ihre benutzerdefinierte GolfBall-Klasse. Mit dieser Klasse soll ein wirklicher Golfball nachgebildet werden. Der Einfachheit halber erzeugen wir nur eine Methode dafür, Putt, die das Einputten oder Einlochen eines Golfballs simuliert. Die Methode ist in den Zeilen 14 bis 18 zu finden (gleich mehr dazu). Logischerweise wird das einzige Ereignis nur dann ausgelöst, wenn der Golfball schließlich im Loch landet. Zeile 6 deklariert das benutzerdefinierte Ereignis für diese Klasse: Sunk (eingelocht). Beachten Sie, wie einfach diese Codezeile ist; sie besteht aus lediglich vier Wörtern. Das Ereignis wird genau wie eine Klasse deklariert, doch statt das class-Schlüsselwort zu benutzen, verwenden Sie das event-Schlüsselwort. Sie brauchen ihr keine weitere Funktionalität zu verleihen, schließlich sollen nicht Sie das Ereignis behandeln, sondern der Programmierer der Klasse. Sie müssen noch den Typ des Delegaten festlegen, der das Ereignis behandeln soll. In diesem Fall verwenden wir den Standard-EventHandler-Delegaten, obwohl wir auch unseren eigenen hätten verwenden können (mehr dazu später).
164
Ereignisse und Objekte
Die Zeilen 8 bis 12 deklarieren eine ungewöhnliche Art von Methode. Sie trägt den gleichen Namen wie unser benutzerdefiniertes Ereignis, nur dass ihr das Präfix On vorangestellt ist (z.B. OnSunk). Jedes benutzerdefinierte Ereignis muss eine entsprechende Methode OnEreignisName besitzen. Diese Methode dient nur dem einen Zweck, das Ereignis auszulösen, wie man aus Zeile 10 ersieht; keine andere Methode kann das Ereignis direkt aufrufen, sondern muss dafür über diese On-Methode gehen. Die On-Methode ist besonders interessant. Zunächst ist festzuhalten, dass sie einen Parameter des Typs EventArgs übernimmt – d.h. des Typs, der dem in Zeile 6 verwendeten Typ von EventHandler entspricht. (Sie werden gleich sehen, woher dieser Parameter stammt.) Als Nächstes ist festzuhalten, dass sie in Zeile 9 den Wert von Sunk, unserem Ereignis, auszuwerten scheint. Was bedeutet das konkret? In Zeile 6 haben Sie ein neues Ereignis deklariert, dafür aber weder eine Implementierung bereitgestellt noch eine Instanz davon erzeugt. Erinnern Sie sich daran, dass Sie von den meisten Objekten zuerst eine Instanz erzeugen müssen, bevor Sie das jeweilige Objekt benutzen können. Ein Ereignis funktioniert genauso. Indem Sie hier keine Instanz erzeugten, überlassen Sie dies dem Benutzer der GolfBall-Klasse. Ereignet sich etwas, erzeugt der Benutzer Ihrer GolfBall-Klasse eine Instanz, indem er dem Ereignis einen Delegaten zuweist. Etwa so: GolfBall myGolfBall = new GolfBall(); myGolfBall.Sunk += new EventHandler(this.eineMethode)
Bis das Ereignis einen Delegaten zugewiesen bekommt, ist es nicht instantiiert und trägt daher den Wert null (oder nothing in VB .NET). Der Zweck der On-Methode besteht darin zu prüfen, ob ein Delegat zugewiesen wurde. Dies erfolgt in Zeile 9. Falls Sunk, das Ereignis, nicht gleich null ist, dann bedeutet das, dass ein Delegat zugewiesen wurde und das Ereignis ausgelöst werden kann. Würden Sie diese Prüfung nicht vornehmen und es wäre kein Delegat zugewiesen, würden Sie beim ersten Auslösen des Ereignisses eine Fehlermeldung erhalten. Das in Zeile 6 deklarierte Ereignis verwendet einen Delegaten vom Typ EventHandler. Bekanntlich sendet der EventHandler-Delegat (wie jeder andere Delegat) zwei Parameter an den Ereignishandler: ein Object, welches das das Ereignis auslösende Objekt darstellt, und einen EventArgs-Parameter. Welches Objekt löst also unser Ereignis aus? Natürlich das GolfBall-Objekt, jene Klasse, in der sich all dieser Code befindet. Daher ist der dem Ereignis zu übergebende Parameter lediglich this, das für die aktuelle Klasse steht. Merke: Der erste Parameter zur Auslösung eines Ereignisses auf diese Weise ist stets this (oder me in VB .NET). Um mehr über den zweiten Parameter zu erfahren, müssen wir zu Zeile 14 springen. Diese Methode, Putt, führt die OnSunk-Methode unter bestimmten Bedingungen aus. Wollten Sie irgendwelche ereignisrelevanten Informationen übergeben, würden Sie sie
165
Ereignisse in Windows Forms
hier erzeugen. Da es aber für dieses Ereignis keine gibt, erzeugen wir einfach einen neuen EventArgs-Parameter und übergeben ihn an die OnSunk-Methode. Lassen Sie uns zusammenfassen. Als Erstes erzeugt der Benutzer unserer GolfBall-Klasse eine Instanz dieser Klasse und ein Delegat wird dem Sunk-Ereignis zugewiesen. Der Benutzer ruft die Putt-Methode auf, um zu versuchen, den »Golfball einzulochen«. Sobald festgestellt wurde, dass dem Putter genügend Kraft verliehen wurde (wie durch den InStrength-Parameter angegeben wird), wird die OnSunk-Methode ausgeführt, wobei ihr ein EventArgs-Parameter übergeben wird. Die OnSunk-Methode prüft wiederum, ob ein Delegat zugewiesen wurde. Für diesen Fall löst sie das Sunk-Ereignis aus und übergibt ihm eine Repräsentation des aktuellen Objekts und des EventArgs-Parameters. Wenn das Sunk-Ereignis ausgelöst wird, veranlasst der Delegat, dass der vom Benutzer zugeordnete Ereignishandler ausgeführt wird. Wir wollen uns als Nächstes einmal die Code-Seite des Benutzers der GolfBall-Klasse ansehen (im Gegensatz zu der des Endanwenders). Sie ist in Listing 5.6 zu sehen. Listing 5.6: Die Benutzerseite des GolfBall-Beispiels 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:
166
public class MainForm : Form { private Button btPutt = new Button(); private Label lblStrength = new Label(); private TextBox tbStrength = new TextBox(); private GolfBall gfBall = new GolfBall(); public MainForm(){ lblStrength.Text = "Spielstärke:"; lblStrength.Location = new Point(50,50); tbStrength.Text = 0.ToString(); tbStrength.Location = new Point(125,50); btPutt.Text = "Lochen Sie den Ball ein!"; btPutt.Location = new Point(100,100); btPutt.Click += new EventHandler(this.PuttBall); gfBall.Sunk += new EventHandler(this.BallSunk); this.Text = "Beispiel für ein angepasstes Ereignis"; this.Controls.Add(btPutt); this.Controls.Add(tbStrength); this.Controls.Add(lblStrength); } public void PuttBall(Object Sender, EventArgs e) {
Ereignisse und Objekte
27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38:
gfBall.Putt(Convert.ToInt32(tbStrength.Text)); } public void BallSunk(Object Sender, EventArgs e) { MessageBox.Show("Eingelocht!"); } public static void Main() { Application.Run(new MainForm()); } } }
Speichern Sie dieses und Listing 5.5 in einer einzigen Datei. In Listing 5.6 findet sich nichts Besonderes. In den Zeilen 2 bis 5 erzeugen Sie ein paar Steuerelemente, darunter auch eine Instanz der GolfBall-Klasse. Die Zeilen 8 bis 16 platzieren die Steuerelemente im Formular und stellen ein paar Eigenschaften ein. Die Steuerelemente erlauben es dem Benutzer, einen Spielstärke-Wert einzugeben und eine Schaltfläche anzuklicken, um den Ball »einzulochen«. In Zeile 18 fügen Sie der Sunk-Methode der GolfBall-Klasse einen Delegate hinzu, genau wie Sie das bei jeder anderen Klasse täten. Die Zeilen 20 bis 23 fügen Ihrem Formular alle Steuerelemente hinzu. Die PuttBall-Methode in Zeile 26 wird immer dann ausgeführt, wenn die in Zeile 2 deklarierte Schaltfläche angeklickt wird. Sie führt schlicht die SunkMethode der GolfBall-Klasse aus, welche bereits in Listing 5.5 in Zeile 14 deklariert worden war. Sie übergibt den Spielstärke-Wert, den der Benutzer in das Textfeld eingegeben hat. Jedes Mal wenn das Sunk-Ereignis ausgelöst wird, gelangt die BallSunk-Methode zur Ausführung. In unserem Fall wird Sunk aufgerufen, sobald die Putt-Methode mit einem Spielstärke-Wert von genau 5 aufgerufen wird. BallSunk (der Ball wurde eingelocht) ruft die Show-Methode der MessageBox-Klasse auf (die sich von der MsgBox-Funktion des Namensraums Microsoft.VisualBasic unterscheidet), um eine einfache Meldung anzuzeigen, die angibt, dass der Ball im Loch versenkt (daher »sunk«) wurde. Kompilieren Sie diese Anwendung und führen Sie sie aus. Tragen Sie verschiedene Werte in das Textfeld ein und beachten Sie, dass nichts passiert, wenn Sie auf die Schaltfläche klicken, es sei denn, Sie hätten einen Spielstärke-Wert 5 eingegeben. Das Ergebnis ist in Abbildung 5.3 zu sehen.
167
Ereignisse in Windows Forms
Abbildung 5.3: Unser benutzerdefiniertes Sunk-Ereignis in voller Aktion – der Benutzer gewinnt!
Steuerelemente sezieren Aufgrund des Wissens, über das Sie nun verfügen, können Sie eine Hypothese darüber aufstellen, wie Objekte, die Sie kennen, implementiert werden (was Ihnen helfen wird, sobald Sie Ihre eigenen Steuerelemente erstellen). Nehmen Sie das Button-Steuerelement als Beispiel. Obwohl Sie nicht wissen, wie es genau erstellt wurde, können Sie aufgrund dessen, was Sie heute gelernt haben, dennoch darauf schließen. Lassen Sie uns eine Eigenschaft, nämlich Text, und ein Ereignis, Click, genauer untersuchen (den Darstellungsvorgang wollen wir vorerst ignorieren; wir besprechen ihn an Tag 13). Wir wollen uns mit der Frage befassen, wie wir das heute Gelernte auf nützliche Objekte anwenden können. Als Erstes können Sie davon ausgehen, dass die Text-Eigenschaft eine einfache Variable ist, die wie folgt im Quellcode des Buttons deklariert wird: public string Text;
Als Nächstes muss die Button-Klasse das Click-Ereignis deklarieren, so wie im folgenden Codestück: public event EventHandler Click;
Da alle Ereignisse eine korrespondierende On-Methode besitzen müssen, deklarieren wir diese im nächsten Schritt: protected virtual void OnClick(EventArgs e) { if (Click != null) { Click(this, e); } }
Das war schon alles! In Listing 5.7 kommt alles zusammen.
168
Ereignisse und Objekte
Listing 5.7: Die extrapolierte Button-Klasse 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 System.Windows.Forms { public class Button : ButtonBase { public string Text; public event EventHandler Click; protected virtual void OnClick(EventArgs e){ if (Click != null){ Click(this,e); } } public Button(){ // Code zur Initialisierung und Anzeige der Schaltfläche } } }
Dieser Code ist natürlich vereinfacht. Wir wissen ja, dass das Button-Steuerelement über mehr als nur eine Eigenschaft und ein Ereignis verfügt. Tatsächlich wurde das Click-Ereignis von der Control-Klasse geerbt, daher müssten wir es eigentlich nicht hier deklarieren, aber das vermittelt Ihnen eine gute Vorstellung davon, was das Erstellen von Steuerelementen bedeutet.
Benutzerdefinierte Delegaten erstellen Wenn Sie Ihre eigenen benutzerdefinierten Ereignisse erzeugen, müssen Sie häufig auch Ihre eigenen benutzerdefinierten Delegaten und EventArgs-Objekte erzeugen. Den Delegaten zu erstellen, ist einfach; das EventArgs-Objekt ist etwas komplizierter, doch Sie sind bereits in der Lage, das anzupacken. Die Deklaration des Delegaten besteht aus einer Zeile mit dem delegate-Schlüsselwort: public delegate void MyEventHandler(Object Sender, MyEventArgs e);
Diese Zeile erzeugt einen neuen Delegaten namens MyEventHandler, der sich für jedes Ihrer benutzerdefinierten Ereignis verwenden lässt. Er stellt einen EventArgs-Parameter bereit, ein benutzerdefiniertes Objekt, das wir ebenfalls zu erstellen haben (beide Objekte befolgen die Standardnamenskonventionen). Genau wie bei einem Ereignis müssen Sie weder eine Implementierung noch Code für diesen Delegaten bereitstellen; die CLR erledigt das alles für Sie.
169
Ereignisse in Windows Forms
Zum Erstellen des zweiten Parameters gehört das Erzeugen Ihrer eigenen benutzerdefinierten Klasse mit den Eigenschaften, die Ihr Ereignis benötigt, wie in Listing 5.8 demonstriert wird: Listing 5.8: Eine benutzerdefinierte EventArgs-Klasse erstellen 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14:
using System; using System.Windows.Forms; namespace TYWinforms.Day5 { public class GolfBallEventArgs : EventArgs { public readonly int Meter; public readonly bool Save; public GolfBallEventArgs(int Meter,bool Save){ this.Meter = Meter; this.Save = Save; } } }
Diese Klasse namens GolfBallEventArgs werden wir nutzen, um einem Ereignishandler benutzerdefinierte Ereignisinformationen zukommen zu lassen. Sie erbt von der Klasse EventArgs, so dass wir keine Funktionen der Letzteren duplizieren müssen. In den Zeilen 6 und 7 deklarieren Sie zwei Eigenschaften: Meter, die angibt, aus welcher Entfernung der Golfball beim Einputten eingelocht wurde; und Save, die angibt, ob der Einputt-Schlag für Par gespeichert wurde. Diese Werte sind auf readonly (Nur-Lesen) gesetzt, so dass sie sich durch nichts anderes als durch den Konstruktor selbst ändern lassen. Dieses Vorgehen ist Standard, denn schließlich gilt: Nachdem diese Werte gesetzt sind, gibt es keinen Grund mehr, sie zu ändern. In VB .NET würden die entsprechenden Zeilen wie folgt aussehen: ReadOnly Meter as Integer ReadOnly Save as Boolean
In Zeile 9 stoßen wir auf den Konstruktor unserer GolfBallEventArgs-Klasse. Sie übernimmt zwei Parameter, nämlich Meter und Save, die mit den readonly-Eigenschaften, die gerade erstellt wurden, korrespondieren. Dieser Konstruktor dient lediglich dazu, die Parameterwerte den entsprechenden Eigenschaften der Klasse zuzuweisen. Wir wollen einmal unsere GolfBall-Klasse so ändern, dass sie diesen neuen Delegaten und das EventArgs-Objekt verwendet. Der neue Code, der auf dem modifizierten Listing 5.5 basiert, ist in Listing 5.9 zu sehen.
170
Ereignisse und Objekte
Listing 5.9: Den benutzerdefinierten Delegaten verwenden 1: using System; 2: using System.Windows.Forms; 3: using System.Drawing; 4: 5: namespace TYWinforms.Day5 { 6: public class GolfBallEventArgs : EventArgs { 7: public readonly int Meter; 8: public readonly bool Save; 9: 10: public GolfBallEventArgs(int Meter,bool Save){ 11: this.Meter = Meter; 12: this.Save = Save; 13: } 14: } 15: 16: public delegate void GolfBallEventHandler(Object Sender, GolfBallEventArgs e); 17: 18: public class GolfBall { 19: public event GolfBallEventHandler Sunk; 20: 21: protected virtual void OnSunk(GolfBallEventArgs e){ 22: if (Sunk != null){ 23: Sunk(this,e); 24: } 25: } 26: 27: public void Putt(int intStrength){ 28: if (intStrength == 5){ 29: Random rndGen = new Random(); 30: OnSunk(new GolfBallEventArgs(rndGen.Next(1,51), Convert.ToBoolean(rndGen.Next(0,2)))); 31: } 32: } 33: }
Die Zeilen 5 bis 14 umfassen die GolfBallEventArgs-Klasse, die wir gerade entwickelt haben (Listing 5.8). Zeile 16 enthält die Deklaration des Delegaten, den diese Klasse verwendet. Innerhalb der GolfBall-Klasse haben nur wenige Änderungen stattgefunden. In Zeile 19 deklarieren Sie das Sunk-Ereignis mit Hilfe des GolfBallEventHandler-Delegaten anstelle von EventHandler. Auf ähnliche Weise verwenden Sie in den Zeilen 21 und 30 GolfBallEventArgs statt EventArgs. Diesmal verhält sich die Putt-Methode jedoch ein wenig anders als gewohnt.
171
Ereignisse in Windows Forms
Weil sie das GolfBallEventArgs-Objekt jetzt mit zwei Werten versorgen muss, nämlich Meter und Save, müssen wir ein paar Überstunden einlegen. Es geht uns nicht darum, wie die Werte aussehen, Hauptsache, sie werden zurückgegeben. Daher übergeben wir einfach ein paar zufällige Zahlen. In Zeile 29 erzeugen wir eine Instanz der Random-Klasse, die alle Arten von Methoden enthält, die Zufallszahlen generieren, darunter auch die von uns verwendete Methode, Next. Sie übernimmt zwei Parameter, beide Integer, die einen Wertebereich angeben, aus dem eine Zufallszahl zurückgegeben wird (Next liefert einen GanzzahlInteger, ohne Dezimalstellen). Für Meter, den ersten Parameter, wählen wir irgendeine Zahl zwischen 1 und 50 aus (im Bereich darüber dürfte es kaum jemanden geben, der aus dieser Distanz einputten kann!). Für den zweiten Parameter benötigen wir einen booleschen Wert. Dieser kann True, False, 1 oder 0 sein. Daher benutzen wir Next, um eine Zufallszahl im Bereich zwischen 0 und 1 zurückzugeben (und da Next nur Ganzzahlen zurückgibt, muss das entweder 0 oder 1 sein, aber nichts dazwischen). Mit Hilfe der Convert.ToBoolean-Methode wandeln wir die zurückgegebene Zufallszahl in einen booleschen Wert um, um sie dem GolfBallEventArgsKonstruktor zu übergeben. Wir können den Ereignishandler für das Sunk-Ereignis so ändern, dass er dieses Objekt verwendet. Ändern Sie mit Hilfe der gleichen MainForm-Klasse aus Listing 5.6 die Zeile 31 wie folgt: MessageBox.Show("Eingelocht aus " + e.Meter.ToString() + " Metern Entfernung!");
Abbildung 5.4 zeigt das Ergebnis dieser letzten Änderung.
Abbildung 5.4: Unser benutzerdefiniertes Sunk-Ereignis mit dem Objekt GolfBallEventArgs gibt dem Benutzer Anlass zum Jubeln!
172
Zusammenfassung
5.4
Zusammenfassung
Ereignisse sind ein zentraler Bestandteil einer Windows Forms-Anwendung. Ohne sie würde man nichts damit erledigen können. Wie das Ereignissystem funktioniert, wissen Sie nun sowohl aus der Perspektive des Entwicklers als auch aus der des Benutzers. Ein Ereignishandler ist diejenige Methode, die ausgeführt wird, sobald ein Ereignis stattfindet. Zur Erstellung des Handlers gehört das Verknüpfen von Ereignis und Handler mit Hilfe der AddHandler-Methode in VB .NET, oder mit dem +=-Operator in C#. Ereignishandler weisen eine Standardsignatur auf, die nur wenige Variationen zulässt. Ein Delegat ist eine Klasse, die eine Referenz auf einen Ereignishandler enthält. Er stellt die »Drähte« zwischen einem Ereignis und seinen Handlern dar. In .NET befolgen alle Delegaten das Namensschema NameEventHandler. Delegaten übergeben den Ereignishandlern zwei Parameter: ein Object-Objekt, das das ereignisauslösende Objekt darstellt, und einen EventArgs-Parameter, der zusätzliche Informationen bereitstellt. Der EventArgsParameter befolgt das gleiche Namensschema wie der Delegat. Um Ihr eigenes (benutzerdefiniertes) Ereignis zu erstellen, müssen Sie es lediglich mit Hilfe des event-Schlüsselwortes deklarieren und einen passenden Delegaten dafür wählen. Jedes Ereignis muss eine entsprechende OnEreignisName-Methode besitzen, die zur Auslösung des Ereignisses verwendet wird. Diese Methode kann ebenso prüfen, ob ein Delegat »verdrahtet« wurde, indem sie überprüft, ob das Ereignis einen Wert null (oder nothing in VB .NET) ergibt. Mit Hilfe des delegate-Schlüsselworts können Sie Ihre eigenen Delegaten auf die gleiche Weise erstellen wie ein benutzerdefiniertes Ereignis. Ein Delegat benötigt weder Implementierung noch Code – die CLR erzeugt beides für Sie. Ihre benutzerdefinierten Delegaten können jeweils einen vordefinierten EventArgs-Parameter verwenden, oder Sie können Ihren eigenen erstellen, indem Sie eine Klasse erzeugen, die vom EventArgs-Objekt erbt. Ihr benutzerdefiniertes EventArgs-Objekt muss nur die benutzerdefinierten readonlyEigenschaften bereitstellen, die Sie wollen, sowie einen Konstruktor, um diesen Eigenschaften Werte zuweisen zu können.
5.5 F
Fragen und Antworten
Woher weiß man, welche Art von Delegat man für ein Ereignis benutzen muss? A
Leider gibt es keine leichte Methode das herauszufinden. In den meisten Fällen verwendet man den Standard-EventHandler-Delegaten, so dass man damit auf der sicheren Seite ist. Ist dies aber nicht der korrekte Delegat, dann wird Ihnen normalerweise Ihr Compiler (Visual Studio .NET oder die Befehlszeilencompiler
173
Ereignisse in Windows Forms
csc.exe und vbc.exe) mitteilen, welchen Sie verwenden sollten. In diesem Buch weisen wir normalerweise auf den passenden Delegaten darauf hin.
F
Kann ich einem einzelnen Ereignis mehr als einen Delegaten zuweisen? A
Durchaus. Sie dürfen dies tun, wenn Sie wünschen, dass ein Einzelereignis mehr als eine Aktion ausführt. In unserem Vergleich mit dem Auto entspräche dies einer Ihrer Aktionen (sagen wir, Sie treten auf das Gaspedal), aber mehreren Aktionen des Wagens (bewegt sich, die Tachonadel zittert, Ausschalten des Tempomaten usw.). Das ist aber keine gebräuchliche Praxis, da normalerweise ein Ereignishandler alle gewünschten Aktionen ausführen kann. Es ist jedoch eine schlaue Möglichkeit, Ereignishandler zu »erweitern«. Mal angenommen, Sie hätten mit ShowText und ShowTextAndAlert zwei Ereignisse. Sie müssen Text in einem Bezeichnungsfeld anzeigen, doch das zweite Ereignis muss außerdem ein Meldungsfenster mit einer Warnung anzeigen. Es besteht kein Grund dafür, den Code, der den Text zur Anzeige bringt, zu duplizieren. Daher kann man beiden Ereignissen einen einzigen Delegaten zuweisen. Das ShowTextAndAlert-Ereignis würde einen weiteren Delegaten zugewiesen bekommen, der aber das Anzeigen des Meldungsfeldes veranlasst. Sobald das ShowTextAndAlert-Ereignis ausgelöst wird, würden beide Delegaten ausgeführt werden, so dass Text angezeigt und ein Meldungsfeld geöffnet wird. Die Ereignishandler werden in der Reihenfolge ausgeführt, die ihnen die Delegaten zuweisen.
5.6
Workshop
Dieser Workshop soll Ihnen helfen, sich besser an die heute behandelten Begriffe zu erinnern. Es hilft Ihnen sehr, die Antworten vollständig zu verstehen, bevor Sie weiterlesen. Die Antworten zu den Quizfragen und den Übungen finden Sie in Anhang A.
Quiz 1. Wie sieht die standardmäßige Signatur eines Ereignishandlers aus? 2. Erzeugen Sie in C# ein Ereignis namens ShowText, das den Delegaten KeyPressEventHandler verwendet. 3. Erstellen Sie einen benutzerdefinierten Delegaten, der das Objekt KeyPressEventArgs verwendet.
174
Workshop
4. Wahr oder falsch? Um Objekttypen miteinander zu vergleichen, verwendet man den Gleichheitszeichenoperator (=). 5. Welche der folgenden Aussagen ist inkorrekt? AddHandler btOne.Click, new EventHandler(AddressOf btOne_Click) public sub MyEventHandler(Sender as Object, e as EventArgs) Handles btTemp.Click Addhandler btOne.Click += new EventHandler(AddressOf btOne_Click)
6. Warum sollten die Eigenschaften eines benutzerdefinierten EventArgs-Objekts readonly sein? 7. Ist das folgende Codestück korrekt? Was sollte man falls nötig ändern? public virtual void OnMyEvent(EventArgs e) { MyEvent(this, e); }
8. An welcher Stelle (im Quellcode) muss man benutzerdefinierte Ereignisse und Delegaten deklarieren?
Übung Erstellen Sie in C# eine Taschenrechner-Anwendung wie den Windows-Taschenrechner. Er sollte Zifferntasten aufweisen, mit denen sich Zahlen eingeben lassen, sowie Funktionstasten, die Berechnungen vornehmen, wenn man darauf klickt. Verwenden Sie einen Ereignishandler für alle Zifferntasten und einen Handler für alle Funktionstasten. (Tipp: Nehmen Sie verborgene Steuerelemente, also solche, deren Visible-Eigenschaft auf False gesetzt ist – damit können Sie temporäre Variablen speichern.)
175
Windows Forms mit Steuerelementen erweitern
6
Windows Forms mit Steuerelementen erweitern
In der heutigen Lektion runden Sie Ihr wachsendes Repertoire an Windows Forms-Steuerelementen ab. Bis jetzt haben Sie nur Menüs, Bildlaufleisten, Statusleisten, Symbolleisten, Textbox, Bezeichnungsfelder und Schaltflächen als Steuerelemente zu sehen bekommen. Heute erfahren Sie etwas über Kombinationsfelder und Optionsfelder, die dem Benutzer mehrere Auswahlmöglichkeiten bereitstellen, sodann Timer, die sich zur Zeitmessung von Ereignissen verwenden lassen, und schließlich Strukturansichten (Treeviews), mit denen der Benutzer das Dateisystem erkunden kann, und viele andere Steuerelemente. Sie lernen darüber hinaus, wie man die Windows Forms-Merkmale für automatisches Layout nutzt, um eine übersichtlichere und leichter zu pflegende Benutzeroberfläche zu präsentieren. Heute lernen Sie, wie Sie 쐽
vom Benutzer Informationen einholen und sie auf logische Art und Weise anzeigen,
쐽
den Benutzer zwingen, Entscheidungen zu treffen,
쐽
Benutzereingaben formatieren,
쐽
Grafiken in Ihren Anwendungen anzeigen,
쐽
zeitmessende Anwendungen erstellen ,
쐽
viele verfügbare Aufzählungen nutzen, um Ihre Steuerelemente anzupassen,
쐽
die Positionierung Ihrer Steuerelemente steuern.
Wenn Sie die heutige Lektion durcharbeiten, sollten Sie an ein paar Schlüsselaspekte bezüglich der Windows Forms-Steuerelemente denken. Jedes Windows Forms-Steuerelement im .NET Framework erbt direkt oder indirekt von der Control-Klasse, welche wiederum von der Object-Klasse erbt. Das bedeutet, dass diese Steuerelemente eine ganze Reihe von Eigenschaften und Methoden gemeinsam haben, darunter die GetTypeMethode, die Height- und Width-Eigenschaften, das Click-Ereignis und andere, die Sie heute kennen lernen. (Um eine vollständige Aufzählung dieser gemeinsamen Mitglieder zu erhalten, schlagen Sie bitte in Anhang B nach.) All diese Steuerelemente haben auch Regeln für ihre Verwendung gemeinsam. Sie werden sehen, dass Sie nach dem Erlernen des Umgangs mit einem Steuerelement auch mit den anderen gut zurechtkommen werden. Natürlich verfügt jedes Steuerelement über seine Eigenarten und eigenen Mitglieder, aber sie folgen alle dem gleichen Muster.
178
Das Steuerelement Button
6.1
Das Steuerelement Button
Das Steuerelement Button kennen Sie ja bereits. Seine grundlegendste Eigenschaft ist Text. Sie setzt die Aufschrift, die auf der Schaltfläche angezeigt wird, um dem Benutzer einen Hinweis darauf zu geben, was die Schaltfläche bewirkt. TextAlign positioniert die Aufschrift auf der Schaltfläche und kann die folgenden Werte der ContentAlign-Aufzählung annehmen: BottomCenter, BottomLeft, BottomRight, MiddleCenter, MiddleLeft, MiddleRight, TopCenter, TopLeft und TopRight – ein Wert für jede Position auf der Schaltfläche. Die FlatStyle-Eigenschaft gestattet Ihnen die Anpassung des Aussehens der Schaltfläche. Die Eigenschaft kann einen der Werte in der FlatStyle-Aufzählung annehmen: Flat, Popup, wobei die Schaltfläche flach aussieht, bis Sie mit der Maus darüber geraten, Standard als Standardwert oder System, bei dem sich das Aussehen der Schaltfläche nach dem Standard Ihres Betriebssystems richtet (wobei dieser Wert einem der drei vorhergehenden Werte entsprechen muss). Abbildung 6.1 zeigt die ersten drei Stile sowie die Verwendung der TextAlign-Eigenschaften.
Abbildung 6.1: Beachten Sie, dass sich die Beschriftung der Schaltflächen in diesen Beispielen für FlatStyle-Werte jeweils an einer anderen Position befindet. Das ist eine Funktion der Eigenschaft TextAlign.
Mit Button-Steuerelementen können Sie Grafiken auf zweierlei Weise darstellen. Sie können entweder die Eigenschaften Image und ImageAlign verwenden oder die Eigenschaften ImageList und ImageIndex (wie bereits bei den Symbolleisten an Tag 4). ImageAlign verwendet die gleichen Werte der ContentAlign-Aufzählung wie TextAlign, wohingegen Image ein Image-Objekt übernimmt: button1.Image = Image.FromFile("C:\WinForms\Day6\MyBitmap.bmp")
Sie wissen bereits, wie man Click, das Hauptereignis eines Button-Steuerelements verarbeitet. Das folgende Codestück zeigt die Zuweisung eines Delegaten zur Click-Methode und einen exemplarischen Ereignishandler: AddHandler Button1.Click, new EventHandler(AddressOf Me.Button1_Click) ... private sub Button1_Click(Sender as Object, e as EventArgs) MessageBox.Show("Sie haben angeklickt: " & Ctype(Sender, Button).ToString end sub
Das Button-Steuerelement besitzt die Methode PerformClick, die Ihnen die Simulation eines Schaltflächen-Klicks gestattet. Sie können also das Click-Ereignis genauso auslösen,
179
Windows Forms mit Steuerelementen erweitern
als hätte ein Benutzer die Schaltfläche angeklickt. Dieser Methode müssen Sie keine Parameter bereitstellen; die CLR wird sie für Sie generieren: Button1.PerformClick
Das ist recht nützlich, wenn Sie einmal den Handler des Click-Ereignisses aufrufen müssen; durch PerformClick brauchen Sie sich nicht mehr um die Erstellung von EventArgsObjekten usw. zu kümmern.
6.2
Die Steuerelemente CheckBox und RadioButton
Die Steuerelemente CheckBox und RadioButton sind einander sehr ähnlich. Beide gestatten dem Benutzer, eine (oder mehrere) Auswahl(en) aus einer Gruppe ähnlicher Elemente zu treffen. Wahrscheinlich haben Sie diese Steuerelemente bereits einmal beim Ausfüllen eines Webformulars benutzt. Sie unterscheiden sich dadurch, dass es das Kombinationsfeld CheckBox dem Benutzer gestattet, mehr als ein Element der Angebotsliste auszuwählen, während das Optionsfeld RadioButton nur eine Auswahl gestattet. Listing 6.1 zeigt ein Beispiel für die Verwendung dieser Steuerelemente. Listing 6.1: Ein Beispiel für den Einsatz der Steuerelemente RadioButton und CheckBox 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22:
180
Imports System Imports System.Windows.Forms Imports System.Drawing namespace TYWinforms.Day6 public class Listing61 : Inherits Form private lblColor as new Label private lblSex as new Label private private private private private private
chkColorBlue as new CheckBox chkColorRed as new CheckBox chkColorYellow as new CheckBox chkColorGreen as new CheckBox rbSexMale as new RadioButton rbSexFemale as new RadioButton
public sub New lblColor.Text = "Wählen Sie Ihre Lieblingsfarbe(n)" lblColor.Location = new Point(10,10) lblColor.AutoSize = True
Die Steuerelemente CheckBox und RadioButton
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: 51: 52: 53: 54: 55: 56: 57: 58: 59: 60: 61: 62: 63: 64: 65:
chkColorBlue.Text = "Blau" chkColorBlue.Location = new Point(10,25) chkColorBlue.Width = 50 chkColorRed.Text = "Rot" chkColorRed.Location = new Point(60,25) chkColorRed.Width = 50 chkColorYellow.Text = "Gelb" chkColorYellow.Location = new Point(110,25) chkColorYellow.Width = 60 chkColorGreen.Text = "Grün" chkColorGreen.Location = new Point(170,25) chkColorGreen.Width = 60 lblSex.Text = "Wählen Sie Ihr Geschlecht" lblSex.Location = new Point(10,50) lblSex.AutoSize = True rbSexMale.Text = "Männlich" rbSexMale.Location = new Point(10,75) rbSexMale.Width = 50 rbSexFemale.Text = "Weiblich" rbSexFemale.Location = new Point(60,75) rbSexFemale.Width = 60 Me.Controls.Add(lblColor) Me.Controls.Add(lblSex) Me.Controls.Add(chkColorBlue) Me.Controls.Add(chkColorRed) Me.Controls.Add(chkColorYellow) Me.Controls.Add(chkColorGreen) Me.Controls.Add(rbSexMale) Me.Controls.Add(rbSexFemale) end sub public shared sub Main() Application.Run(new Listing61) end sub end class end namespace
181
Windows Forms mit Steuerelementen erweitern
Dieses Listing ist sehr einfach aufgebaut. Alle hier verwendeten Steuerelemente werden in den Zeilen 8 bis 16 deklariert, und die Eigenschaften Text, Location und Width werden in den Zeilen 19 bis 49 festgelegt. Die Steuerelemente werden dann dem Formular in den Zeilen 51 bis 58 hinzugefügt. Listing 6.1 produziert das in Abbildung 6.2 dargestellte Ergebnis.
Abbildung 6.2: Die Steuerelemente RadioButton und CheckBox sind in Formularen sehr nützlich. CheckBox-Steuerelemente erlauben Ihnen, jede beliebige Kombination von Kästchen im Containersteuerelement auszuwählen, welches in diesem Fall das Formular ist. RadioButtons andererseits erlauben Ihnen nur eine Auswahl je übergeordnetem Steuerelement – also pro Formular in diesem Fall. Um getrennte Gruppen von RadioButtons mit nur jeweils
einem wählbaren Wert zu erstellen, gruppieren Sie die Steuerelemente durch Positionierung auf einem Panel-Steuerelement. (Ein Panel-Steuerelement gestattet lediglich die Gruppierung von Steuerelementen; fassen Sie einfach jeden Satz von RadioButton-Steuerelementen, die denselben Wert beschreiben, auf einem separaten Panel-Steuerelement zusammen.) RadioButtons, die sich auf verschiedenen übergeordneten Steuerelementen befinden, schließen sich gegenseitig aus. Die Steuerelemente CheckBox und RadioButton haben ein paar Eigenschaften gemein. Die Checked-Eigenschaft lässt sich dazu verwenden, zu prüfen oder zu bestimmen, ob das angegebene Steuerelement ausgewählt ist. Die CheckAlign-Eigenschaft ähnelt der TextAlignEigenschaft des Button-Steuerelements. Sie prüft, wie das Auswahlfeld bezüglich des Textes ausgerichtet ist. CheckAlign verwendet ebenfalls die ContentAlignment-Aufzählung. Die AutoCheck-Eigenschaft stellt fest, ob sich das Aussehen des Steuerelements automatisch ändern sollte, wenn es angeklickt wird. Sollte also ein Häkchen erscheinen, sobald die Auswahl angeklickt wurde? Setzen Sie diese Eigenschaft auf False, wenn Sie anhand der Checked-Eigenschaft das Steuerelement selbst mit einem Häkchen versehen wollen. Der typische Fall dafür träte ein, wenn eine Art von Gültigkeitsprüfung erfolgen müsste, bevor
182
Das Steuerelement ComboBox
ein Steuerelement angeklickt werden darf (etwa bei der Gültigkeitsprüfung von Benutzereingaben). Auch Appearance ist eine vielen Steuerelementen gemeinsame Eigenschaft. Mit Hilfe von Werten aus der Appearance-Aufzählung (Button oder Normal) bestimmt sie, ob das Steuerelement normal aussieht (Voreinstellung) oder als Schaltfläche erscheint, die sich ausoder einschalten lässt. Die Funktionalität ist die gleiche, doch dies bietet dem Benutzer ein leicht verändertes Erscheinungsbild der Benutzeroberfläche. Die beiden Steuerelemente haben ein Ereignis gemein: CheckChanged. Wie der Name schon andeutet, tritt es auf, sobald das Kontrollhäkchen für das Steuerelement gesetzt oder entfernt wird. Auf Grund seiner etwas komplexeren Funktionsmerkmale verfügt das CheckBox-Steuerelement über einige weitere Eigenschaften. Die CheckState-Eigenschaft ähnelt der CheckedEigenschaft, bietet aber etwas mehr Möglichkeiten. Sie muss einen der Werte aus der CheckState-Aufzählung annehmen: Checked, Unchecked oder Indeterminate. Die ersten beiden bieten die gleiche Funktion wie die Checked-Eigenschaft (s.o.), während Indeterminate einen dritten Zustand des Steuerelements beschreibt; das Steuerelement ist mit Häkchen versehen, doch grau dargestellt, so dass es den Eindruck vermittelt, nur teilweise »angekreuzt« zu sein. Fügen Sie in Listing 6.1 nach Zeile 25 folgende Zeile hinzu und kompilieren Sie die Anwendung neu, um diesen Zustand zu sehen: chkColorBlue.CheckState = CheckState.Indeterminate
Per Voreinstellung können Sie diesen »unbestimmten« Zustand nur im Code auswählen. Wenn Sie jedoch die ThreeState-Eigenschaft auf true setzen, dann kann auch der Benutzer auf diesen Zustand umschalten. Um mit der CheckState-Eigenschaft fortzufahren: Das Ereignis CheckStateChanged wird ausgelöst, sobald diese Eigenschaft sich ändert, was doch dem Vorgang bei CheckChanged recht ähnlich ist, wenn sich die Eigenschaft Checked ändert. Da sowohl CheckBox als auch RadioButton von derselben Klasse erben wie das ButtonSteuerelement (ButtonBase), teilen sie viele der gleichen Eigenschaften: Text, TextAlign, PerformClick und FlatStyle, um nur ein paar Beispiele zu nennen.
6.3
Das Steuerelement ComboBox
Das ComboBox-Steuerelement (Kombinationsfeld) ist recht interessant; es kombiniert ein editierbares Textfeld (wie eine TextBox) mit einer Dropdown-Liste, aus der der Benutzer vorgegebene Optionen wählen kann. Wegen dieser zweifachen Funktionalität verfügt das Steuerelement über eine Reihe von Eigenschaften, um sein Aussehen zu bestimmen und ihm Wahlmöglichkeiten zuzuweisen.
183
Windows Forms mit Steuerelementen erweitern
Das Kombinationsfeld instantiieren Das Erstellen dieses Steuerelements verläuft wie bei jedem anderen auch: dim cboMyList as new ComboBox
Sie können die Eigenschaften Top, Left oder Location dazu verwenden, das Steuerelement im Formular zu positionieren, sowie die Eigenschaften Font, BackColor und andere, allen Steuerelementen zugängliche Eigenschaften, um sein Aussehen anzupassen. Sie können sogar die Text-Eigenschaft nutzen, um eine Zeichenfolge in der Textbox-ähnlichen Sektion des Steuerelements anzuzeigen. Bei den interessanteren Eigenschaften geht es jedoch um das Füllen der Dropdown-Liste. Die einfachste Möglichkeit, dem Kombinationsfeld solche Elemente hinzuzufügen, besteht in der Verwendung der Items-Auflistung und der Methoden Add oder AddRange. Die erste fügt der Liste ein einzelnes Element hinzu, die zweite ein komplettes Array von Objekten. Listing 6.2 demonstriert beide Methoden. Listing 6.2: Einer Dropdown-Liste in einer ComboBox neue Elemente hinzufügen 1: Imports System 2: Imports System.Windows.Forms 3: Imports System.Drawing 4: 5: namespace TYWinforms.Day6 6: 7: public class Listing62 : Inherits Form 8: private cboMyList as new ComboBox 9: 10: public sub New 11: cboMyList.Location = new Point(75,50) 12: cboMyList.Text = "Wählen Sie ein Element aus" 13: cboMyList.Items.Add("Single Item") 14: cboMyList.Items.AddRange(new Object() {"Erster im Bereich", "zweiter im Bereich ", "Dritter im Bereich "}) 15: 16: Me.Text = "Listing 6.2" 17: Me.Controls.Add(cboMyList) 18: end sub 19: 20: public shared sub Main() 21: Application.Run(new Listing62) 22: end sub 23: end class 24: end namespace
184
Das Steuerelement ComboBox
Wir fangen an, indem wir in den Zeilen 13 und 14 Elemente hinzufügen (gleich mehr dazu). Zeile 12 legt den Text fest, der im Textfeld des Steuerelements angezeigt wird. Dieser Text erscheint, falls kein anderes Element der Liste ausgewählt wurde. Auf diese Weise fungiert er stellvertretend als Standardwert oder -auswahl. Zeile 13 fügt der Liste mit Hilfe der Add-Methode ein einzelnes Element hinzu. Zeile 14 fügt der ComboBox ein Array hinzu. Sowohl die Add- als auch die AddRange-Methode übernehmen Object-Datentypen als Parameter. Hier erzeugen Sie Objekte vom Typ string, dem gebräuchlichsten Typ, doch Sie können leicht andere Typen hinzufügen. Wenn Sie der ComboBox wirklich einen anderen Objekttyp hinzufügen, dann stellen Sie bitte sicher, dass die Eigenschaft DisplayMember der Eigenschaft des Objekts entspricht, das Sie anzeigen wollen. So zum Beispiel die Text-Eigenschaft eines Button-Objekts: cboMyList.Items.Add(new Button()) cboMyList.DisplayMember = "Text"
Wenn Sie jedoch keine Eigenschaft für die Anzeige angeben, führt die CLR automatisch die ToString-Methode am fraglichen Objekt aus und zeigt das Ergebnis an. Beachten Sie bitte, dass Zeile 14 ein neues Object-Array erzeugt und es in derselben Zeile mit Werten füllt. Sie hätten anstelle dieses Codes auch folgende Zeilen als Alternative verwenden können, um das Gleiche zu erzielen: dim arrList as Object() = {"erstes im Bereich", "zweites im Bereich", "drittes im Bereich"} cboMyList.Items.AddRange(arrList)
Die Wahl zwischen diesen beiden Vorgehensweisen ist Ihnen überlassen. Abbildung 6.3 zeigt das Ergebnis des Listings. Statt die AddRange-Methode zu verwenden, um mehrere Werte auf einmal hinzuzufügen, können Sie auch die DataSource-Eigenschaft auf ein Objekt-Array setzen. Das folgende Codestück bewirkt das Gleiche wie Zeile 14 in Listing 6.2: cboMyList.DataSource = new Object() {"erstes im Bereich", "zweites im Bereich", "drittes im Bereich"}
Mit Hilfe von DataSource können Sie die Elemente der ComboBox leicht auf jede beliebige Auflistung von Objekten setzen. An Tag 9 werden Sie eine weitere Einsatzmöglichkeit für diese Eigenschaft im Zusammenhang mit Datenbanken kennen lernen. Wenn Sie der ComboBox mit Hilfe der Add-Methode viele Elemente hinzufügen, rufen Sie als Erstes die BeginUpdate-Methode auf: cboMyList.BeginUpdate()
185
Windows Forms mit Steuerelementen erweitern
Diese Methode zwingt die Anwendung, mit dem Aktualisieren der Oberfläche der ComboBox so lange zu warten, bis alle Elemente hinzugefügt worden sind. Das Aktualisieren der Benutzeroberfläche ist ein zeitraubender Vorgang, und wenn Sie viele Elemente auf einmal hinzuzufügen haben, könnten die Aktualisierungen Ihre Anwendung praktisch zum Stillstand bringen. Wenn Sie mit dem Hinzufügen von Elementen fertig sind, rufen Sie die EndUpdate-Methode auf: cboMyList.EndUpdate()
Abbildung 6.3: Hier können Sie das Einzelelement ebenso sehen wie die Bereichselemente, die wir unserem Beispiel für das ComboBoxSteuerelement hinzugefügt haben.
Die Anzeige des Steuerelements steuern DropDownStyle ist die erste Eigenschaft, die Sie kennen müssen, um die Anzeige der ComboBox zu steuern. Diese Eigenschaft kontrolliert das Aussehen und die Bedienung des Steuerelements und kann die Art und Weise der Interaktion des Benutzers mit der ComboBox ändern. Diese Eigenschaft muss auf einen der Werte der ComboBoxStyle-Aufzählung gesetzt
sein: 쐽
DropDown: Das ist der Standardwert. Der Benutzer kann den Textbereich bearbeiten und muss einen Pfeil anklicken, um die Dropdown-Inhalte ansehen zu können.
쐽
DropDownList: Der Benutzer kann den Textbereich nicht bearbeiten. Der DropdownBereich ist der gleiche wie beim DropDown-Wert.
쐽
Simple: Der Benutzer kann den Textbereich bearbeiten und die Dropdown-Liste wird
stets angezeigt (es gibt also keinen anzuklickenden Pfeil, um die Liste aufzuklappen, obwohl eine Bildlaufleiste vorhanden sein kann). Sobald Sie diese Eigenschaft festgelegt haben, gibt es eine Reihe weiterer Eigenschaften, mit denen sich das Aussehen des Textbereichs anpassen lässt. MaxLength legt die Anzahl derjenigen Zeichen fest, die maximal in das Textfeld eingegeben werden können (wenn
186
Das Steuerelement ComboBox
aber der Benutzer ein Element aus der Liste auswählt, das mehr Zeichen hat als MaxLength erlaubt, wird trotzdem der Gesamttext des Elements angezeigt). SelectedText gibt immer den momentan im Textbereich markierten Wert zurück. Um zu steuern, welcher Teil des angezeigten Textes markiert wird, verwenden Sie die Eigenschaften SelectionStart und SelectionLength. Die erste übernimmt einen Integer, der das Zeichen angibt, mit dem die Markierung beginnt. Die zweite Eigenschaft bestimmt, wie viele Zeichen nach der SelectStart-Position markiert werden. Die Methoden Select und SelectAll erlauben Ihnen, einen Teil oder die Gesamtheit des Textes im Textbereich zu markieren. SelectAll übernimmt keine Parameter, aber Select übernimmt zwei Integerwerte, die den zu markierenden Zeichenbereich angeben. Text zu markieren ist häufig nützlich, wenn es notwendig ist, Elemente in der ComboBox zu aktualisieren oder neue einzufügen. Auch die Dropdown-Liste verfügt über mehrere eigene Eigenschaften. DroppedDown zeigt an, ob die Dropdown-Liste gerade angezeigt wird. DropDownWidth gibt ähnlich wie MaxLength die Anzahl der Zeichen an, die in der Liste angezeigt werden können. Die Maßeinheit lautet hier allerdings Pixel statt Zeichenzahl. MaxDropDownItems gibt die Anzahl der Elemente an, die auf einmal angezeigt werden, falls der Benutzer auf die Dropdown-Liste klickt. Wenn sich in der Liste mehr Elemente befinden als MaxDropDownItems, erscheint an der Seite der Liste eine Bildlaufleiste, um dem Benutzer zu gestatten, mehr Elemente anzusehen. Zwei Eigenschaften betreffen die Höhe des Kombinationsfeldes. ItemHeight gibt die Höhe jedes Listenelements in Pixeln an. Diese Eigenschaft erlaubt keine Anpassung der Elementhöhe, nur die Betrachtung der Elemente (es sei denn, Sie überschreiben das Standardverhalten des Steuerelements, worüber Sie an Tag 18 mehr erfahren). Der Wert der Eigenschaft PreferredHeight wird vom Betriebssystem des Benutzers zugewiesen und gibt die tatsächliche Höhe des Steuerelements an. Schließlich können Sie noch die Sorted-Eigenschaft nutzen, um der ComboBox zu befehlen, die Listenelemente automatisch (alphabetisch) zu sortieren. Dies gilt sowohl für vorhandene Elemente als auch für jedes neu hinzugefügte Element. Wollen Sie diese Funktion, dann setzen Sie Sorted auf True, wenn nicht, dann auf False.
Die ComboBox verwenden Da Sie nun dem Benutzer alle Werte in der ComboBox zur Auswahl stellen, müssen Sie wissen, wie Sie die Auswahl kontrollieren und überwachen. Zwei der gebräuchlichsten ComboBox-Mitglieder sind die SelectedIndex-Eigenschaft und das SelectedIndexChangedEreignis. Listing 6.3 zeigt ein Beispiel, in dem diese Mitglieder eingesetzt werden.
187
Windows Forms mit Steuerelementen erweitern
Listing 6.3: Die Auswahl, die der Benutzer getroffen hat, überwachen 1: Imports System 2: Imports System.Windows.Forms 3: Imports System.Drawing 4: 5: namespace TYWinforms.Day6 6: 7: public class Listing63 : Inherits Form 8: private cboMyList as new ComboBox 9: 10: public sub New 11: cboMyList.Location = new Point(75,50) 12: cboMyList.Text = " Wählen Sie ein Element!" 13: dim arrList as Object() = {"erstes im Bereich", "zweites im Bereich", "drittes im Bereich "} 14: cboMyList.Items.AddRange(arrList) 15: AddHandler cboMyList.SelectedIndexChanged, new EventHandler(AddressOf Me.HandleSelect) 16: 17: Me.Text = "Listing 6.3" 18: Me.Controls.Add(cboMyList) 19: end sub 20: 21: public sub HandleSelect(Sender as Object, e as EventArgs) 22: MessageBox.Show("Sie haben folgendes Element ausgewählt: " & cboMyList.SelectedIndex.ToString) 23: end sub 24: 25: public shared sub Main() 26: Application.Run(new Listing63) 27: end sub 28: end class 29: end namespace
Dieses Listing ähnelt dem Listing 6.2. Die ComboBox wird in den Zeilen 13 und 14 gefüllt, wobei diesmal nur ein Array benutzt wird. In Zeile 15 wird dann dem SelectedIndexChanged-Ereignis ein Delegat zugewiesen. Er tritt nur dann in Aktion, wenn der Benutzer ein neues Listenelement auswählt. Der Handler HandleSelect für dieses Ereignis beginnt in Zeile 21. Er besteht aus einer einzigen Codezeile. Mit Hilfe der Methode MessageBox.Show zeigen Sie dem Benutzer eine Meldung an, in der Sie angeben, welches Listenelement er ausgewählt hat. Denken Sie daran, dass alle Listen in .NET nullbasiert sind (d.h. die Zählung ihrer Elemente beginnt
188
Das Steuerelement DateTimePicker
bei 0 statt bei 1), so dass bei Auswahl des zweiten Elements durch den Benutzer das Meldungsfeld »Element 1« als ausgewählt zeigen wird. Abbildung 6.4 zeigt das Ergebnis, das Listing 6.3 produziert.
Abbildung 6.4: SelectedIndex zeigt die Indexnummer des ausgewählten
Listenelements an.
In den meisten Fällen werden Ihnen diese beiden Mitglieder genügend Kontrolle über das Steuerelement geben. Es gibt noch eine Reihe weiterer nützlicher Methoden: FindString und FindStringExact. Die erste Methode sucht und liefert den Index für das erste Listenelement, das mit der angegebenen Zeichenfolge beginnt. In Listing 6.3 würde folgendes Codestück die Zahl 0 zurückgeben: cboMyList.FindString("1st") FindStringExact hingegen gibt das erste Listenelement zurück, das der (gesuchten) Zei-
chenfolge exakt entspricht. Das obige Codestück würde nichts zurückgeben, weil es keine Elemente gibt, die nur den Text »1st« enthalten. Diese Methode erweist sich als nützlich, wenn man in einer ComboBox nach einem bestimmten Wert suchen muss. Insbesondere ist sie für den Benutzer von Vorteil, wenn die Liste recht umfangreich ist. Kurzum: Die ComboBox ist ein sehr leistungsfähiges Steuerelement; Sie müssen bloß wissen, wie Sie es einsetzen.
6.4
Das Steuerelement DateTimePicker
Gemäß der Voreinstellung verhält sich das Steuerelement DateTimePicker recht ähnlich wie die ComboBox; es verfügt über einen editierbaren Textbereich und eine aufklappbare Liste. Doch besteht der Textbereich aus einem änderbaren Datum und die »Liste« aus einem interaktiven Kalender. Abbildung 6.5 zeigt ein typisches DateTimePicker-Steuerelement. Dieses Steuerelement präsentiert uns eine sehr leistungsfähige Benutzeroberfläche. Der Benutzer kann im Steuerelement das Datum ändern, indem er es direkt in den Textbe-
189
Windows Forms mit Steuerelementen erweitern
reich einträgt oder indem er eines aus dem Kalenderbereich auswählt. Der Kalenderbereich verfügt über Schaltflächen, mit deren Hilfe der Benutzer monatsweise vor und zurück springen kann. Er kann auch Monate auswählen, indem er nach einem Klick auf die Titelleiste aus der herunterklappenden Liste einen Monat auswählt. Das Beste aber kommt noch: Der DateTimePicker gestattet nur die Auswahl oder Eingabe von realen, gültigen Daten. Daher kann ein Benutzer niemals das Datum »57. Macomber 1345« eingeben, wie sehr er es auch versuchen mag.
Abbildung 6.5: Ein DateTimePicker stellt Ihnen Daten und Uhrzeiten zur Auswahl bereit.
Der DateTimePicker weist eine Reihe von Eigenschaften auf, die sich zur Anpassung des Kalenderaussehens nutzen lassen: Eigenschaft
Wird zur Einstellung von x benutzt
CalendarFont
die im Kalender benutzte Schriftart
CalendarForeColor
die Farbe des Textes
CalendarMonthBackground
die Farbe hinter dem Monat
CalendarTitleBackColor
die Farbe hinter dem Titel
CalendarTitleForeColor
die Farbe des Titeltextes
CalendarTrailingForeColor
die Farbe der im Kalender nachfolgenden Datumswerte (die nicht mehr zum aktuellen Monat gehören)
Tabelle 6.1: So gestalten Sie den Kalender.
Sie können das Erscheinungsbild ganz Ihren Wünschen anpassen. Die Format-Eigenschaft erlaubt Ihnen zudem, die Anzeigeform der Daten im Textbereich zu steuern. Diese müssen die Werte aus der DateTimePickerFormat-Aufzählung aufweisen: 쐽
Custom: ein angepasstes Anzeigeformat; verwenden Sie die CustomFormat-Eigenschaft.
쐽
Long: das vom Betriebssystem des Benutzers ausgewählte lange Datumsformat. Zum Beispiel »Mittwoch, 7. November 2001«.
190
Das Steuerelement DateTimePicker
쐽
Short: das vom Betriebssystem des Benutzers ausgewählte kurze Datumsformat. Zum Beispiel »7.11.2001«
쐽
Time: Die vom Betriebssystem des Benutzers vorgenommene Formatierung der Zeitangabe. Zum Beispiel »9:48:25«
Falls das Format auf DateTimePickerFormat.Custom eingestellt ist, können Sie die CustomFormat-Eigenschaft dazu verwenden, die Art und Weise anzupassen, wie Datum und Zeit angezeigt werden. Diese Eigenschaft benutzt speziell formatierte Zeichenfolgen, um Datums- und Zeitangaben darzustellen. Das folgende Codestück würde »01. Juni, 0930« anzeigen: dtpMyDate.CustomFormat = "dd. MMMM, HHmm"
Tabelle 6.2 führt alle verfügbaren Zeichenfolgen auf (Achtung: bei den Zeichenfolgenwerten ist die Groß-/Kleinschreibung zu berücksichtigen). Formatzeichenfolge
Beschreibung
d
Tagesangabe mit einer oder zwei Ziffern
dd
Tagesangabe mit zwei Ziffern
ddd
Drei-Zeichen-Abkürzung für Wochentag
dddd
Vollständiger Wochentagsname
h
Ein- oder Zwei-Ziffern-Ausgabe der Stunde im 12-Stunden-Format (z.B. 1 p.m.)
hh
Zwei-Ziffern-Ausgabe der Stunde im 12-Stunden-Format
H
Ein- oder Zwei-Ziffern-Ausgabe der Stunde im 24-Stunden-Format (z.B. 1300 Uhr)
HH
Zwei-Ziffern-Ausgabe der Stunde im 24-Stunden-Format
m
Ein- oder Zwei-Ziffern-Ausgabe der Minute
mm
Zwei-Ziffern-Ausgabe der Minute
M
Ein- oder Zwei-Ziffern-Ausgabe des Monats
MM
Zwei-Ziffern-Ausgabe des Monats
MMM
Drei-Zeichen-Abkürzung für Monat
MMMM
Vollständiger Monatsname
Tabelle 6.2: Datum- und Zeit-relevante Zeichenfolgen für CustomFormat
191
Windows Forms mit Steuerelementen erweitern
Formatzeichenfolge
Beschreibung
s
Ein- oder Zwei-Ziffern-Ausgabe der Sekunde
ss
Zwei-Ziffern-Ausgabe der Sekunde
t
Einbuchstabige Abkürzung für AM/PM (z.B. wird »AM« als »A« angezeigt)
tt
Zweibuchstabige Abkürzung für AM/PM
y
Ein- oder Zwei-Ziffern-Ausgabe der Jahreszahl (z.B. wird »2001« als »1« angezeigt)
yy
Die letzten beiden Ziffern der Jahreszahl
yyyy
Alle vier Ziffern der Jahreszahl
Tabelle 6.2: Datum- und Zeit-relevante Zeichenfolgen für CustomFormat (Forts.)
Die Value-Eigenschaft gibt ein DateTime-Objekt zurück, das die gerade im Steuerelement angezeigte Zeit zurückgibt. MaxDate und MinDate geben die maximalen (am weitesten in der Zukunft liegenden) und minimalen (am weitesten in der Vergangenheit liegenden) Daten zurück, die der Benutzer aus dem Kalender auswählen kann. Diese Eigenschaften übernehmen DateTime-Objekte als Werte. Das folgende Codestück setzt das MinimumDatum auf den 20. Juni 1985 fest: dtpMinDate = new DateTime(1985, 6, 20) DropDownAlignment übernimmt einen Wert aus der LeftRightAlignment-Aufzählung, um anzugeben, nach welcher Seite des Textbereichs der Kalender ausgerichtet sein soll. Mögliche Werte dafür sind LeftRightAlignment.Left (Standardwert) und LeftRightAlignment.Right.
Es gibt eine Reihe von Möglichkeiten, wie Sie dem Benutzer gestatten können, das Datum im Textbereich zu ändern. Bei der ersten Version (Standardeinstellung) kann der Benutzer den Wert eingeben. Der DateTimePicker erlaubt nur gültige Einträge (der genaue Typ kann von der Format-Eigenschaft abhängen), daher müssen Sie sich nicht um ungültige Daten kümmern. Die zweite Methode erlaubt es dem Benutzer, ein Auf-Ab-Steuerelement zu verwenden (in der Art einer kleinen Bildlaufleiste), um die Werte zu ändern. Für diese Methode müssen Sie die ShowUpDown-Eigenschaft auf True setzen. Setzt man ShowCheckBox auf True, wird ein Kontrollkästchen neben dem Datums im Textbereich angezeigt. Dadurch kann der Benutzer signalisieren, dass er ausdrücklich das angezeigte Datum auswählt. Das kann sich als nützlich erweisen, wenn Sie vom Benutzer verlangen, dass er einen Datumsbereich angibt. Indem er das Kontrollkästchen deaktiviert lässt, könnte der Benutzer ein Open-End- oder ein Startdatum angeben. Verwenden Sie die Checked-Eigenschaft, um herauszufinden, ob das Kontrollkästchen gerade angekreuzt ist.
192
Das Steuerelement ImageList
Es gibt eine paar wichtige Ereignisse im Steuerelement DateTimePicker. ValueChanged wird ausgelöst, sobald sich der Wert im Textbereich ändert, ob nun durch direkte Bearbeitung oder durch eine Auswahl aus dem Kalender. Die CloseUp- und DropDown-Ereignisse finden statt, sobald der Kalenderbereich des Steuerelements geschlossen respektive geöffnet wird. Sie könnten diese Ereignisse ausnutzen, um Gültigkeitsprüfungen auszuführen, etwa um zu sehen, ob ein ausgewähltes Datum in einen gültigen Bereich fällt, bevor Sie dem Benutzer erlauben fortzufahren.
6.5
Das Steuerelement ImageList
Wir haben das ImageList-Steuerelement bereits an Tag 4 besprochen, so dass wir uns damit nicht allzu lange aufhalten wollen. Die herausragende Eigenschaft von ImageList ist Images, welche eine Auflistung von Grafiken aufnimmt, die sich von anderen Teilen Ihrer Anwendung nutzen lassen. Um Bilder hinzuzufügen, verwenden Sie einfach die AddMethode, etwa so: private ImageList ilstToolbar = new ImageList(); ilstToolbar.Images.Add(Image.FromFile("i_open.bmp ")); ilstToolbar.Images.Add(Image.FromFile("i_maximize.bmp "));
Um Bilder zu entfernen, verwenden Sie Remove, wobei Sie den Index des zu entfernenden Bildes angeben. Es gibt nur wenige weitere Eigenschaften: ColorDepth, die zu jedem gelisteten Bild dessen Anzahl an Farben angibt (ausgedrückt als Bit-Wert: 4 Bit, 8 Bit usw.); ImageSize, die sich für die Größenänderung der Bilder einsetzen lässt; und schließlich TransparentColor, welche eine Farbe im Bild durchsichtig machen kann, wodurch Dinge hinter dem Bild zum Vorschein kommen. Listing 6.4 zeigt ein typisches Beispiel einer ImageList, die mit einem Button-Steuerelement interagiert. Listing 6.4: Die Verwendung von ImageList in C# 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12:
using System; using System.Windows.Forms; using System.Drawing; namespace TYWinForms.Day6 { public class Listing64 : Form { private ImageList ilstButton = new ImageList(); private Button btImage = new Button(); public Listing64() { ilstButton.Images.Add(Image.FromFile("i_open.bmp"));
193
Windows Forms mit Steuerelementen erweitern
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:
ilstButton.Images.Add(Image.FromFile("i_maximize.bmp")); ilstButton.Images.Add(Image.FromFile("i_happy.bmp")); btImage.ImageList = ilstButton; btImage.ImageIndex = 0; btImage.Location = new Point(100,100); btImage.Click += new EventHandler(this.CycleImages); this.Text = "Listing 6.4"; this.Controls.Add(btImage); } public void CycleImages(Object Sender, EventArgs e) { if (btImage.ImageIndex == ilstButton.Images.Count-1) { btImage.ImageIndex = 0; } else { btImage.ImageIndex += 1; } } public static void Main() { Application.Run(new Listing64()); } } }
Die ImageList wird in den Zeilen 12 bis 14 mit Bildern gefüllt (diese Zeilen sollten auf tatsächlich vorhandene Bilder zeigen). Button verfügt wie viele Windows Forms-Steuerelemente über eine ImageList-Eigenschaft, die die Zuweisung einer ImageList zu diesem Steuerelement zulässt. Zeile 16 weist die ImageList dem Button-Steuerelement zu. Zeile 17 stellt die Schaltfläche so ein, dass sie zunächst das erste Bild in der Liste anzeigt. Zeile 18 positioniert die Schaltfläche auf dem Formular und Zeile 19 fügt dem Click-Ereignis einen Delegaten hinzu. Der Ereignishandler CycleImages (Zeile 25) ändert das auf der Schaltfläche angezeigte Bild, führt aber zuvor Prüfungen durch. Klickt der Benutzer auf die Schaltfläche, soll das nächste Bild angezeigt werden. Dies wird erreicht, indem einfach die ImageIndex-Eigenschaft nach oben gezählt (inkrementiert) wird (Zeile 29). Sobald man jedoch beim letzten Bild in der Liste angelangt ist, ändert sich das Bild mangels Vorrat nicht mehr. In diesem Fall setzt man den ImageIndex auf 0 zurück, so dass der Hochzählzyklus von neuem beginnen kann. In Zeile 26 wird eine Prüfung durchgeführt, um herauszufinden, ob der aktuelle Wert ImageIndex-Wert bereits auf dem letzten Listenwert (Count –1) angelangt ist. Ist das der Fall, startet ImageIndex wieder auf 0, andernfalls wird auf den nächsten Wert weitergezählt.
194
Das Steuerelement ListBox
Abbildung 6.6 zeigt das Ergebnis dieses Code-Beispiels.
Abbildung 6.6: Weist man einem Button eine ImageList zu, führt dies zur Anzeige von Grafiken statt Text auf der Schaltfläche.
6.6
Das Steuerelement ListBox
Das ListBox-Steuerelement (Listenfeld) ähnelt dem ComboBox-Steuerelement (Letzteres besteht aus einer Kombination von ListBox und TextBox). Ihnen gemeinsam sind solche Mitglieder wie Items, DataSource, DisplayMember, SelectedIndex, FindString usw. Sowohl ListBox als auch ComboBox sind von derselben Basisklasse abgeleitet, nämlich ListControl. Das die ListBox keine Kombination von Elementen darstellt, ist sie weitaus spezialisierter in ihren Aufgaben als die ComboBox. Daher verfügt sie über einige Mitglieder mehr. Mit Hilfe der ListBox lassen sich dem Benutzer mehrere Elemente in einer Liste anzeigen. Eine ListBox ist stets sichtbar, denn sie wird nicht wie die Dropdown-Liste in der ComboBox ausgeblendet. Und anders als dort kann der Benutzer in der ListBox mehrere Elemente auf einmal auswählen, indem er dabei einfach die (Strg)- oder (ª)-Taste gedrückt hält. Dieses Verhalten der ListBox bedingt auch eine komplexere Funktionalität mit sich. Das Beispiel in Listing 6.5 verwendet fast alle verfügbaren Eigenschaften von ListBox. Listing 6.5: Die Verwendung des ListBox-Steuerelements mit C# 1: 2: 3: 4: 5: 6: 7: 8: 9: 10:
using System; using System.Windows.Forms; using System.Drawing; namespace TYWinForms.Day6 { public class Listing65 : Form { private ListBox lbItems = new ListBox(); public Listing65() {
195
Windows Forms mit Steuerelementen erweitern
11: 12: 13: 14:
lbItems.Location = new Point(75,75); lbItems.MultiColumn = true; lbItems.ColumnWidth = 75; lbItems.SelectedIndexChanged += new EventHandler(this.HandleSelect); lbItems.SelectionMode = SelectionMode.MultiExtended;
15: 16: 17:
Object [] arrColors = {"Weiss", "Rot", "Orange", "Gelb", "Grün", "Blau", "Indigo", "Violett", "Schwarz"}; lbItems.Items.AddRange(arrColors);
18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29:
this.Text = "Listing 6.5"; this.Controls.Add(lbItems); } public void HandleSelect(Object Sender, EventArgs e) { ListBox lbTemp = (ListBox)Sender; int i; if (lbTemp.SelectedIndices.Count == 1 ) { lbItems.BackColor = Color.FromName(lbTemp.SelectedItem.ToString()); } else { for (i = 0; i < lbTemp.SelectedIndices.Count; i++) { MessageBox.Show("Sie haben folgendes Element ausgewählt: " + lbTemp.SelectedItems[i].ToString()); } }
30: 31: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41:
} public static void Main() { Application.Run(new Listing65()); } } }
Die Zeilen 11 bis 18 enthalten die meisten für uns interessanten Eigenschaften. Zeile 11 kennen Sie ja bereits; sie legt die Position des Steuerelements im Formular fest. Die ListBox kann mehrere Spalten von Elementen zugleich anzeigen. Wenn Sie MultiColumn wie in Zeile 12 auf true setzen, erzeugt die ListBox so viele Spalten wie nötig sind, um ihre Elemente aufzunehmen, damit der Benutzer keinen Bildlauf nach unten ausführen muss. (Beachten Sie, dass diese Bildlauffunktion bereits im ListBox-Steuerelement eingebaut ist; daher müssen Sie sich nicht um die betreffenden Ereignisse kümmern.) Die Abbildung 6.7 zeigt ein Beispiel für dieses Konzept.
196
Das Steuerelement ListBox
Multicolumn = true; (Spalten werden auf angemessene Weise erzeugt, so dass vertikales Scrollen nicht nötig ist) Element 1 Element 6 Element 2 Element 7 Element 3 Element 8 Element 4 Element 5
Multicolumn = false; (Voreinstellung) (Der Benutzer muss vertikal scrollen, um alle Elemente sehen zu können)
Element 1 Element 2 Element 3 Element 4 Element 5 Element 6 Element 7 Element 8
Abbildung 6.7: MultiColumn gibt an, ob sich Listenelemente horizontal oder vertikal scrollen lassen.
Zeile 13 legt einfach die Breite jeder Spalte fest, sofern MultiColumn auf true gesetzt ist. Zeile 14 weist dem SelectedIndexChanged-Ereignis einen Delegaten zu, genau wie beim gleichnamigen Ereignis in der ComboBox. Die Zeile 15 legt den SelectionMode der ListBox fest. Diese Eigenschaft bestimmt, wie der Benutzer Elemente auswählen kann (Mehrfach- oder Einzelauswahl usw.). Die möglichen Werte der SelectionMode-Aufzählung sind: 왘
MultiExtended: Der Benutzer kann mehrere Elemente mit Hilfe der (ª)-, (Strg)- und Pfeiltasten auswählen. (Dies ist die übliche Vorgehensweise,
um Mehrfachauswahl zu gestatten.) 왘
MultiSimple: Der Benutzer kann mehrere Elemente auswählen, indem er
auf eines nach dem anderen klickt. Jeder weitere Klick nimmt ein neues Element in die bestehende Auswahl auf, daher ist keine Zusatztaste wie etwa (ª) oder (Strg) nötig. 왘
None: Es können keine Elemente ausgewählt werden.
왘
One: Es kann nur ein Element ausgewählt werden.
In den Zeilen 17 und 18 erstellen Sie schließlich ein Array von Zeichenfolgenobjekten und weisen es der ListBox mit Hilfe der AddRange-Methode zu. Beachten Sie, dass wir hier Farbennamen verwenden. Gleich werden Sie sehen, wie diese Farben eingesetzt werden. Springen wir hinunter in Zeile 24: Hier ist der Ereignishandler für das Ereignis SelectedIndexChanged zu finden. Zunächst sind in dieser Methode zwei Variablen zu erstellen: eine ListBox und ein Integer. Die erste Variable wird als
Abkürzung zum Objekt verwendet, das das Ereignis erzeugt hat. Denken Sie daran, dass die Sender-Variable zuerst in den richtigen Typ zu konvertieren ist, um sie benutzen zu können: ((ListBox)Sender).eigenschaft
Um Ihnen zu ersparen, den Typ jedes Mal konvertieren zu müssen, tun Sie das einmal in Zeile 25 und verwenden ab jetzt die neue lbTemp-Variable, die nun
197
Windows Forms mit Steuerelementen erweitern
identisch mit dem Objekt lbItems ist, das dieses Ereignis generiert hat. Dieser Vorgang ist zwar nicht unbedingt nötig, erspart aber einiges an Tipparbeit. Es gibt zwei mögliche Situationen: Der Benutzer hat ein Element markiert, und der Benutzer hat mehr als ein Element markiert. Im Einzelelement-Fall wollen wir die Hintergrundfarbe der ListBox auf die gewählte Farbe einstellen. In der Mehrfachelement-Situation können wir offensichtlich den Hintergrund der ListBox nicht auf mehrere Farben gleichzeitig setzen; statt dessen zeigen wir einfach eine Meldung an, die den Benutzer über seine Auswahl informiert (eigentlich wird nur seine letzte Auswahl in der Meldung angezeigt). In Zeile 28 benutzen Sie die SelectedIndices-Eigenschaft, die die Indizes der ausgewählten Elemente zurückgibt, ganz gleich, wie viele Elemente ausgewählt worden sind. Sollte die Anzahl der Indizes in SelectedIndices (wird durch die Count-Eigenschaft angegeben) gleich 1 sein, dann wissen Sie, dass nur ein Element ausgewählt wurde. In Zeile 29 verwenden Sie dann die FromName-Methode des Color-Objekts, um den richtigen Color-Wert je nach dem ausgewählten Element zurückzugeben. Denken Sie daran, dass die SelectedItem-Eigenschaft ein String-Objekt liefert, so dass Sie die ToString-Methode verwenden müssen, um statt dessen die Zeichenfolgen-Darstellung zu erhalten. Die Zeilen 30 bis 33 behandeln jenen Fall, bei dem es mehr als eine Auswahl gibt. Mit Hilfe der Integer-Variablen i, die Sie zuvor erzeugt haben, führen Sie eine Programmschleife durch jedes der ausgewählten Elemente aus. Die forSchleife setzt die Variable i auf 0 und fährt fort, sie zu inkrementieren (und den Code in der Schleife auszuführen), bis sie nicht mehr kleiner als die Anzahl der ausgewählten Indizes ist (welche durch SelectedIndices.Count angegeben wird). Der Code in der Programmschleife verwendet die MessageBox.ShowMethode, um eine Meldung an den Benutzer auszugeben. SelectedItems ist eine Auflistung der ausgewählten Elemente (ähnlich wie SelectedIndices eine Auflistung der Indexzahlen der ausgewählten Elemente ist). Das war's schon. Abbildung 6.8 zeigt das Ergebnis, nachdem eine einzelne Farbe ausgewählt wurde (die Hintergrundfarbe der ListBox hat sich geändert) und dann mehrere Elemente. Es gibt noch ein paar weitere Mitglieder der ListBox kennen zu lernen. ScrollAlwaysVisible lässt sich auf true setzen, damit die ListBox ständig eine senkrechte Bildlaufleiste anzeigt, selbst wenn alle Elemente auch ohne Bildlauf sichtbar wären. UseTabStops ist eine interessante Eigenschaft. Falls das Element oder der Text, den Sie in der ListBox anzeigen wollen, Tabulatorzeichen enthält, veranlasst das Setzen dieser Eigenschaft auf true die normale Anzeige dieser Tabulatoren. Ist sie jedoch auf false gesetzt,
werden die Tabulatorzeichen zu Leerzeichen umgewandelt.
198
Das Steuerelement PictureBox
Abbildung 6.8: Die ListBox gestattet die Mehrfachauswahl.
Die ListBox verfügt über eine Text-Eigenschaft, die sich von den Text-Eigenschaften aller anderen Steuerelemente unterscheidet. Wurde ein Element bereits ausgewählt, dann gibt Text den Text dieses Elements zurück. Wurden mehrere Elemente ausgewählt, gibt Text den Text des ersten ausgewählten Elements zurück. Wenn Sie jedoch versuchen, Text gleich einem Wert zu setzen, dann sucht es diesen Text und wählt dieses Element genau wie die FindStringExact-Methode aus. Der folgende Code würde beispielsweise das Element mit dem Text »Hallo Welt« auswählen (vorausgesetzt, es gibt ein Element mit diesem Text): lbTemp.Text = "Hallo Welt";
6.7
Das Steuerelement PictureBox
Das Steuerelement PictureBox ist sehr einfach. Seine einzige Aufgabe besteht in der Anzeige einer Grafik. Werfen wir einen Blick auf seine Eigenschaften. Die wahrscheinlich wichtigste ist wohl die Image-Eigenschaft. Sie gibt an, welches Bild die PictureBox anzeigen wird. Bei diesem Bild kann es sich um praktisch jede Grafikdatei handeln, so etwa im GIF-, JPG- oder BMP-Format. Zum Beispiel: dim pbMyPicture as new PictureBox pbMyPicture.Image = Image.FromFile("i_happy.bmp")
Stellen Sie auf jeden Fall sicher, dass das zu verwendende Bild eine gültige, also vorhandene Datei ist und Sie dafür die richtige Pfadangabe bereitstellen (Grafikdateien werden üblicherweise im selben Ordner wie die Anwendung gespeichert). SizeMode steuert, wie die Grafiken angezeigt werden und nimmt einen der folgenden Werte der PictureBoxSizeMode-Aufzählung an:
199
Windows Forms mit Steuerelementen erweitern
쐽
AutoSize: Die PictureBox passt sich an die Größe der enthaltenen Grafik an.
쐽
CenterImage: Das Bild wird in der Mitte der PictureBox angezeigt. Ist das Bild größer als die PictureBox, werden seine äußeren Ränder abgeschnitten.
쐽
Normal: Das Bild wird an der linken oberen Ecke der PictureBox ausgerichtet. Ist das Bild größer als die PictureBox, werden seine äußeren Ränder abgeschnitten.
쐽
StretchImage: Das Bild wird entweder gestaucht oder gestreckt, um die PictureBox
vollständig auszufüllen. An Tag 13 erfahren Sie, wie man Bildlaufleisten in Verbindung mit der PictureBox einsetzt, um in einem Bild zu navigieren, das größer als die PictureBox ist.
6.8
Das Steuerelement TabControl
Im Betriebssystem Windows findet man häufig Fenstern, die in der Art von Karteikarten gestaltet sind – Fenster mit mehreren so genannten Registerkarten (auch als Tabs oder Tabseiten bezeichnet), die bestimmte Funktionen gruppieren. Abbildung 6.9 beispielsweise zeigt das Fenster EIGENSCHAFTEN VON ANZEIGE in Windows, das über fünf Registerkarten verfügt. Ähnlich wie die ToolBar- und MainMenu-Steuerelemente besteht auch TabControl aus dem Hauptsteuerelement und mehreren untergeordneten Steuerelementen. Jede Tabseite wird durch ein TabPage-Steuerelement dargestellt. Um dem TabControl eine neue Tabseite hinzuzufügen, ruft man einfach die Add-Methode auf: TabControl tcMain = new TabControl(); tcMain.TabPages.Add(new TabPage("Tab 1");
Diese Steuerelemente sind am einfachsten mit Hilfe eines Beispiels zu verstehen. Es ist ein recht umfangreiches Beispiel, weswegen ich es auf mehrere Abschnitte aufteilen werde, um die Untersuchung zu erleichtern. Der erste Teil, das Anwendungsgerüst, ist in Listing 6.6 zu sehen. Listing 6.6: So erzeugen Sie in C# Registerkarten für Ihre Anwendung. 1: 2: 3: 4: 5: 6: 7:
200
using System; using System.Windows.Forms; using System.Drawing; namespace TYWinForms.Day6 { public class Listing66 : Form {
Das Steuerelement TabControl
8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27:
private TabControl tcMain = new TabControl(); private TabPage tpGeneral = new TabPage("Allgemein"); private TabPage tpDisplay = new TabPage("Anzeige"); private TabPage tpLocation = new TabPage("Position"); private TabPage tpAdvanced = new TabPage("Extras"); private private private private private private private private
Label lbl1Name = new Label(); TextBox tb2Color = new TextBox(); Button bt2Color = new Button(); TextBox tb3Top = new TextBox(); TextBox tb3Left = new TextBox(); Button bt3Location = new Button(); TextBox tb4Tab = new TextBox(); Button bt4Tab = new Button();
public static void Main() { Application.Run(new Listing66()); } } }
Abbildung 6.9: Mit dem Steuerelement TabControl lassen sich Fenster mit Registerkarten erstellen.
201
Windows Forms mit Steuerelementen erweitern
Dieses Listing ist sehr einfach. Die passenden Namensräume werden in den Zeilen 1 bis 3 importiert. Die Klasse und die Namensräume werden in den Zeilen 5 und 7 deklariert und alle benötigten Steuerelemente in den Zeilen 8 bis 21. Zu diesen gehören das TabControl, vier TabPage- und diverse Button- und Label-Steuerelemente. Zeile 23 deklariert die Methode Main, die wie üblich lediglich die Run-Methode aufruft. Listing 6.7 zeigt den Konstruktor für diese Klasse, der zwischen die Zeilen 22 und 23 des Listings 6.6 platziert werden sollte. Listing 6.7: Beispiel für einen TabControl-Konstruktor 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:
202
public Listing66() { // Tabseite 1 lbl1Name.Text = "Listing 6.6: Windows Forms in 21 Tagen"; lbl1Name.AutoSize = true; lbl1Name.Location = new Point(10,75); // Tabseite 2 tb2Color.Location = new Point(25,75); bt2Color.Text = "Ändern!"; bt2Color.Location = new Point(125,75); bt2Color.Click += new EventHandler(this.ChangeColor); // Tabseite 3 tb3Top.Text = this.DesktopLocation.Y.ToString(); tb3Top.Location = new Point(25,50); tb3Left.Text = this.DesktopLocation.X.ToString(); tb3Left.Location = new Point(25,75); bt3Location.Text = "Ändern!"; bt3Location.Location = new Point(125,75); bt3Location.Click += new EventHandler(this.ChangeLocation); // Tabseite 4 tb4Tab.Location = new Point(25,50); bt4Tab.Text = "Neuer Tab!"; bt4Tab.Location = new Point(75,75); bt4Tab.Click += new EventHandler(this.AddTab); tpGeneral.Controls.Add(lbl1Name); tpDisplay.Controls.Add(tb2Color); tpDisplay.Controls.Add(bt2Color); tpLocation.Controls.Add(tb3Top);
Das Steuerelement TabControl
35: 36: 37: 38: 39: 40: 41: 42: 43: 44: 45: 46: 47: 48: 49:
tpLocation.Controls.Add(tb3Left); tpLocation.Controls.Add(bt3Location); tpAdvanced.Controls.Add(tb4Tab); tpAdvanced.Controls.Add(bt4Tab); tcMain.Width = this.Width; tcMain.Height = this.Height; tcMain.TabPages.Add(tpGeneral); tcMain.TabPages.Add(tpDisplay); tcMain.TabPages.Add(tpLocation); tcMain.TabPages.Add(tpAdvanced); this.Text = "Listing 6.6"; this.Controls.Add(tcMain); }
Dieser Teil des Codes ist in Abschnitte für jede Registerkarte aufgeteilt. Unser Entwurf erfordert vier Registerkarten: »Allgemein«, die allgemeine Informationen zur Anwendung anzeigt; »Anzeige«, die dem Benutzer die Anpassung der Farben der Anwendung erlaubt; »Position«, die dem Benutzer erlaubt, die Position der Anwendung auf dem Desktop mit Programmschritten anzupassen; und schließlich »Extras«, die dem Benutzer das Hinzufügen weiterer Tabseiten zur Anwendung gestattet. Die Zeilen 2 bis 5 richten die Steuerelemente ein, die auf der ersten Tabseite erscheinen werden. Hier haben wir lediglich ein Label-Steuerelement. In den Zeilen 8 bis 12 findet die Initialisierung der zweiten Tabseite statt. Wir erzeugen eine TextBox, in der der Benutzer eine neue Farbe eintragen kann, sowie eine Schaltfläche, um den Wert zu bestätigen. (Der Ereignishandler ChangeColor ist unten in Listing 6.8 zu finden.) Die Tabseite 3, in den Zeilen 15 bis 22 zu finden, enthält zwei Textfelder (eines für den oberen Rand der Anwendung und eines für den linken) und eine Schaltfläche, um die neuen Werte übernehmen zu können. Tabseite Nummer 4 weist ein Textfeld und eine Schaltfläche auf. (Beide Ereignishandler für diese Steuerelemente finden sich unten in Listing 6.8.) Nichts Aufregendes also bis jetzt. Als Nächstes müssen wir die Steuerelemente den passenden Tabseiten hinzufügen. Dies erfolgt ähnlich wie das Hinzufügen von Steuerelementen zu einem Formular: mit Hilfe der Controls.AddMethode. Die Zeilen 31 bis 38 fügen alle vorgestellten Steuerelemente in die entsprechenden Tabseiten ein. Die Zeilen 40 bis 45 stellen die Eigenschaften für das zentrale TabControlObjekt ein. Nun müssen wir alle Tabseiten dem TabControl hinzufügen, analog dem Einfügen von Steuerelementen in Tabseiten. In Zeile 48 müssen Sie das TabControl dem Form hinzufügen.
203
Windows Forms mit Steuerelementen erweitern
Sie können die Anwendung bereits in dieser Form kompilieren (vergessen Sie jedoch nicht, zuvor die Zeilen 12, 22 und 29 in Listing 6.7 auszukommentieren – diese Zeilen würden Fehler verursachen, da wir die entsprechenden Ereignishandler noch nicht erstellt haben). Beachten Sie, dass die Registerkarten bereits voll funktionsfähig sind: Sie können darin navigieren, ohne dafür extra Code geschrieben zu haben! Wir wollen die Ereignishandler aus Listing 6.8 näher untersuchen. Dieser Code sollte nach dem Konstruktor eingefügt werden, jedoch erst hinter der Main-Methode aus Listing 6.6 (beachten Sie, dass der Code nicht unbedingt hier stehen muss; das ist lediglich ein Vorschlag). Listing 6.8: Ereignisverarbeitung mit dem TabControl 1: public void ChangeColor(Object Sender, EventArgs e) { 2: int i; 3: 4: for (i = 0; i < tcMain.TabPages.Count; i++) { 5: tcMain.TabPages[i].BackColor = Color.FromName(tb2Color.Text); 6: } 7: } 8: 9: public void ChangeLocation(Object Sender, EventArgs e) { 10: this.DesktopLocation = new Point(Convert.ToInt32 (tb3Top.Text), Convert.ToInt32(tb3Left.Text)); 11: } 12: 13: public void AddTab(Object Sender, EventArgs e) { 14: tcMain.TabPages.Add(new TabPage(tb4Tab.Text)); 15: }
Die Zeilen 1 bis 7 umfassen die ChangeColor-Methode. Sie ist dafür zuständig, die vom Benutzer angegebene Farbe zu übernehmen und sie auf die Applikation anzuwenden. Die Methode wird ausgeführt, sobald die bt2color-Schaltfläche auf der 2. Tabseite angeklickt wird. Das Ändern der Farbe ist jedoch nicht so einfach, wie es aussieht. Man könnte die BackColor-Eigenschaft des Formulars auf die neue Farbe umstellen, doch da die Tabseiten das gesamte Formular überdecken, würde man die Farbänderung nicht sehen. Daher muss man die Farbe der Tabseiten selbst ändern. Zeile 4 verwendet eine weitere for-Schleife, um von der ersten Tabseite bis zur letzten (wie durch TabPages.Count angegeben) zu zählen. In jeder TabPage im TabControl-Steuerelement setzen Sie die BackColor-Farbe auf die vom Benutzer angegebene. Verwenden Sie die FromName-Methode des Color-Objekts, um den eingegebenen Text in einen Color-Wert umzuwandeln.
204
Das Steuerelement TabControl
Die Zeilen 9 bis 11 enthalten die ChangeLocation-Methode, die das Formular auf der Benutzeroberfläche bewegt, wobei Werte aus der 3. Tabseite berücksichtigt werden. Diese Methode ist sehr einfach: Sie benutzen lediglich die Eigenschaft DesktopLocation des Form-Objekts, um das Formular auf den benutzerdefinierten Koordinaten zu positionieren. Denken Sie daran, den Text in den Textfeldern jeweils mit Hilfe der Convert.ToInt32-Methode zu einem Integer umzuwandeln, wie in Zeile 10 zu sehen. Die AddTab-Methode in Zeile 13 ist schließlich die einfachste von allen. Sie erstellt eine neue Tabseite und fügt sie dem TabControl-Objekt hinzu. Der Text, den der Benutzer in tb4Tab angibt, wird als Titel der Tabseite verwendet. Kompilieren Sie die vollständige Anwendung und experimentieren Sie mit dem Funktionsumfang. Abbildung 6.10 zeigt das Ergebnis, nachdem eine neue Tabseite hinzugefügt wurde.
Abbildung 6.10: Mit dem TabControl-Steuerelement können Sie dynamisch weitere Tabseiten erstellen.
Es gibt noch ein paar TabControl-Eigenschaften, die Sie kennen sollten. Das TabControl hat die gleichen SelectedIndex- und SelectedIndexChanged-Mitglieder wie die Steuerelemente ComboBox und ListBox, so dass Sie damit bereits umgehen können. Zudem besitzt es eine SelectedTab-Eigenschaft, die das TabPage-Objekt zurückgibt, das gerade ausgewählt ist. Anstelle von Text für den Titel der Tabseite, wie Sie ihn in den Listings 6.6 bis 6.8 verwendet haben, kann TabControl auch Grafiken verwenden. Erstellen Sie einfach wie immer eine ImageList und weisen Sie sie der ImageList-Eigenschaft des TabControl-Steuerelements zu. Mit Hilfe der Alignment-Eigenschaft können Sie die Positionierung der Tabseiten im Formular ändern. Diese Eigenschaft übernimmt einen der Werte aus der TabAlignment-Aufzählung: Bottom, Left, Right oder Top. Eine kleine Änderung, die Sie hier vornehmen, kann Ihrer Anwendung ein völlig neues Aussehen verleihen.
205
Windows Forms mit Steuerelementen erweitern
Auch das TabControl verfügt über eine Appearance-Eigenschaft. Sie verwendet Werte aus der TabAppearance-Aufzählung und bestimmt, wie die einzelnen Tabseiten angezeigt werden sollen. Mögliche Werte sind Buttons, FlatButtons und Normal. Die ersten beiden Optionen vermitteln den visuellen Eindruck von Schaltflächen statt Registern, doch die Funktionalität ist die gleiche. Einige der Eigenschaften betreffen die Größe der Registerkarten. ItemSize holt oder setzt die Breite und Höhe der Registerkarten. In der Standardeinstellung passt sich die Registerkarte automatisch ihrem Inhalt an. Die Padding-Eigenschaft ändert den Abstand zwischen den Elementen auf der Tabseite und deren Rändern. Diese Eigenschaft übernimmt jedoch keinen Integerwert, sondern einen Point-Wert: tcMain.Padding = new Point(20,20);
Stellen Sie sich vor, Sie erzeugen ein neues Point-Objekt der Größe 20 x 20 Pixel, das auf jeder Seite des Tabseitentitels liegt. Dadurch erweitert sich die Registerkarte. Des Weiteren gibt es die SizeMode-Eigenschaft, die bestimmt, wie stark ein TabControl die Registerkarten expandieren sollte. Sie verwendet Werte aus der Aufzählung TabSizeMode: FillToRight bewirkt die Expansion bis zur Gesamtbreite des TabControl-Steuerelements, bei Fixed haben alle Registerkarten die gleiche, feste Größe und Normal legt fest, dass die Größe jede Tabseite durch die bereits genannten ItemSize- und Padding-Eigenschaften gesteuert wird. Erzeugen Sie mehr Tabseiten, als sich zugleich darstellen lassen, erscheinen auf dem TabControl Pfeile, mit deren Hilfe der Benutzer blättern kann, um alle Tabseiten zu sehen. Wenn Sie die Multiline-Eigenschaft auf true setzen, bewegen sich die Tabseiten, die normalerweise verborgen wären, in eine andere Zeile, so dass sie immer angezeigt werden – es werden so viele Zeilen erstellt wie zur Anzeige aller Tabseiten nötig sind. Um den Überblick über Ihre Steuerelemente behalten zu können, gibt es die Eigenschaften RowCount und TabCount, die, falls Multiline auf true gesetzt ist, die Anzahl der Zeilen bzw. die Gesamtzahl der Tabseiten zurückgeben. Die HotTrack-Eigenschaft schließlich veranlasst die Tabseiten, ihr Erscheinungsbild zu ändern (genauer gesagt: der Titelzeilentext ändert die Farbe), sobald die Maus darüber bewegt wird.
6.9
Die Steuerelemente TextBox und RichTextBox
Ihnen ist das TextBox-Steuerelement in diesem Buch bereits einige Male begegnet. Meistens haben Sie nur seine Text-Eigenschaft genutzt und meist brauchen Sie auch nicht mehr. Es besitzt aber noch ein paar Eigenschaften, die sich als nützlich erweisen könnten.
206
Die Steuerelemente TextBox und RichTextBox
Wir werfen einen kurzen Blick darauf, bevor ich Ihnen erzähle, was sie mit dem RichTextBox-Steuerelement zu tun haben. AcceptsReturn und AcceptsTab sind zwei Eigenschaften, die angeben, ob die (¢)- und die (ÿ_)-Tasten Zeilenumbrüche respektive Einzüge in der TextBox verursachen. Wenn der
Benutzer die Tabulatortaste drückt, geht gemäß der Voreinstellung der Fokus auf das nächste Steuerelement über und die (¢)-Taste aktiviert die Standardschaltfläche (falls es eine gibt). Indem Sie diese Eigenschaft auf true setzen, können Sie den Funktionsumfang Ihres Steuerelements erhöhen. Wenn Sie AcceptReturn gestatten, dürfen Sie damit rechnen, mehr als eine Zeile Daten zu erhalten. Tritt dies ein, dann sollten Sie Multiline auf true setzen, sonst könnte AcceptReturn nutzlos werden. Lines gibt ein Array von Zeichenfolgen zurück, das den Text aus jeder Zeile in der TextBox enthält. WordWrap gibt vor, ob der Text in die nächste Zeile weiterlaufen (also umgebrochen werden) soll, wenn die TextBox nicht groß genug ist, um ihn komplett auf einmal anzuzeigen. Ist jedoch WordWrap gleich false und Multiline gleich true, dann muss der Benutzer die (¢)-Taste drücken, um in die nächste Zeile zu gelangen. Sie können auch die Art und Weise, wie der Benutzer mit der TextBox interagiert, modifizieren. Die Eigenschaft CharacterCasing übernimmt einen Wert der CharacterCasing-Aufzählung, der angibt, wie die Großschreibung gehandhabt werden soll, wenn der Benutzer Text eingibt. Die Eigenschaft kann einen von drei Werten annehmen: Lower, welcher alle Eingaben in Kleinschreibung umwandelt; Normal, welcher Text so lässt, wie er eingegeben wird; und Upper, der jede Eingabe in Großschreibung umwandelt. Mit Hilfe von CanUndo kann der Benutzer seine letzten Aktionen rückgängig machen (für viele Benutzer ein Glücksfall!). Die Undo-Methode veranlasst die Rückgängigmachung, und ClearUndo löscht die Rückgängig-Liste, so dass der Benutzer keine Rückgängig-Aktionen mehr vornehmen kann, da die Anwendung sich nun nicht mehr »erinnern« kann, was passiert ist. Modified gibt an, ob der Text in der TextBox geändert wurde. Diese Eigenschaft wird häufig dazu verwendet, um festzustellen, ob Inhalte gespeichert werden sollten, bevor die Anwendung geschlossen wird. ReadOnly (schreibgeschützt) bedeutet, dass sich der Text nicht bearbeiten lässt. PasswordChar gibt das Zeichen an, welches zur Maskierung einer Benutzereingabe verwendet werden soll. Beim Eingeben von Kennwörtern haben Sie sicher schon oft bemerkt, dass Ihre Eingabe durch Sternchen (*) ersetzt wird. Die TextBox verfügt über eine Reihe von Methoden, die den Text behandeln. Clear löscht alle Textinhalte in der TextBox. Copy, Cut und Paste folgen alle den vertrauten WindowsOperationen Kopieren, Ausschneiden und Einfügen. AppendText hängt eine angegebene Zeichenfolge an das Ende des TextBox-Inhalts an.
207
Windows Forms mit Steuerelementen erweitern
Rich Text Das TextBox-Steuerelement eignet sich hervorragend, um Benutzereingaben zu handhaben. Sein Hauptnachteil: Es kann nur mit reinem Text oder Text ohne Formatierung umgehen. In ihrer einfachsten Form verhält sich die RichTextBox, die auch formatierten Text verarbeiten kann, wie jedes andere Steuerelement auch. Mit seinen Brüdern teilt es sich viele Mitglieder, darunter die Eigenschaften AcceptsTab, CanUndo und Multiline aus der TextBox. Doch RichTextBox bietet weit mehr Funktionen, darunter das Speichern und Laden von Dateien. Wir wollen einen Blick auf ein einfaches Beispiel für ein RichTextBox-Steuerelement werfen. Es erlaubt die Formatierung von Text. Wieder werde ich den Code aufteilen, um die Abschnitte leichter analysieren zu können. Das Listing 6.9 enthält den ersten Teil dieser Anwendung. Listing 6.9: Der Einsatz des Steuerelements RichTextBox 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:
208
Imports System Imports System.Windows.Forms Imports System.Drawing Namespace TYWinForms.Day6 Public Class Listing69 : Inherits Form private rtbText as New RichTextBox private intFontSize as Integer private strFontColor as String private strFontStyle as String private private private private private private private private private private private private private private private
cmnuText as New ContextMenu cmniFont as New MenuItem cmniBold as New MenuItem cmniItalics as New MenuItem cmniNormal as New MenuItem cmniFontSize as New MenuItem cmniSize8 as New MenuItem cmniSize10 as New MenuItem cmniSize12 as New MenuItem cmniSize14 as New MenuItem cmniColor as New MenuItem cmniColorRed as New MenuItem cmniColorBlue as New MenuItem cmniColorGreen as New MenuItem cmniColorBlack as New MenuItem
public shared sub Main()
Die Steuerelemente TextBox und RichTextBox
30: 31: 32: 33:
Application.Run(new Listing69) end sub End Class End Namespace
Listing 6.9 zeigt den grundlegenden Rahmen für unsere Anwendung. Die Zeilen 8 bis 27 weisen eine Reihe von Variablen auf, von denen viele Steuerelemente vom Typ ContextMenu und MenuItem sind, die der Benutzer verwenden wird, um die Schriftart im RichTextBox-Steuerelement zu ändern. Die drei Variablen in den Zeilen 9 bis 11 sind globale Variablen, die registrieren, welche Größe, Farbe und Auszeichnung die aktuelle Schriftart hat; diese Werte werden sich später als recht nützlich erweisen. Listing 6.10 zeigt den Konstruktor dieser Beispielanwendung. Listing 6.10: Der Konstruktor für das RichTextBox-Steuerelement der Anwendung 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:
public sub New() intFontSize = 10 strFontColor = "Schwarz" strFontStyle = "Normal" rtbText.Dock = DockStyle.Fill rtbText.ScrollBars = RichTextBoxScrollBars.Both rtbText.ContextMenu = cmnuText cmnuText.MenuItems.Add(cmniFont) cmnuText.MenuItems.Add(cmniFontSize) cmnuText.MenuItems.Add(cmniColor) cmniFont.Text = "Font" cmniBold.Text = "Fett" cmniFont.MenuItems.Add(cmniBold) cmniItalics.Text = "Kursiv" cmniFont.MenuItems.Add(cmniItalics) cmniNormal.Text = "Normal" cmniNormal.Checked = true cmniFont.MenuItems.Add(cmniNormal) AddHandler cmniBold.Click, new EventHandler(AddressOf Me.HandleFont) AddHandler cmniItalics.Click, new EventHandler(AddressOf Me.HandleFont) AddHandler cmniNormal.Click, new EventHandler(AddressOf Me.HandleFont) cmniFontSize.Text = "Grösse" cmniSize8.Text = "8" cmniFontSize.MenuItems.Add(cmniSize8)
209
Windows Forms mit Steuerelementen erweitern
29: 30: 31: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41: 42: 43: 44: 45: 46: 47: 48: 49: 50: 51: 52: 53: 54: 55: 56: 57: 58: 59:
cmniSize10.Text = "10" cmniSize10.Checked = true cmniFontSize.MenuItems.Add(cmniSize10) cmniSize12.Text = "12" cmniFontSize.MenuItems.Add(cmniSize12) cmniSize14.Text = "14" cmniFontSize.MenuItems.Add(cmniSize14) AddHandler cmniSize8.Click, new EventHandler(AddressOf Me.HandleFontSize) AddHandler cmniSize10.Click, new EventHandler(AddressOf Me.HandleFontSize) AddHandler cmniSize12.Click, new EventHandler(AddressOf Me.HandleFontSize) AddHandler cmniSize14.Click, new EventHandler(AddressOf Me.HandleFontSize) cmniColor.Text = "Farbe" cmniColorRed.Text = "Rot" cmniColor.MenuItems.Add(cmniColorRed) cmniColorBlue.Text = "Blau" cmniColor.MenuItems.Add(cmniColorBlue) cmniColorGreen.Text = "Grün" cmniColor.MenuItems.Add(cmniColorGreen) cmniColorBlack.Text = "Schwarz" cmniColorBlack.Checked = true cmniColor.MenuItems.Add(cmniColorBlack) AddHandler cmniColorRed.Click, new EventHandler(AddressOf Me.HandleFontColor) AddHandler cmniColorBlue.Click, new EventHandler(AddressOf Me.HandleFontColor) AddHandler cmniColorGreen.Click, new EventHandler(AddressOf Me.HandleFontColor) AddHandler cmniColorBlack.Click, new EventHandler(AddressOf Me.HandleFontColor) Me.Text = "Listing 6.9" Me.Font = New Font("Times New Roman", intFontSize) Me.Controls.Add(rtbText) end sub
Dies ist ein Standard-Konstruktor, doch er hat eine Menge Code zu verarbeiten. Die Zeilen 2 bis 4 setzen Anfangswerte für die Schriftstile Ihrer Anwendung fest. Die Zeilen 6 bis 8 definieren Eigenschaften für das RichTextBox-Steuerelement. Dock gibt an, wie sich das Steuerelement im Verhältnis zum Formular bewegt. ScrollBars diktiert, ob und wie Bildlaufleisten für die RichTextBox angezeigt werden sollen. Diese Eigenschaft kann einen der Werte aus der RichTextBoxScrollBar-Aufzählung annehmen:
210
Die Steuerelemente TextBox und RichTextBox
왘
Both: Falls nötig, werden waagrechte und senkrechte Bildlaufleisten
erscheinen. 왘
ForcedBoth: Egal, ob benötigt oder nicht, es werden immer waagrechte und senkrechte Bildlaufleisten erscheinen.
왘
ForcedHorizontal: Es wird stets eine waagrechte Bildlaufleiste angezeigt.
왘
ForcedVertical: Es wird stets eine senkrechte Bildlaufleiste angezeigt.
왘
Horizontal: Bei Bedarf wird eine waagrechte Bildlaufleiste angezeigt.
왘
None: Es werden keine Bildlaufleisten angezeigt.
왘
Vertical: Bei Bedarf wird eine senkrechte Bildlaufleiste angezeigt.
Zeile 8 weist diesem Steuerelement ein ContextMenu zu, so dass der Benutzer darauf rechtsklicken und die Schrifteigenschaften ändern kann. Die Zeilen 10 bis 12 fügen dem ContextMenu-Steuerelement Menüelemente der höchsten Hierarchieebene hinzu. Fast der ganze Rest des Listings beschäftigt sich mit den Eigenschaften für diese MenuItems. Die Zeilen 14 bis 24 initialisieren die Menüelemente, die den Schriftstil steuern (fett, kursiv oder normal). Die Zeilen 26 bis 39 initialisieren diejenigen Elemente, die sich mit der Schriftgröße befassen, und die Zeilen 41 bis 54 betreffen die Elemente, die die Schriftfarbe steuern. Beachten Sie, dass jede Codegruppe nur einen Ereignishandler verwendet: Die Zeilen 14 bis 24 benutzen HandleFont, die Zeilen 26 bis 39 HandleFontSize und die Zeilen 41 bis 54 HandleFontColor. Die Zeilen 56 bis 59 initialisieren schließlich das Formular, wobei sie die zu benutzende Standardschrift festlegen. Listing 6.11 zeigt die Ereignishandler und diverse Funktionen der Anwendung. Listing 6.11: Die Behandlung der RichTextBox-Ereignisse 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11:
public sub HandleFont(Sender as Object, e as EventArgs) strFontStyle = CType(Sender, MenuItem).Text rtbText.SelectionFont = new Font("Times New Roman", intFontSize, ConvertToFontStyle(strFontStyle)) cmniBold.Checked = false cmniItalics.Checked = false cmniNormal.Checked = false CType(Sender, MenuItem).Checked = true end sub
211
Windows Forms mit Steuerelementen erweitern
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: 45:
public sub HandleFontSize(Sender as Object, e as EventArgs) intFontSize = Convert.ToInt32(CType(Sender, MenuItem).Text) rtbText.SelectionFont = new Font("Times New Roman", intFontSize, ConvertToFontStyle(strFontStyle)) cmniSize8.Checked = false cmniSize10.Checked = false cmniSize12.Checked = false cmniSize14.Checked = false CType(Sender, MenuItem).Checked = true end sub public sub HandleFontColor(Sender as Object, e as EventArgs) strFontColor = CType(Sender, MenuItem).Text rtbText.SelectionColor = Color.FromName(strFontColor) cmniColorRed.Checked = false cmniColorBlue.Checked = false cmniColorGreen.Checked = false cmniColorBlack.Checked = false CType(Sender, MenuItem).Checked = true end sub private function ConvertToFontStyle(strStyle) as FontStyle select strStyle case "Fett" return FontStyle.Bold case "Kursiv" return FontStyle.Italic case "Normal" return FontStyle.Regular end select end function
Beachten Sie bitte zunächst, dass keine dieser Methoden eines der Ereignisse in RichTextBox direkt verarbeitet. Vielmehr behandeln wir die Ereignisse der MenuItem-Steuerelemente, die die Eigenschaften der RichTextBox entsprechend anpassen. Lassen Sie uns als Nächstes hinunter zur Funktion ConvertToFontStyle springen, die in Zeile 36 beginnt. Wie Sie aus ihrer Deklaration schließen können, gibt diese Funktion einen Wert der FontStyle-Aufzählung zurück. Wenn Sie nacheinander jedes Ereignis behandeln, werden Sie bemerken, dass es nötig wird, das vom Benutzer ausgewählte Menu-
212
Die Steuerelemente TextBox und RichTextBox
Item in einen passenden Typ umzuwandeln, den die RichTextBox verwenden kann. So kön-
nen Sie etwa mit folgendem Befehl keine Schrift erzeugen: new Font("Times New Roman", 8, "Fett")
Statt dessen müssen Sie den Wert der FontStyle-Aufzählung verwenden: new Font("Times New Roman", 8, FontStyle.Fett)
Die Funktion ConvertToFontStyle wandelt den Text »Fett« in einen FontStyle.Bold-Wert um, den Sie an anderer Stelle in Ihrem Code benutzen können. Wie genau, werden Sie gleich sehen. Wenn Sie zu Zeile 1 und der HandleFont-Methode zurückgehen, denken Sie bitte daran, dass diese Methode das Click-Ereignis für die Menüelemente cmniBild, cmniItalics und cmniNormal behandelt, die die Schriftart jeweils fett oder kursiv auszeichnen bzw. auf normal zurücksetzen. In Zeile 2 holen Sie den Text-Wert vom gerade ausgewählten MenuItem in die strFontStyle-Variable (Sie müssen die Sender-Variable in einen passenden Typ umwandeln – in diesem Fall MenuItem); dieser Wert wird »Fett« sein, »Kursiv« oder »Normal«, wie in den Zeilen 15, 17 und 19 des Listings 6.10 gezeigt wird. In Zeile 3 verwenden Sie die Eigenschaft SelectionFont der RichTextBox. Sie holt und setzt Informationen über die gerade in der RichTextBox verwendete Schriftart, insbesondere den gerade ausgewählten (oder markierten) Text. Ist momentan kein Text ausgewählt, betrifft diese Eigenschaft jeden neuen Text, den der Benutzer eingibt. Zeile 3 weist SelectionFont ein neues Font-Objekt zu, wobei die in den Variablen intFontSize und strFontStyle gesetzten Werte verwendet werden. Nun verstehen Sie, warum diese globalen Variablen wichtig sind – ohne sie würde es viel mehr Mühe bereiten, neue Schriftstile festzulegen. Ohne globale Variablen würde es sicherlich mehr Arbeit bedeuten, doch sie wäre nicht schwieriger. Wenn Sie diese globalen Variablen nicht verwenden wollen, dann ändern Sie die Zeile 3 wie folgt: rtbText.SelectionFont = new Font("Times New Roman"), rtbText.SelectionFont.Size, ConvertToFontStyle(Ctype(Sender, MenuItem).Text))
Mit anderen Worten: Die globalen Variablen spielen Platzhalter für Werte der SelectionFont-Eigenschaft und der Sender-Variablen. Lassen Sie uns kurz zur ConvertToFontStyle-Funktion zurückkehren. Bekanntlich kann man die Zeichenfolge, die vom ausgewählten Menüelement abgerufen wird, nicht direkt verwenden. Daher gibt diese Methode den richtigen Wert der FontStyle-Aufzählung zurück, um die Schrift richtig festzulegen. An Tag 4 behandelten wir Menüelemente. Wenn man zulässt, dass Menüelemente mit Häkchen versehen werden, dann muss man dafür sorgen, dass alle momentan nicht rele-
213
Windows Forms mit Steuerelementen erweitern
vanten Menüelemente kein Häkchen aufweisen. Die Zeilen 5 bis 9 entfernen alle Häkchen von den Schriftstil-Menüelementen; dann wird das passende Menüelement mit Häkchen versehen, je nachdem, was die Sender-Variable angibt. Die Methoden HandleFontSize und HandleFontColor tun praktisch das Gleiche wie HandleFont. Beide holen den Text des ausgewählten Menüelements (die Zeilen 13 respektive 25). HandleFontSize weist der SelectionFont-Eigenschaft unter Zuhilfenahme der globalen Variablen eine neue Schrift zu und versieht die Menüelemente dann mit Häkchen oder entfernt diese, je nachdem. HandleFontColor verwendet eine etwas andere Eigenschaft, nämlich SelectionColor. Diese Eigenschaft holt oder setzt die für den gerade ausgewählten Text verwendete Farbe (ist gerade keiner ausgewählt, dann für jeden neuen Text). In Zeile 26 verwenden Sie die FromName-Methode des Color-Objekts, um die Farbe zuzuweisen. In den Zeilen 28 bis 33 werden die Häkchen gesetzt bzw. entfernt. Diese Anwendung enthält eine Menge Code; tatsächlich ist sie das umfangreichste Codebeispiel, das Sie bis jetzt gesehen haben. Doch das meiste davon ist recht einfach, denn es besteht vor allem aus dem Initialisierungscode des Konstruktors. Kombinieren Sie diese drei Listings, indem Sie Listing 6.10 und 6.11 in Zeile 28 des Listings 6.9 einfügen. Abbildung 6.11 zeigt ein typisches Ergebnis aus dieser Anwendung.
Abbildung 6.11: Die voll funktionsfähige RichTextBox-Anwendung bietet dem Benutzer zahlreiche Wahlmöglichkeiten an.
Die Hauptarbeit bei der Verwendung des RichTextBox-Steuerelements besteht also vor allem in der Bereitstellung von Benutzerschnittstellen (wie Menüelementen), um Schrifteigenschaften bearbeiten zu können. Die zwei Haupteigenschaften SelectionFont und SelectionColor betreffen den gerade ausgewählten Text. Die RichTextBox besitzt viele solcher Eigenschaften, darunter SelectionAlignment, die anzeigt, wie der momentan markierte Text auszurichten ist, SelectionBullet, die festlegt, ob der Text eine Liste mit Aufzählpunkten sein soll, und schließlich SelectionIndent, die festlegt, wie groß Einrückungen sein sollen. (Um etwas über die anderen Eigenschaften zu erfahren, schlagen Sie bitte in Anhang B nach.)
214
Das Steuerelement Timer
Bevor wir zum nächsten Steuerelement übergehen, sind drei RichTextBox-Mitglieder vorzustellen, die jeder Entwic