NET Windows Forms in 21 Tagen . Oberflächen programmieren

Chris Payne Übersetzung: Michael Matzer .NET Windows Forms ■ ■ ■ Oberf berfl rflächen hen ob objektorient entiert pro...

Author: Chris Payne

78 downloads 1364 Views 13MB Size Report

This content was uploaded by our users and we assume good faith they have the permission to share this book. If you own the copyright to this book and it is wrongfully on our website, we offer a simple DMCA procedure to remove your content from our site. Start by pressing the button below!

Report copyright / DMCA form

DOWNLOAD PDF

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 Entwickler kennen sollte. Das erste, DetectUrls, ist interessant, da seine Funktion zunehmende Bedeutung in heutigen Anwendungen erlangt. Wird diese Eigenschaft auf true gesetzt, formatiert die RichTextBox jeden Text, der wie eine Webadresse (URL) aussieht, auf solche Weise, dass er anklickbar ist – genau wie eine normale Verknüpfung in einem Webbrowser. Der fragliche Text ist blau und unterstrichen (je nach Ihren Internet-Einstellungen). Um Klicks auf solche Links handhaben zu können, müssen Sie dem LinkClicked-Ereignis der RichTextBox einen Delegaten zuweisen und einen Ereignishandler hinzufügen, so etwa: public Sub Link_Clicked(Sender As Object, e As LinkClickedEventArgs) System.Diagnostics.Process.Start(e.LinkText) end Sub

Die Start-Methode in diesem Codestück ruft den Standard-Browser des Benutzers mit dem Link, den er angeklickt hat, auf (eigentlich ruft sie die Anwendung auf, die dafür konfiguriert ist, Internet-Links zu verarbeiten, was aber meist ein Browser ist). Das zweite kennen zu lernende RichTextBox-Mitglied ist die Find-Methode. Sie durchsucht die RichTextBox nach einer angegebenen Zeichenfolge – eine sehr nützliche Funktion für jede textverarbeitende Anwendung. Diese Methode kann etliche verschiedene Parameter übernehmen, doch die gebräuchlichsten sind eine Zeichenfolge sowie eine Zeichenfolge mit einem Index für das erste Zeichen, bei dem die Suche beginnen soll. Beim letzten Mitglied handelt es sich eigentlich um zwei, die eine ähnliche Funktion haben. Rtf und SelectedRtf liefern den gesamten bzw. nur den markierten Text in der RichTextBox, wobei sie alle Formatierungen übernehmen. Die Copy-Methode, die auch in der TextBox verfügbar ist, kopiert Text, doch verlieren Sie dabei alle Formatierungen. Verwenden Sie also Rtf oder SelectedRtf, um die Formatierung beizubehalten, wenn Sie den Text an eine andere Anwendung (wie zum Beispiel Microsoft Word) übergeben wollen.

6.10 Das Steuerelement Timer Das Timer-Steuerelement ist eines der nützlichsten Steuerelemente überhaupt. Einfach ausgedrückt, können Sie damit ein Ereignis nach einem festgelegten Intervall auslösen. Bis jetzt hatten Sie keine Möglichkeit, in einer Anwendung Zeit oder Dauer festzuhalten. Denken Sie einmal an all die Einsatzmöglichkeiten von Timer: Sie können eine Anwendung erstellen, die den Benutzer alle fünf Minuten daran erinnert, sein Dokument zu speichern; Sie können Echtzeituhren und -zähler bereitstellen und eine Leistungsüberwachung einrichten. Praktisch jede interaktive Aufgabe, die Sie automatisieren wollen, erfordert das TimerSteuerelement.

215

Windows Forms mit Steuerelementen erweitern

Da er kaum etwas anderes tut, als die Zeit zu stoppen, verfügt der Timer über sehr wenige Mitglieder. Er hat nur zwei Eigenschaften: Enabled zeigt an, ob der Timer aktiv sein soll, und Interval legt die Dauer in Millisekunden fest, nach der der Timer »ticken« soll. Jeder »Tick« im Timer erzeugt ein Ereignis, das treffend einfach Tick genannt wird. Damit können Sie angepasste automatische Routinen ausführen lassen. Schließlich gibt es noch zwei interessante Methoden, nämlich Start und Stop, die einfach den Timer starten bzw. anhalten. Eine der besten Anwendungsmöglichkeiten von Timer besteht in einer Weckuhr. Listing 6.12 zeigt eine solche Anwendung. Listing 6.12: Eine Weckuhr 1: Imports System 2: Imports System.Windows.Forms 3: Imports System.Drawing 4: 5: namespace TYWinForms.Day6 6: 7: public class Listing612 : Inherits Form 8: private tmrClock as New Timer 9: private tmrAlarm as New Timer 10: private lblClock as New Label 11: private intSnoozeTime as Integer 12: private intSnoozeCounter as Integer 13: 14: public sub New() 15: intSnoozeTime = 10000 '10 Sekunden 16: 17: tmrClock.Interval = 1000 18: tmrClock.Enabled = true 19: AddHandler tmrClock.Tick, new EventHandler(AddressOf Me.UpdateClock) 20: 21: tmrAlarm.Interval = 1000 22: tmrAlarm.Enabled = true 23: AddHandler tmrAlarm.Tick, new EventHandler(AddressOf Me.CheckAlarm) 24: 25: lblClock.Width = 300 26: lblClock.Height = 150 27: lblClock.Location = new Point(0,100) 28: lblClock.Text = DateTime.Now.ToString 29: 30: Me.Text = "Listing 6.12" 31: Me.Font = new Font("Arial", 20) 32: Me.Controls.Add(lblClock)

216

Das Steuerelement Timer

33: 34: 35: 36: 37: 38: 39: 40: 41: 42: 43: 44: 45: 46: 47: 48: 49: 50: 51: 52:

end sub public sub UpdateClock(Sender as Object, e as EventArgs) lblClock.Text = DateTime.Now.ToString end sub public sub CheckAlarm(Sender as Object, e as EventArgs) intSnoozeCounter += tmrAlarm.Interval if intSnoozeCounter = intSnoozeTime then intSnoozeCounter = 0 MessageBox.Show("Aufwachen, Schlafmütze!!!") end if end sub public shared sub Main() Application.Run(new Listing612) end sub end class end namespace

In dieser Anwendung erzeugen Sie zwei Timer-Steuerelemente: eines, um die dem Benutzer sichtbare Uhr zu aktualisieren, und eines, um den »Weckruf« zu steuern. In den Zeilen 8 bis 12 werden diese beiden Timer neben ein paar weiteren Variablen deklariert. In Zeile 15 stellen Sie im Konstruktor die Schlummerzeit ein oder die Zeit, bevor der Alarm losgeht – in unserem Fall nach 10 Sekunden (= 10.000 Millisekunden). In den Zeilen 17 bis 19 stellen Sie das Intervall des Timers auf eine Sekunde (oder 1000 Millisekunden) ein, aktivieren bzw. starten den Timer und übergeben ihm einen Ereignishandler. Die Zeilen 21 bis 23 erledigen das Gleiche für den Weckruf-Timer. Ein paar Eigenschaften für ein Label-Steuerelement, das die Uhr anzeigt, werden in den Zeilen 25 bis 28 festgelegt, und die Zeilen 30 bis 32 bestimmen ein paar allgemeine Eigenschaften für das Formular. Beachten Sie, dass Sie die DateTime.Now-Methode verwenden, um die aktuelle Zeit zurückzugeben, wie sie von der Uhr des Benutzer-Computers definiert wird. Die ToString-Methode wandelt das DateTime-Objekt in Text um, der im Label-Steuerelement angezeigt wird. Die UpdateClock-Methode in Zeile 35 wird alle 1000 Millisekunden durch den Timer tmrClock ausgeführt. Sie ruft einfach fortlaufend DateTime.Now auf, um die sichtbare Uhr zu aktualisieren. Auch CheckAlarm wird alle 1000 Millisekunden ausgeführt und bestimmt, ob das vorgegebene Schlummerintervall bereits verstrichen ist. In Zeile 40 erhöht

217

Windows Forms mit Steuerelementen erweitern

diese Methode die intSnoozeCounter-Variable, die in Zeile 42 mit der intSnoozeTime-Variablen verglichen wird. Sind beide gleich – sind also 10 Sekunden verstrichen – wird eine Meldung mit einer freundlichen Weckrufbotschaft angezeigt. Die Zählervariable wird dann auf 0 zurückgesetzt, um den Weckrufvorgang von neuem zu starten. Ansonsten passiert nichts, und der Timer tickt unverdrossen weiter. Abbildung 6.12 zeigt das Ergebnis nach zehn Sekunden.

Abbildung 6.12: Ihre einfache Weckuhr besitzt einen stillen Alarmruf.

6.11 Das Steuerelement TreeView Das Steuerelement TreeView wird für die Anzeige hierarchischer Listen von Informationen verwendet. Die gebräuchlichste Einsatzweise besteht in Oberflächen vom Typ des Windows Explorers: Sie können damit durch eine Verzeichnisstruktur blättern, wie in Abbildung 6.13 zu sehen. Eine Verzeichnisstruktur ist jedoch nicht das Einzige, das das TreeView-Steuerelement darstellen kann. Jede beliebige hierarchisch aufgebaute Informationsstruktur – Kunden- und Bestelldaten, Stammbäume, Speisekarten usw. – lässt sich mit TreeView handhaben. Jedes Element – oder Strukturknoten (node) – in der TreeView-Liste wird durch ein TreeNode-Objekt dargestellt. Natürlich kann jeder TreeNode unter sich weitere TreeNodes haben, so dass das Steuerelement seine hierarchische Charakteristik erhält. Der erste Knoten wird als Wurzel- oder Stammknoten (root node) bezeichnet. Da Sie jeden Knoten in der TreeView einzeln anlegen müssen, könnte das Anlegen dieses Steuerelements etwas mühselig sein, doch es ist zum Glück nicht schwierig. Das folgende Codestück erstellt z.B. neue Knoten einfach durch Einsatz von Programmschleifen:

218

Das Steuerelement TreeView

Abbildung 6.13: Die Benutzeroberfläche des Windows Explorers verwendet eine Strukturansicht. dim myTreeView as new TreeView For i = 0 to 20 MyTreeView.Nodes.Add(New TreeNode("Node " &&i.ToString)) For j = 0 to 20 MyTreeView.Nodes(i).Nodes.Add(New TreeNode("SubNode " &&j.ToString)) For k = 0 to 20 MyTreeView.Nodes(i).Nodes(j).Nodes.Add(New TreeNode("SubSubNode " &&k.ToString)) Next k Next j Next i

In diesem Codestück werden Schleifen durch drei verschiedene Variablen zwischen 0 und 20 geführt. Das Ergebnis ist ein dreischichtiges TreeView-Steuerelement, wobei jede Schicht über 21 Knoten verfügt. Neue Knoten lassen sich einfach mit der Nodes.AddMethode hinzufügen, wobei ein neues TreeNode-Objekt mit einer festgelegten Beschriftung übergeben wird. Auf diese Beschriftung kann man auch über die Text-Eigenschaft jedes Knotens zugreifen. Das TreeView-Steuerelement lässt sich weitgehend anpassen; jeder Aspekt der Benutzeroberfläche lässt sich steuern. Tabelle 6.3 zeigt die gebräuchlichsten Eigenschaften von TreeView.

219

Windows Forms mit Steuerelementen erweitern

Eigenschaft

Beschreibung

CheckBoxes

Gibt an, ob neben jedem Knoten Kontrollkästchen angezeigt werden sollen. Dadurch kann der Benutzer bestimmte Knoten zur Bearbeitung auswählen. Sie verwenden die Checked-Eigenschaft des TreeNode-Objekts, um zu bestimmen, ob ein Objekt mit Häkchen versehen (checked) ist.

FullRowSelect

Gibt an, ob die Markierung, die bei der Auswahl eines Knotens erscheint, die gesamte Breite des Steuerelements einnehmen oder sich auf die Beschriftung des Knotens beschränken soll.

HotTracking

Gibt an, ob sich das Aussehen des Knotens ändert, wenn sich der Mauszeiger darüber befindet (z.B. der Text sich blau färbt)

ImageList

Ein ImageList-Steuerelement, das sich dazu einsetzen lässt, Grafiken anstelle der Knotensymbole anzuzeigen. Sie verwenden dies mit der ImageIndex-Eigenschaft genau wie bei anderen Steuerelementen.

Indent

Die Anzahl an Pixeln, um die jeder untergeordnete Knoten gegenüber seinem übergeordneten Knoten eingerückt werden soll.

LabelEdit

Gibt an, ob sich die Beschriftung eines Knotens bearbeiten lässt.

Nodes

Gibt eine Auflistung von Strukturknoten (TreeNode) zurück.

PathSeparator

Das für die Abtrennung von Knoten verwendete Zeichen (mehr dazu gleich).

ShowLines

Gibt an, ob in der Strukturansicht Verbindungslinien zwischen den Knoten gezeichnet werden.

ShowPlusMinus

Gibt an, ob neben Knoten mit untergeordneten Knoten Plus- und Minuszeichen angezeigt werden sollen.

ShowRootLines

Gibt an, ob zwischen Stammknoten der Strukturansicht Verbindungslinien gezeichnet werden sollen.

Scrollable

Gibt an, ob nach Bedarf Bildlaufleisten angezeigt werden sollen.

VisibleCount

Die Anzahl der gleichzeitig sichtbaren Knoten.

TopNode

Gibt das oberste sichtbare TreeNode-Objekt zurück.

Tabelle 6.3: Die gebräuchlichsten Eigenschaften des TreeView-Steuerelements

Das TreeNode-Objekt weist ebenfalls einige nützliche Eigenschaften auf. FullPath kombiniert die Bezeichnungstexte aller Knoten, die anzusteuern sind, um den aktuellen Knoten zu erreichen. Die Angabe ist durch das PathSeparator-Zeichen (Standardwert: \) aufgeteilt. Beispielsweise sähe der FullPath, also die vollständige Pfadangabe, zum 14. Knoten,

220

Zusätzliche nützliche Steuerelemente

der zum Knoten gehört, der als 2. Knoten dem 3. Wurzelknoten untergeordnet ist, mit Hilfe des PathSeparator-Zeichens wie folgt aus: "Node2\SubNode1\SubSubNode13\"

Die Eigenschaften IsEditing, IsExpanded, IsSelected und IsVisible geben true- oder false-Werte zurück, um anzugeben, ob der aktuelle TreeNode gerade bearbeitet wird oder sichtbar, erweitert oder ausgewählt ist. Um Strukturknoten anzusteuern, stehen die Eigenschaften NextNode und NextVisibleNode sowie PrevNode und PrevVisibleNode zur Verfügung. Diese Eigenschaften geben die spezifizierten Strukturknoten zurück. Zwei nützliche TreeView-Methoden sind CollapseAll und ExpandAll, die entweder alle erweiterten Knoten reduzieren oder umgekehrt alle reduzierten Knoten erweitern. In analoger Weise verfügt TreeNode über Collapse, Expand, ExpandAll und Toggle. Letztere schaltet zwischen den Zuständen erweitert/reduziert hin und her. Das TreeView-Steuerelement weist eine Reihe von Ereignissen auf, die sowohl vor als auch nach bestimmten Aktionen ausgelöst werden. Diese Ereignisse verwenden die Präfixe Before (vor) und After (nach), so etwa in BeforeCheck, BeforeCollapse, BeforeExpand, BeforeLabelEdit und BeforeSelect (zusammen mit den entsprechenden After-Methoden).

6.12 Zusätzliche nützliche Steuerelemente In der heutigen Lektion haben wir gerade mal die Oberfläche der Windows Forms-Steuerelemente angekratzt. Wir haben die gebräuchlichsten Steuerelemente erforscht, doch es gibt insgesamt 42 Steuerelemente. Hier eine kleine Kostprobe: 쐽

CheckListBox: Ähnelt der ListBox, platziert aber neben jedem Listenelement ein kleines Kästchen. Da es sich um eine Kombination aus CheckBox und ListBox handelt,

können Sie sich die Eigenschaften in diesem Steuerelement vorstellen. 쐽

DataGrid: Sehr nützlich beim Anzeigen von Informationen aus gespeicherten Datenquellen wie etwa Datenbanken. (Mehr dazu an Tag 9.)

쐽

ProgressBar: Ähnlich den »Leisten-« Steuerelementen, die Sie an Tag 4 kennen gelernt haben. Die Fortschrittsleiste wird von links nach rechts angefüllt, um anzuzeigen, wie weit die Vollendung einer Aufgabe vorangeschritten ist.

쐽

ToolTip: Stellt eine QuickInfo dar, die erscheint, wenn der Mauszeiger über einem

Steuerelement schwebt. Windows ist voll von solchen QuickInfos, so dass dieses Steuerelement sich als recht hilfreich erweist.

221

Windows Forms mit Steuerelementen erweitern

6.13 Das Layout steuern Es ist an der Zeit zu lernen, wie man all diese Steuerelemente ordentlich auf einem Formular anordnet, denn sonst würde man ein unverständliches Durcheinander erhalten. Sie haben bereits eine Organisationsmethode kennen gelernt: das Hinzufügen von Steuerelementen zu anderen, übergeordneten Steuerelementen, wie etwa Panel- oder TabControlSteuerelementen. Mit diesen beiden lassen sich Steuerelemente zu logischen Gruppen zusammenfassen, die sowohl verwaltbar (als auch leicht darstellbar) sind. Es gibt noch andere Möglichkeiten zur Organisation von Steuerelementen. Eine davon besteht in der Dock-Eigenschaft der Control-Klasse. Mit Dock lassen sich die Position sowie die Art und Weise angeben, in der ein fragliches Steuerelement an sein Containersteuerelement angedockt ist. Indem man Werte aus der DockStyle-Aufzählung verwendet, kann man Steuerelemente dazu bringen, am oberen oder unteren Rand eines Formulars oder eines Panel-Steuerelements (wie etwa Symbolleisten oder Bildlaufleisten) zu kleben oder den Container vollständig auszufüllen. Folgende sind die DockStyle-Werte: 쐽

Bottom: Dockt das Steuerelement am unteren Rand des Containersteuerelements an.

쐽

Fill: Alle Ränder des Steuerelements werden an die entsprechenden gegenüberliegenden Seiten des Containers angedockt, wodurch das Steuerelement den Container vollständig ausfüllt, selbst wenn dessen Größe sich ändert.

쐽

Left: Dockt das Steuerelement am linken Rand des Containersteuerelements an.

쐽

None: Standardwert; das Steuerelement wird nirgendwo angedockt.

쐽

Right: Dockt das Steuerelement am rechten Rand des Containersteuerelements an.

쐽

Top: Dockt das Steuerelement am oberen Rand des Containersteuerelements an.

Eine weitere das Layout beeinflussende Eigenschaft ist Anchor. Sie ist ebenfalls in jedem Steuerelement vorhanden und ähnelt Dock insofern, als sie festlegt, welche Ränder eines Steuerelements mit dem übergeordneten Formular verknüpft sein sollen, doch im Unterschied zu Dock werden die Steuerelemente dadurch nicht an den Formularrändern angedockt. Vielmehr bleibt die angegebene Seite des Steuerelements an ihrer Position relativ zum Rand des Formulars, unabhängig von seiner Position auf dem Formular oder von der Größenänderung des Formulars. Anchor nimmt einen der Werte der AnchorStyle-Aufzählung an: Bottom, Left, None, Right oder Top. Damit ein Steuerelement seine Größe relativ zu der des Formulars ändert, setzen Sie die Verankerung auf gegenüberliegende Seiten des Formulars. Dies erfolgt in VB .NET mit dem Or-Operator und in C# mit dem Zeichen | – etwa so: textBox1.Anchor = AnchorStyles.Top Or AnchorStyles.Bottom textBox1.Anchor = AnchorStyles.Top | AnchorStyles.Bottom;

222

Das Layout steuern

Listing 6.13 zeigt ein gutes Beispiel für die Manipulation der Eigenschaften Dock und Anchor. Listing 6.13: Das dynamische Ändern eines Steuerelementlayouts (Visual Basic .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: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41:

Imports System Imports System.Windows.Forms Imports System.Drawing Namespace TYWinForms.Day6 Public Class Listing613 : Inherits Form Private WithEvents pnlButton As New Panel Private WithEvents pnlControls As New Panel Private WithEvents gboxAnchor As New GroupBox Private WithEvents gboxDock As New GroupBox Private WithEvents btnDemo As New Button Private WithEvents rbNone As New RadioButton Private WithEvents rbTop As New RadioButton Private WithEvents rbLeft As New RadioButton Private WithEvents rbBottom As New RadioButton Private WithEvents rbRight As New RadioButton Private WithEvents rbFill As New RadioButton Private WithEvents chkTop As New CheckBox Private WithEvents chkLeft As New CheckBox Private WithEvents chkBottom As New CheckBox Private WithEvents chkRight As New CheckBox Public Sub New() rbRight.Location = New Point(8,120) rbRight.Size = New Size(72,24) rbRight.Text = "Rechts" rbNone.Location = New Point(8,24) rbNone.Size = New Size(72,24) rbNone.Text = "Kein" rbNone.Checked = True rbBottom.Location = New Point(8,96) rbBottom.Size = New Size(72,24) rbBottom.Text = "Unten" rbTop.Location = New Point(8,48) rbTop.Size = New Size(72,24) rbTop.Text = "Oben"

223

Windows Forms mit Steuerelementen erweitern

42: 43: 44: 45: 46: 47: 48: 49: 50: 51: 52: 53: 54: 55: 56: 57: 58: 59: 60: 61: 62: 63: 64: 65: 66: 67: 68: 69: 70: 71: 72: 73: 74: 75: 76: 77: 78: 79: 80: 81: 82: 83: 84: 85: 86: 87:

224

rbLeft.Location = New Point(8,72) rbLeft.Size = New Size(72,24) rbLeft.Text = "Links" rbFill.Location = New Point(8,144) rbFill.Size = New Size(72,24) rbFill.Text = "Füllen" gboxAnchor.Location = New Point(16,16) gboxAnchor.Size = New Size(88,128) gboxAnchor.Text = "Verankern" gboxDock.Location = New Point(16,152) gboxDock.Size = New Size(88,176) gboxDock.Text = "Andocken" btnDemo.Size = New Size(120,24) btnDemo.Anchor = AnchorStyles.None btnDemo.Location = New Point(64,72) btnDemo.Text = "Spiel mit mir!" chkBottom.Location = New Point(8,72) chkBottom.Size = New Size(72,24) chkBottom.Text = "Unten" chkLeft.Location = New Point(8,48) chkLeft.Size = New Size(72,24) chkLeft.Text = "Links" chkTop.Location = New Point(8,24) chkTop.Size = New Size(72,24) chkTop.Text = "Oben" chkRight.Location = New Point(8,96) chkRight.Size = New Size(72,24) chkRight.Text = "Rechts" pnlButton.BorderStyle = FormBorderStyle.Fixed3D pnlButton.Dock = DockStyle.Fill pnlButton.Size = New Size(448,400) pnlButton.Text = "ButtonPanel" pnlButton.Controls.Add(btnDemo) pnlControls.BorderStyle = FormBorderStyle.Fixed3D pnlControls.Dock = DockStyle.Right pnlControls.Location = New Point(328,0)

Das Layout steuern

88: pnlControls.Size = New Size(120,400) 89: pnlControls.Text = "ControlsPanel" 90: pnlControls.Controls.Add(gboxAnchor) 91: pnlControls.Controls.Add(gboxDock) 92: 93: gboxAnchor.Controls.Add(chkRight) 94: gboxAnchor.Controls.Add(chkBottom) 95: gboxAnchor.Controls.Add(chkLeft) 96: gboxAnchor.Controls.Add(chkTop) 97: gboxDock.Controls.Add(rbBottom) 98: gboxDock.Controls.Add(rbLeft) 99: gboxDock.Controls.Add(rbNone) 100: gboxDock.Controls.Add(rbRight) 101: gboxDock.Controls.Add(rbFill) 102: gboxDock.Controls.Add(rbTop) 103: 104: Me.Text = "Listing 6.13" 105: Me.Size = New Size(800,600) 106: Me.Controls.Add(pnlButton) 107: Me.Controls.Add(pnlControls) 108: End Sub 109: 110: Private Sub AnchorClicked(Sender As Object,e As EventArgs) Handles chkBottom.Click,chkLeft.Click,chkRight.Click,chkTop.Click 111: If chkTop.Checked Then 112: btnDemo.Anchor = btnDemo.Anchor Or AnchorStyles.Top 113: End If 114: 115: If chkLeft.Checked Then 116: btnDemo.Anchor = btnDemo.Anchor Or AnchorStyles.Left 117: End If 118: 119: If chkBottom.Checked Then 120: btnDemo.Anchor = btnDemo.Anchor Or AnchorStyles.Bottom 121: End If 122: 123: If chkRight.Checked Then 124: btnDemo.Anchor = btnDemo.Anchor Or AnchorStyles.Right 125: End If 126: End Sub 127: 128: Private Sub DockClicked(Sender As Object,e As EventArgs) Handles rbBottom.Click,rbFill.Click,rbLeft. Click,rbRight.Click,rbTop.Click,rbNone.Click 129: dim rbSet as RadioButton = CType(sender,RadioButton) 130:

225

Windows Forms mit Steuerelementen erweitern

131: 132: 133: 134: 135: 136: 137: 138: 139: 140: 141: 142: 143: 144: 145: 146: 147: 148: 149: 150:

If rbSet Is rbNone Then btnDemo.Dock = DockStyle.None ElseIf rbSet Is rbTop Then btnDemo.Dock = DockStyle.Top ElseIf rbSet Is rbLeft Then btnDemo.Dock = DockStyle.Left ElseIf rbSet Is rbBottom Then btnDemo.Dock = DockStyle.Bottom ElseIf rbSet Is rbRight Then btnDemo.Dock = DockStyle.Right Else btnDemo.Dock = DockStyle.Fill End If End Sub public shared sub Main() Application.Run(New Listing613) end sub End Class End Namespace

In den Zeilen 8 bis 22 richten Sie einfach einige Steuerelemente ein, mit denen der Benutzer die Anchor- und Dock-Eigenschaften ändern kann; Sie benötigen ein Optionsfeld oder ein Kontrollkästchen für jeden der Werte in den DockStyle- und AnchorStyle-Aufzählungen (verwenden Sie Optionsfelder für DockStyle, denn es lässt sich nur jeweils ein Wert zuweisen; Kontrollkästchen werden für AnchorStyle benutzt, denn man kann ja mehrere Verankerungen zugleich haben). Beachten Sie den Gebrauch des Schlüsselwortes WithEvents: Dies teilt der CLR mit, dass jedes einzelne der Steuerelemente Ereignisse auslösen wird (in C# ist das Einbeziehen solcher Schlüsselworte nicht nötig). In den Zeilen 25 bis 107, also dem Großteil des Codes, initialisieren und platzieren wir Steuerelemente im Formular. In diesem Listing findet sich ein neues Steuerelement namens GroupBox (Gruppenfeld). Es ähnelt dem Panel-Steuerelement, weil es andere Steuerelemente enthält, doch es zeichnet einen Kasten um seine untergeordneten Steuerelemente, so dass der Benutzer weiß, dass diese Steuerelemente zusammengehören. In den Zeilen 93 bis 102 werden die einzelnen Steuerelemente diesen Gruppenfeldern hinzugefügt, welche wiederum (in den Zeilen 90 und 91) Panel-Steuerelementen hinzugefügt werden. Die Panel-Steuerelemente finden in den Zeilen 106 und 107 endlich Aufnahme in das Formular. Es gilt nur noch zwei Methoden zu untersuchen: AnchorClicked in Zeile 110 und DockClicked in Zeile 128. Sie verwenden das Schlüsselwort Handles, um der CLR mitzuteilen, auf welche Ereignisse diese Methoden angewendet werden sollen (mehr zur Ereignisbehand-

226

Das Layout steuern

lung in Windows Forms finden Sie an Tag 5). In unserem Fall handhabt die AnchorClicked-Methode alle Click-Ereignisse der Kontrollkästchen, und DockClicked tut das Gleiche für die Optionsfelder. Wir wollen zuerst AnchorClicked betrachten. Da sich Anchor-Eigenschaften kumulativ auf ein Steuerelement anwenden lassen, müssen Sie jedes einzelne Anker-Kontrollkästchen untersuchen. Ist das Kontrollkästchen für AnchorStyles.Top angekreuzt, müssen Sie den AnchorStyles.Top-Wert anwenden, und so weiter für alle weiteren Werte. Dies lässt sich leicht bewerkstelligen, indem man mit Hilfe des Or-Operators die Werte in if-Statements der Anchor-Eigenschaft einer Schaltfläche hinzufügt. Als Folge dieser Vorgehensweise wird jeder AnchorStyles-Wert nach Bedarf in der Reihenfolge der if-Statements ausgewertet und kumulativ angewendet. Mit DockClicked verhält es sich ähnlich. Doch da sich DockStyle-Werte nur einzeln anwenden lassen, müssen Sie die Stile nicht zusammen hinzufügen. Mit Hilfe von ifStatements bestimmen Sie einfach, welches Optionsfeld angeklickt wurde, und wenden den passenden DockStyle-Wert an (beachten Sie den Gebrauch des Is-Schlüsselworts: Denken Sie beim Vergleichen von Objekten daran, diesen Operator anstelle des Gleichheitszeichens (=) zu verwenden). Probieren Sie die Steuerelemente der Anwendung, die in Abbildung 6.14 zu sehen ist, aus und beachten Sie, wie die Schaltfläche dadurch beeinflusst wird. Obwohl die Eigenschaften TabStop und TabIndex das Layout von Steuerelementen nicht direkt betreffen, so gestatten sie doch das Navigieren zwischen den einzelnen Steuerelementen, so dass sie an dieser geeigneten Stelle vorgestellt werden sollen. Als WindowsBenutzer wissen Sie, dass Sie die (ÿ_)-Tasten dazu benutzen können, von einem Steuerelement zum nächsten zu gelangen. Dadurch können Sie sich ohne Maus durch eine Anwendung manövrieren. Die TabIndex-Eigenschaft gibt an, in welcher Reihenfolge bestimmte Steuerelemente angesteuert werden, wenn die (ÿ_)-Taste gedrückt wird. Ein Steuerelement mit dem TabIndex von 0 ist das erste zu markierende Steuerelement, sobald eine (ÿ_)-Taste gedrückt wird; TabIndex gleich 1 ist das nächste und so weiter. Jedes Steuerelement im Formular lässt sich auf diese Weise ansteuern. Wenn Sie die TabIndex-Werte nicht ausdrücklich zuweisen, erledigt dies die CLR für Sie, allerdings gemäß der Reihenfolge, in der das jeweilige Steuerelement dem Formular hinzugefügt wurde (und falls Sie aus Versehen eine TabIndex-Zahl überspringen, wird das die CLR ignorieren und einfach zur nächsten verfügbaren Indexzahl springen). Dies ist ein wichtiges Merkmal der Benutzeroberfläche, das man berücksichtigen muss. Es mag aber Situationen geben, in denen Sie nicht wünschen, dass der Benutzer mit der (ÿ_)-Taste auf ein Steuerelement springt. In der Regel sollten z.B. Benutzer nicht in der Lage sein, ein Label-Steuerelement zu manipulieren, daher sollte es nicht auswählbar sein. In solchen Fällen setzen Sie die TabStop-Eigenschaft auf false.

227

Windows Forms mit Steuerelementen erweitern

Abbildung 6.14: Das Modifizieren der Anchor- und Dock-Eigenschaften einer Schaltfläche.

6.14 Zusammenfassung Am besten verwenden Sie dieses umfangreiche Kapitel als eine Art Nachschlagewerk und Referenz – Sie müssen das nicht alles auswendig lernen. Sie haben mehrere Schaltflächen kennen gelernt: Button, RadioButton und CheckBox. Obwohl sie sich in ihrer Implementierung leicht unterscheiden, gestatten sie alle dem Benutzer, eine Auswahl zu treffen. Die gebräuchlichsten Mitglieder diese Steuerelemente sind die Text-Eigenschaft und das Click-Ereignis. Mit Hilfe des DateTimePicker-Steuerelements kann der Benutzer Zeiten und Daten wählen, indem er sie entweder manuell eingibt oder aus der Dropdown-Liste des Kalenders auswählt. Was uns zum nächsten Steuerelement führt: der ComboBox. Sie ist eine Kombination aus TextBox und ListBox; ein Benutzer kann Text von Hand eingeben oder Elemente aus einer Dropdown-Liste auswählen. Anders als die ComboBox erlaubt es die ListBox dem Benutzer, mehrere Elemente auf einmal auszuwählen. Dieses Steuerelement ist sehr nützlich, wenn Sie dem Benutzer mehrere Auswahlmöglichkeiten anbieten wollen. ImageList und PictureBox haben beide mit Bildern zu tun, unterscheiden sich aber stark voneinander. ImageList ist im Grunde ein Array von Grafiken, das Sie mit anderen Steuerelementen verknüpfen können, um Grafiken anzuzeigen (so wie die Schaltflächen für eine ToolBar). Eine PictureBox wird lediglich dazu verwendet, dem Benutzer eine einzelne Grafik anzuzeigen.

228

Fragen und Antworten

Mit Hilfe von TabControl können Sie Steuerelemente auf logische Weise gruppieren, indem Sie Registerkarten (Tabseiten) verwenden. Die Steuerelemente TextBox und RichTextBox bieten dem Benutzer die Möglichkeit, Text in ein Feld einzugeben. Letzteres bietet den weitaus größeren Funktionsumfang: Der Benutzer kann u.a. Schriftart, Farbe, Größe und Ausrichtung des Textes ändern. Dieses Steuerelement ähnelt WordPad. Mit Hilfe des Timer-Steuerelements lassen sich Ereignisse in bestimmten Zeitabständen auslösen. Unter anderem können Sie damit Weckuhren erstellen oder automatisierte Datensicherungsprozeduren durchführen lassen. Mit TreeView können Sie hierarchisch angeordnete Informationen in einer einfach zu bedienenden Strukturansicht anzeigen. Zum Schluss haben Sie gelernt, wie Sie das Layout Ihrer Steuerelemente in Formularen steuern, indem Sie Dock, Anchor, TabIndex und TabStop verwenden. Die ersten beiden Eigenschaften führen ähnliche Funktionen aus, der Unterschied besteht darin, dass Dock ein Steuerelement an den Rand eines Formulars bewegt, Anchor aber die Position eines Steuerelements relativ zu den Rändern des Formulars fixiert – hier ist kein Andocken an den Rand nötig.

6.15 Fragen und Antworten F

GDI+ wurde heute mehrmals erwähnt. Um was handelt es sich dabei? A

GDI+ ist die erweiterte Schnittstelle zu Grafikgeräten (Graphics Device Interface, GDI), mit deren Hilfe Sie verschiedene Grafiktypen zeichnen und bearbeiten können und die Sie in die Lage versetzt, Zeichenverfahren in Windows zu handhaben. GDI+ wurde entwickelt, um Entwicklern zu ermöglichen, sich auf die Grafikfunktionen zu konzentrieren, ohne dabei an die vielen unterschiedlichen Typen von Grafik-Hardware (wie etwa 3D-Grafikkarten) und Treiber denken zu müssen. GDI+ ist das Hauptthema an Tag 13.

F

Verwendet Microsoft Word ein RichTextBox-Steuerelement als seine Benutzeroberfläche? A

Nein. Word verwendet eine besondere, speziell dafür entwickelte Steuerelementart, die der Öffentlichkeit nicht zugänglich ist. Rich Text wird als normaler Text dargestellt, doch mit speziellem Code für die Formatierung versehen. Word benutzt für das Speichern seiner Dateien ein Binärformat, das sie nur für Word brauchbar macht. Wenn Sie also eine Textverarbeitung mit dem gleichen Funktionsreichtum wie Word erstellen wollen, müssen Sie entweder Ihr eigenes Steuerelement schreiben oder auf dem RichTextBox-Steuerelement aufbauen.

229

Windows Forms mit Steuerelementen erweitern

6.16 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. Wodurch werden RadioButton-Auswahlen begrenzt? 2. Was bedeutet die folgende Datums-/Zeit-Formatzeichenfolge? "hh:MM:yy-dddd"

3. Welches Objekt ist mit dem TreeView-Steuerelement verknüpft? 4. Setzen Sie für ein Button-Steuerelement namens btHappy Eigenschaften, die es dazu veranlassen, senkrecht zu expandieren, sobald sein Containerformular seine Größe ändert. 5. Nennen Sie zehn Mitglieder, die allen heute besprochenen Steuerelementen gemeinsam sind! 6. Wie heißen die fünf Mitglieder des Timer-Steuerelements? 7. Wie fügt man dem Steuerelement TabControl Tabseiten hinzu? Beschreiben Sie dies in Worten und mit Hilfe einer Zeile Code. 8. Welche beiden Methoden sollte man ausführen, wenn man vorhat, einer ComboBox mit Hilfe der Add-Methode viele Elemente hinzuzufügen? Wenn Sie an Ihr Wissen über Windows Forms-Steuerelemente denken: Welche anderen heute vorgestellten Steuerelemente haben Ihrer Ansicht nach ebenfalls diese Methoden? 9. Wahr oder falsch? Das PictureBox-Steuerelement kann nur Bitmap- (.BMP) und GIFGrafiken anzeigen.

Übung Erstellen Sie in C# eine Anwendung, mit deren Hilfe Benutzer ihre CD-Sammlung katalogisieren und betrachten können. Sie müssen neue Künstler/Alben/Stücke in den Katalog aufnehmen und mit einer hierarchischen Liste betrachten können. (Kümmern Sie sich nicht um das Speichern der Eingaben – das besprechen wir an Tag 9, wenn es um ADO.NET geht.) Denken Sie daran, dass Alben nur Künstlern hinzugefügt werden und Stücke nur Alben.

230

Mit Dialogfeldern arbeiten

7

Mit Dialogfeldern arbeiten

Dialogfelder sind eine spezielle Art von Windows Forms, die hauptsächlich für die Interaktion mit dem Benutzer und die Anzeige von Meldungen eingesetzt wird. Während der Arbeit mit Windows haben Sie wahrscheinlich bereits Tausende davon gesehen, so etwa wenn Sie sich in Windows einloggen wollen. Dialogfelder sind ein sehr vielseitiges Werkzeug für Windows Forms und bieten zahlreiche komplexe Optionen für Ihre Anwendungen und deren Benutzer. Wir werden den ganzen Tag damit verbringen, den nicht ganz einfachen Umgang mit Dialogfeldern und den speziellen Dialogarten in Windows Forms zu erlernen. Heute erfahren Sie etwas über die verschiedenen Arten von Dialogfeldern in Windows und wie Sie 쐽

das »Ergebnis« eines Dialogfeldes bestimmen,

쐽

jedes beliebige Dialogfeld anpassen,

쐽

mit Hilfe von Dialogfeldern häufig auftretende Aufgaben in Windows bewältigen.

7.1

Informationen holen und anzeigen

Die wichtigste Aufgabe eines Dialogfeldes besteht darin, den Benutzer aufzufordern, Informationen einzugeben. Dies geschieht auf eine ganz andere Weise als bei Ihrem zentralen Windows Formular-Objekt, denn Sie können die Aufmerksamkeit des Benutzers auf recht direkte Weise gewinnen. Während Benutzer in Ihrem Formular häufig die Bitte um Information nur überfliegen, können Sie hingegen recht sicher sein, dass sie die angeforderten Informationen in einem Dialogfeld eingeben. Da Dialogfelder sich gut dazu eignen, die Aufmerksamkeit des Benutzers zu fesseln (Windows begleitet die erste Anzeige eines Dialogfeldes häufig mit einem Warnton), scheinen sie auch geradezu perfekt für das Anzeigen wichtiger Informationen zu sein. Im gestrigen Beispiel einer Weckuhr haben Sie das Meldungsfeld, einen speziellen Dialogfeldtyp, verwendet, um dem Benutzer eine Weckmeldung zukommen zu lassen. In ähnlicher Weise haben Sie in der gestrigen Übung, dem Aufbau eines Musikkatalogs, den Benutzer per Dialogfeld darauf hingewiesen, keine Objekte der falschen Kategorie zuzuordnen (etwa einen Künstler einem Album hinzuzufügen statt andersherum). Ob nun beim Anzeigen oder Einholen von Information, ein Dialogfeld schickt stets Daten zurück an das Hauptformular (mehr dazu später). Nachdem die erbetenen Informationen beschafft wurden, kann der Aufrufer des Dialogfeldes, normalerweise ein Form-Objekt, diese Informationen dazu verwenden, um einige Aktionen auszuführen. Wenn Sie beispielsweise in Word ein Dokument bearbeiten und versuchen, es ohne Speichern zu schließen, erscheint ein Dialogfeld, die Sie zum Spei-

232

Informationen holen und anzeigen

chern auffordert, wie in Abbildung 7.1 zu sehen. Je nachdem auf welche Schaltfläche der Benutzer klickt (JA, NEIN oder ABBRECHEN), führt Word die angemessene Aktion aus (also jeweils speichern, nicht speichern oder das Schließen des Dokuments abbrechen). Auf diese Weise zeigt das Dialogfeld einerseits eine Meldung an und holt auf der anderen Seite Informationen ein.

Abbildung 7.1: Dieses Dialogfeld in Microsoft Word erfordert eine Reaktion vom Benutzer.

Wie Sie heute weiter unten sehen werden, können Dialogfelder weitaus komplizierter sein, als dieses einfache Beispiel vermuten lässt. Sie bieten Ihnen als Entwickler eine Fülle von Möglichkeiten, Informationen zu beschaffen, und das Beste daran ist, dass .NET bereits die meisten komplizierten Arbeiten für Sie erledigt hat. Im Grunde ist ein Dialogfeld ein Form-Objekt, dessen FormBorderStyle-Eigenschaft auf FixedDialog gesetzt ist. (Wie Sie von Tag 3 noch wissen, bedeutet dies, dass das Fenster genau wie ein typisches Windows Forms-Fenster aussieht, nur dass sich seine Größe nicht ändern lässt.) Zusammen mit einer Eigenschaft, die als Modalität bezeichnet wird (mehr dazu später), macht dies Dialogfelder sehr effizient beim Einholen von Benutzereingaben. Der Benutzer kann nicht mit seiner Tätigkeit fortfahren, bis er das Dialogfeld beantwortet hat, um sie »aus dem Weg zu schaffen«. Obwohl es zutrifft, dass die einfachsten Dialogfelder nur etwas Text und zwei Schaltflächen für OK und ABBRECHEN aufweisen, sollte Sie dies nicht davon abhalten, dem Dialogfeld eigene Steuerelemente hinzuzufügen. Sie können sogar jedes Windows FormsSteuerelement – selbst Menüs und Statusleisten – integrieren, als ob es ein Form-Objekt wäre. Doch wozu sollte man ein Dialogfeld zu einer kompletten Anwendung ausbauen? Sicher nicht bis in Word-Dimensionen, doch vielleicht bis zur Komplexität eines Taschenrechners oder eines Temperaturumrechners (Fahrenheit in Celsius und umgekehrt). Doch letzten Endes läuft es auf Folgendes hinaus: Forms wurden dafür entwickelt, als Anwendungen zu agieren, und Dialogfelder nicht. Ich empfehle

Bitte beachten Sie

Verwenden Sie wie bisher Forms für die Anwendungserstellung, es sei denn, Sie hätten einen triftigen Grund, der dagegen spräche.

Verlassen Sie sich nicht nur auf Dialogfelder, um Benutzereingaben zu erhalten. Statt dessen sollten Sie sie nur einsetzen, um dem Benutzer etwas mitzuteilen.

233

Mit Dialogfeldern arbeiten

7.2

Unterschiedliche Arten von Dialogen

Am gebräuchlichste ist das OK/ABBRECHEN-Dialogfeld, doch es sind noch einige andere Typen verfügbar. Das .NET Framework stellt verschiedene Dialogfelder für die Mehrzahl der üblichen Windows-Aufgaben, die Benutzereingaben erfordern, zur Verfügung. Es steht Ihnen sogar frei, einen Benutzer dazu zu zwingen, auf ein Dialogfeld zu antworten, bevor er irgendetwas anderes tun kann. Wir wollen einen Blick auf die Eigenschaften werfen, die Dialogfelder steuern.

Modal vs. nichtmodal Ein modales Formular oder Dialogfeld fordert eine Eingabe vom Benutzer, bevor er mit seiner Tätigkeit in der Anwendung fortfahren kann. Ein Beispiel dafür ist die »Änderungen speichern?«-Abfrage in Word. Erscheint sie, kann man in Word nichts anderes tun als sie zu beantworten. Versucht man in das Hauptdokumentfenster zurückzugehen, erhält man einen Fehlerton und das Dialogfeld fordert erneut zur Antwort auf. Daher erfordert ein modaler Dialog eine Benutzereingabe. Modale Dialoge halten Sie zwar in der jeweiligen Anwendung auf, Sie können aber jederzeit zu einer anderen Anwendung wechseln, etwa zu Excel oder Photoshop. Ein nichtmodales Dialogfeld ist das genaue Gegenteil: Es verlangt keine Benutzereingabe, und der Benutzer kann zwischen der Anwendung und dem Dialog nach Belieben hin und her wandern. Der typische Einsatzbereich dafür ist ein Hilfe-Fenster, das sich neben der Anwendung positioniert und häufig auftretende Fragen beantwortet. Solche Dialoge verlangen nicht, dass Sie mit ihnen interagieren, obwohl Sie das natürlich tun können. Ein gutes Beispiel wäre der Microsoft Office-Assistent in Form einer Büroklammer. Es ist für den Entwickler oftmals schwieriger, mit nichtmodalen Dialogen umzugehen als mit modalen, denn er muss praktisch zwei Formulare gleichzeitig überwachen und passende Daten hin und her leiten. Bei einem modalen Dialog hingegen hat man es entweder mit dem Dialogfeld oder mit der Anwendung zu tun, nie aber mit beiden zugleich, was die Sache erleichtert. Aus diesem Grund werden nichtmodale Dialoge fast ausschließlich für die Informationspräsentation eingesetzt, aber nicht für die Datenbeschaffung.

234

Dialogfelder

Die Standarddialogfelder Standarddialogfelder (Common Dialog Boxes) dienen dazu, allgemein übliche Aufgaben vorzubereiten wie etwa das Öffnen und Speichern einer Datei, die Auswahl einer Schriftart usw. Da sie für häufige Aufgaben eingesetzt werden, sind sie an vielen Stellen anzutreffen – man denke nur an jede Anwendung, die das Öffnen einer Datei erlaubt. Sie setzt die gleiche Benutzeroberfläche für diese Aufgabe ein wie viele andere Anwendungen auch: ein Standarddialogfeld. Für den Entwickler ist dies enorm hilfreich, denn er muss für jede Anwendung, die er schreibt, keine eigenes Dialogfeld programmieren. In .NET Framework sind bereits sieben Klassen für Standarddialogfelder fix und fertig enthalten: 쐽

ColorDialog: Damit kann der Benutzer eine Farbe aus einer vorgegebenen Palette aus-

wählen (etwa um die Farbe einer Schriftart zu ändern). 쐽

FontDialog: Damit kann der Benutzer eine Schriftart auswählen.

쐽

OpenFileDialog: Damit kann der Benutzer eine zu öffnende Datei auswählen. Das

Dialogfeld öffnet die Datei nicht selbst, sondern erlaubt nur ihre Auswahl; Sie müssen in Ihrer Anwendung dafür sorgen, die ausgewählte Datei zu holen und zu öffnen; das Dialogfeld erledigt das nicht automatisch. 쐽

PageSetupDialog: Damit kann der Benutzer in Windows Dokumente formatieren (Sei-

tenränder einstellen, Papiergröße wählen usw.). 쐽

PrintDialog: Damit kann der Benutzer einen Drucker auswählen, Druckoptionen einstellen und ein Dokument drucken.

쐽

PrintPreviewDialog: Seiten- oder Druckvorschau. Damit kann der Benutzer prüfen, wie ein Dokument auf Papier aussehen wird, bevor er es ausdruckt.

쐽

SaveFileDialog: Damit kann der Benutzer Dateien in einem ausgewählten Ordner

speichern (gleicht dem »SPEICHERN UNTER...«-Dialog in Word). Diese Klassen verhalten sich genau wie andere Windows Forms-Steuerelemente oder -Dialogfelder, daher sollten Sie sie rasch erlernen können. Wir kommen heute noch auf sie zurück. Wir wollen zunächst sehen, wie man einfache Dialogfelder verwendet.

7.3

Dialogfelder

Das einfachste Dialogfeld ist die MessageBox-Klasse (Meldungsfeld). Sie verfügt über ein einziges (nicht geerbtes) Mitglied, die Show-Methode, die das Dialogfenster, das nur eine OK-Schaltfläche aufweist, auf den Bildschirm bringt:

235

Mit Dialogfeldern arbeiten

MessageBox.Show("Hallo Welt")

Diese Codezeile zeigt ein Dialogfenster mit dem Text »Hallo Welt« an sowie eine OKSchaltfläche. Für eine Reihe von Situationen reicht dieser Funktionsumfang aus. Die Show-Methode verfügt jedoch noch über einige Parameter, mit denen Sie sie Ihren Wünschen anpassen können. Sie können eine Instanz der MessageBox nicht direkt erzeugen. Der folgende Code etwa erzeugt einen Fehler: dim msgMyMessage as New MessageBox

Der einzige Weg, auf dem Sie mit der MessageBox interagieren können, besteht im Aufruf ihrer Show-Methode: MessageBox.Show("Hallo Welt!")

Tabelle 7.1 führt die verschiedenen Parameter für die Show-Methode auf, und zwar in der Reihenfolge, in der sie im Methodenaufruf stehen müssen (bis auf Nummer 2 sind alle Parameter optional). Nr. des Parameters

Typ

Beschreibung

1

IWin32Window

Das Fenster, vor dem das Dialogfeld angezeigt werden soll (z.B. Me in VB .NET oder this in C#).

2

String

Der im Dialogfenster anzuzeigende Text. Dies ist der einzige obligatorische Parameter.

3

String

Der in der Titelzeile anzuzeigende Text.

4

MessageBoxButtons

Anzahl und Typ der anzuzeigenden Schaltflächen.

5

MessageBoxIcon

Das im Dialogfenster anzuzeigende Symbol.

6

MessageBoxDefaultButton

Legt die (vorausgewählte) Standardschaltfläche fest.

7

MessageBoxOptions

Diverse Optionen für das Dialogfeld.

Tabelle 7.1: Parameter für die Methode MessageBox.Show

Sie könnten die MessageBox auf folgende Art und Weise anzeigen: MessageBox.Show(Me, "Hallo Welt", "Mein Dialogfeld") MessageBox.Show("Hallo Welt", "Mein Dialogfeld", MessageBoxButtons.OKCancel) MessageBox.Show(Me, "Hallo Welt", "Mein Dialogfeld", MessageBoxButtons.OKCancel, MessageBoxIcon.Hand)

236

Dialogfelder

Diese drei Aufrufe erzeugen die drei Dialogfelder, die Sie in Abbildung 7.2sehen. Abbildung 7.2: Sie können einem Meldungsfeld auf einfache Weise weitere (bis zu drei) Schaltflächen hinzufügen.

Die ersten drei in Tabelle 7.1 aufgeführten Parameter sind leicht zu verstehen. Die vier letzten hingegen sind Aufzählungen, die Anzeigeoptionen für das Dialogfeld angeben. Die MessageBoxButtons-Aufzählung enthält die Werte AbortRetryIgnore, OK, OKCancel, RetryCancel, YesNo und YesNoCancel. Der Zweck jeder einzelnen ist einfach herauszufinden: AbortRetryIgnore zeigt drei Schaltflächen an, die die Aufschriften BEENDEN, WIEDERHOLEN und IGNORIEREN tragen; OK zeigt einfach eine Schaltfläche mit OK an, usw. MessageBoxIcon zeigt neben dem Text im Meldungsfenster ein Symbol an. Die Werte können in Asterisk, Error, Exclamation, Hand, Information, None, Question, Stop oder Warning

bestehen. Die tatsächlich angezeigten Symbole können von Betriebssystem zu Betriebssystem variieren (in Windows sind es oftmals die gleichen). Die Abbildung 7.3 zeigt jedes dieser Symbole in Windows NT.

Abbildung 7.3: Der neunte Wert der MessageBoxIconAufzählung lautet None (keines). MessageBoxDefaultButton ist eine leicht zu erlernende Eigenschaft – sie besitzt nur drei Werte: Button1, Button2 und Button3. Die Eigenschaft legt fest, welche Schaltfläche im

Dialogfenster den voreingestellten Fokus hat. Diese Schaltfläche ist vorausgewählt, wenn das Dialogfeld angezeigt wird, und ist auch diejenige, die angeklickt wird, falls der Benut-

237

Mit Dialogfeldern arbeiten

zer die (¢)-Taste drückt. (Nochmals: Es passen maximal drei Schaltflächen in ein Meldungsfeld.) MessageBoxOptions schließlich besitzt vier nicht miteinander verwandte Werte. DefaultDesktopOnly und ServiceNotification geben an, dass das Meldungsfeld auf dem gerade

aktiven Bildschirm erscheinen soll (falls der Benutzer mehr als einen Monitor einsetzt). RightAlign gibt vor, dass der Text im Meldungsfeld rechtsbündig ausgerichtet sein soll, und RtlReading gibt an, dass der Text so formatiert sein soll, dass man ihn von rechts nach links lesen kann (was etwa in arabischen Ländern hilfreich ist). Mit Hilfe der Or- und |Operatoren können Sie diese Werte miteinander kombinieren. MessageBox.Show("Hallo Welt","Mein Dialogfeld"", MessageBoxButtons.OKCancel, MessageBoxIcon.None, MessageBoxDefaultButton.Button1, MessageBoxOptions.RightAlign Or MessageBoxOptions.ServiceNotification)

Eigene Dialogfelder erstellen Die MessageBox-Klasse ist ein ausgezeichnetes vorgefertigtes Dialogsteuerelement, das eine ganze Reihe von Optionen anbietet. Doch in manchen Fällen genügt die MessageBox Ihren Ansprüchen nicht. In diesen Fällen können Sie Ihre eigene Dialogfeldklasse erstellen. Diese aufzubauen entspricht fast dem Aufbau einer Windows Forms-Klasse; man erbt von System.Windows.Forms.Form, erstellt Steuerelemente, fügt sie dem Formular hinzu und sieht auch Ereignishandler vor. Der einzige Unterschied besteht darin, dass man dem übergeordneten Formular (das das Dialogfeld anzeigt) alle notwendigen Eigenschaften zur Verfügung stellt. Lassen Sie uns als Beispiel einmal das DATEI/ÖFFNEN-Dialogfeld von Microsoft Word, das in Abbildung 7.4 zu sehen ist, auf seine Bestandteile hin untersuchen.

Abbildung 7.4: Das Dialogfeld zum Öffnen von Dateien enthält verschiedene Arten von Steuerelementen.

238

Dialogfelder

Sie vermuten sicher schon, welche Arten von Steuerelementen nötig sind, um dieses Dialogfenster aufzubauen: eine ComboBox für die Dropdown-Listen der Verzeichnisse und der Dateitypen, eine Reihe von Button-Steuerelementen für die ÖFFNEN- und ABBRECHENSchaltflächen, ein paar Label-Steuerelemente, möglicherweise ein TreeView-Steuerelement und ein paar TextBox-Steuerelemente. Sobald der Benutzer eine Datei ausgewählt hat, will die Hauptanwendung nur eines wissen: Welche Datei ist das? Daraufhin wird der ausgewählte Dateiname im Textfeld DATEINAME angezeigt. Daher muss die Hauptanwendung die Eigenschaft Text dieser TextBox wissen, damit sie die Datei angemessen behandeln kann. Um diese Eigenschaftstypen dem Hauptformular offen zu legen, müssen wir Eigenschaften erstellen (ähnlich wie die Text-Eigenschaft). Listing 7.1 zeigt eine benutzerdefinierte Dialogfeldklasse, mit der der Benutzer die Titelzeile seines Formulars ändern kann. Listing 7.1: Ihre erste Anwendung mit einem benutzerdefinierten Dialogfeld 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:

Imports System Imports System.Windows.Forms Imports System.Drawing namespace TYWinForms.Day7 public class ChangeCaption : Inherits Form private btnChange as new Button private tbCaption as new TextBox public readonly property Caption as String Get Return tbCaption.Text End Get end property public sub New tbCaption.Location = new Point(10,10) btnChange.Text = "Ändern!" btnChange.Location = new Point(125,10) AddHandler btnChange.Click, new EventHandler(AddressOf Me.Clicked) Me.Text = "Überschrift ändern" Me.Size = new Size(250,100) Me.Controls.Add(btnChange) Me.Controls.Add(tbCaption) end sub

239

Mit Dialogfeldern arbeiten

30: 31: 32: 33: 34:

private sub Clicked(Sender as Object, e as EventArgs) Me.Hide end sub end class End Namespace

Speichern Sie diese Datei als listing7.1.vb. Auf den ersten Blick sieht der Code wie jede andere Windows Forms-Anwendung aus. In den Zeilen 8 und 9 erstellen Sie zwei Steuerelemente, richten in den Zeilen 18 bis 27 Eigenschaften in einem Konstruktor ein und erstellen einen Ereignishandler in den Zeilen 30 bis 32. Der Hauptunterschied besteht darin, dass es in diesem Code keine Main-Methode gibt. Das liegt daran, dass diese Klasse niemals selbstständig ausgeführt wird – sie sollte nur in einem Formular oder einer Anwendung verwendet werden. Werfen Sie einen Blick auf Zeile 30 und den Ereignishandler. Er tut nur eines, nämlich die Hide-Methode des Formulars aufzurufen. Ohne dies würde nichts passieren, sobald der Benutzer auf die Schaltfläche »Titelzeile ändern« geklickt hat. Da wir ein modales Dialogfeld erstellen wollen, würde dies bedeuten, dass der Benutzer nicht wieder zu der ursprünglichen Anwendung zurückkehren könnte. Indem Hide aufgerufen wird, bringen wir das Dialogfeld zum Verschwinden und holen statt dessen die ursprüngliche Anwendung in den Vordergrund, so dass wieder eine Interaktion möglich ist. Beachten Sie schließlich die Zeilen 11 bis 15, die das Erstellen von Eigenschaften in einer Klasse illustrieren. Die Deklaration ähnelt der einer Funktion, verwendet aber das Schlüsselwort property statt function. Innerhalb dieser Eigenschaft finden sich zwei besondere Schlüsselwörter: Get und Set. Der Code in Get wird ausgeführt, sobald eine andere Klasse auf diese Eigenschaft zugreifen will. Set hingegen wird eingesetzt, wenn eine andere Klasse für diese Eigenschaft einen Wert setzt. In unserem Fall brauchen wir jedoch keinen Set-Teil, daher schreiben wir nur den für Get und sorgen dafür, dass die Eigenschaft als readonly (Zeile 11) markiert ist. In die Get- und Set-Teile können Sie jeden beliebigen Code einfügen; hier jedoch wollen wir nur den Wert zurückgeben, der sich in der TextBox befindet, wobei wir das Return-Schlüsselwort verwenden. In C# würde diese Eigenschaft wie in folgendem Codestück aussehen: public string Caption { get { return tbCaption.Text; } }

Beachten Sie, dass C# nicht die Schlüsselwörter property oder readonly erfordert. Wenn Sie die Eigenschaft value setzen wollen, verwenden Sie das Schlüsselwort value:

240

Dialogfelder

'VB .NET Set tbCaption.Text = value End Set //C# set { tbCaption.Text = value; }

Die einzigen public-Mitglieder in der ChangeCaption-Klasse sind der Konstruktor und die Caption-Eigenschaft. Da wir nicht wünschen, dass andere Klassen direkt auf den Rest der Mitglieder zugreifen, machen wir sie alle private. Sie können diese Vorgehensweise bei der Deklaration von public- und privateVariablen auch für die Erstellung von Eigenschaften Ihrer regulären Klassen verwenden. Wir wollen uns die Anwendung ansehen, die diese benutzerdefinierte Dialogfeldklasse verwenden soll. Listing 7.2 zeigt eine einfache Applikation, mit der der Benutzer die Titelzeile des Formulars ändern kann, indem er das ChangeCaption-Dialogfeld aus Listing 7.1 sowie dessen Caption-Eigenschaft einsetzt. Listing 7.2: Die Verwendung des benutzerdefinierten Dialogfeldes 1: Imports System 2: Imports System.Windows.Forms 3: Imports System.Drawing 4: 5: namespace TYWinForms.Day7 6: 7: public class Listing72 : Inherits Form 8: private btnChange as new Button 9: 10: public sub New 11: btnChange.Text = "Überschrift ändern" 12: btnChange.Location = new Point(75,75) 13: btnChange.Size = new Size(100,75) 14: AddHandler btnChange.Click, new EventHandler(AddressOf Me.ShowChangeBox) 15: 16: Me.Text = "Überschrift ändern" 17: Me.Controls.Add(btnChange) 18: end sub 19: 20: public sub ShowChangeBox(Sender as Object, e as EventArgs) 21: dim dlgChangeCaption as new ChangeCaption 22: dlgChangeCaption.ShowDialog

241

Mit Dialogfeldern arbeiten

23: 24: 25: 26: 27: 28: 29: 30: 31:

Me.Text = dlgChangeCaption.Caption end sub public shared sub Main() Application.Run(new Listing72) end sub end class End Namespace

Speichern Sie diese Datei unter dem Namen listing7.2.vb. Listing 7.2 zeigt eine weitere einfache Windows Forms-Klasse, nur dass diese die Hauptanwendung darstellt und daher eine Main-Methode aufweist. Die Zeilen 1 bis 18 sind typisch; sie erstellen und instantiieren das Formular und seine Steuerelemente. Erst in Zeile 20 beginnt es interessant zu werden. Die Methode ShowChangeBox behandelt das Click-Ereignis der Schaltfläche btnChange. In Zeile 21 erzeugen Sie eine neue Instanz der in Listing 7.1 erstellten ChangeCaption-Klasse. Beachten Sie, dass dieses Vorgehen dem beim Erstellen jedes anderen .NET-Objekts entspricht. In Zeile 22 rufen Sie die ShowDialog-Methode auf, die das Dialogfenster zur modalen Anzeige veranlasst.

Moment mal! In Ihrer ChangeCaption-Klasse haben Sie keine ShowDialogMethode erstellt. Wo kam sie also her? Die Klasse System.Windows.Forms.Form enthält die ShowDialog-Methode, weshalb Ihre Dialogfeldklasse sie erben konnte. Das bedeutet aber auch, dass absolut jedes Windows Form-Formular als Dialogfeld eingesetzt werden kann. Das bietet Ihnen eine Menge Flexibilität, wenn Sie Ihre Anwendungen schreiben. Nachdem Zeile 22 ausgeführt und das Dialogfeld angezeigt wurde, geht die Kontrolle über die Anwendung an das modale Dialogfeld über – bis dieses Fenster wieder geschlossen wird, kann die Hauptanwendung nichts tun. Sobald Sie etwas in das Dialogfeld eingeben und die Schaltfläche »ÄNDERN!« anklicken, geht die Kontrolle wieder an die Hauptanwendung über. Die Ausführung geht in Zeile 24 weiter, die die Caption-Eigenschaft des Dialogfeldes holt und sie der Text-Eigenschaft des aktuellen Formulars zuweist. Nun verstehen Sie, wie die Caption-Eigenschaft aus Listing 7.1 eingesetzt wird. Da diese beiden Listings in unterschiedlichen Dateien gespeichert sind, müssen Sie beide zu einer Anwendung kompilieren. Mit Hilfe von Visual Studio .NET ist dies einfach: Sorgen Sie nur dafür, dass sich beide Dateien im selben Projekt befinden und kompilieren Sie sie dann ganz normal (indem Sie ERSTELLEN aus dem ERSTELLEN-Menü auswählen).

242

Dialogfelder

Wenn Sie den Befehlszeilencompiler verwenden, geben Sie nur die beiden Dateien im Befehl an: vbc /t:winexe /r:system.windows.forms.dll /r:system.drawing.dll listing7.1.vb listing7.2.vb

Solange sich diese beiden Dateien im selben Ordner befinden, funktioniert dieser Befehl und Sie erhalten eine ausführbare Datei namens Listing7.1.exe (die Reihenfolge, die Sie für die zu kompilierenden Dateien angeben, bestimmt den Namen der ausführbaren Datei). Das war's schon. Abbildung 7.5 zeigt das Ergebnis.

Abbildung 7.5: Es ist recht einfach, ein benutzerdefiniertes modales Dialogfeld zu erstellen.

Beachten Sie, dass Sie keine besonderen Eigenschaften für Ihre benutzerdefinierte Dialogfeldklasse einrichten mussten. Indem Sie die ShowDialog-Methode aufrufen, stellt die CLR sie automatisch als modales Dialogfeld dar. Doch genau wie in einem gewöhnlichen Formular können Sie Eigenschaften beliebig modifizieren, so etwa SizeGripStyle, um den Größenziehpunkt in der unteren rechten Ecke des Formulars zu ändern, oder ControlBox, um die rechts oben verfügbaren Steuerschaltflächen festzulegen. Wollen Sie Ihr Dialogfeld hingegen nichtmodal präsentieren, rufen Sie statt ShowDialog die Methode Show auf. Der Benutzer wird zwischen Dialogfenster und Hauptanwendung hin und her wechseln können. Doch in der soeben erstellten Anwendung würde dies eine Reihe von Problemen verursachen: 쐽

Da die Ausführung im Hauptformular nicht angehalten wird, sobald die Show-Methode aufgerufen wurde, wird Zeile 24 des Listing 7.2 (wo die Titelzeile aus dem Dialogfeld geholt wird) sofort ausgeführt und die Titelzeile des Formulars wird sich in eine leere Zeichenfolge verwandeln. Denn schließlich ist bei der Dialogfelderstellung das Textfeld tbCaption leer, und Zeile 24 wird ausgeführt, bevor Sie dazukommen, Text einzutragen und auf die ÄNDERN!-Schaltfläche zu klicken.

쐽

Der Benutzer kann fortwährend auf die Schaltfläche TITELZEILE ÄNDERN im Hauptformular klicken, was dazu führt, dass viele Dialogfelder auf einmal angezeigt werden.

243

Mit Dialogfeldern arbeiten

Wenn der Benutzer Text in das tbCaption-Feld eingibt und die Schaltfläche ÄNDERN! anklickt, verschwindet in diesem Fall das Dialogfeld und sonst passiert nichts; die Titelzeile des Formulars ändert sich nicht, denn Zeile 24 wurde bereits lange vor dem Anklicken der ÄNDERN!-Schaltfläche ausgeführt. Um also die Titelzeile dennoch zu bestimmen, müssen Sie irgendwie auf die Eigenschaft tbCaption.Text des Dialogfeldes zugreifen. Dies gelingt, wenn Sie eine neue public-Eigenschaft erstellen: Public property Caption As String Get return tbCaption.Text End Get Set tbCaption.Text = value End Set End Property

Die Lösung für das zweite Problem besteht im Einsatz eines modalen Dialogfeldes. Doch dann muss der Benutzer das Dialogfeld explizit schließen, bevor ihm erlaubt ist, zum Hauptformular zurückzukehren. Sorgen Sie dafür, dass Sie nur modale Dialogfenster verwenden, wenn Sie diese Funktionsweise nutzen wollen.

Informationen abrufen Wir haben bereits gesehen, wie man mit Hilfe von Eigenschaften Daten aus einem Dialogfeld beschafft. Doch manchmal reichen Eigenschaften nicht aus, um jede gewünschte Information zu bekommen. Gelegentlich müssen Sie auch wissen, auf welche Weise der Benutzer das Dialogfeld geschlossen hat: Hat er auf die OK-Schaltfläche geklickt? Oder doch auf die ABBRECHEN-Schaltfläche? Diese Fakten, die man als das Ergebnis (result) des Dialogfeldes bezeichnet, können die Arbeitsweise Ihrer Anwendung verändern, so dass es nötig ist, auch diese Werte zu beschaffen. Die Aufzählung DialogResult enthält mehrere Werte, mit deren Hilfe Sie das Ergebnis eines Dialogfeldes bestimmen. Die ShowDialog-Methode gibt einen Wert aus dieser Aufzählung zurück, so dass Sie damit tun können, was Sie wollen, etwa so: dim objDR as DialogResult objDR = dlgChangeCaption.ShowDialog if objDR = DialogResult.OK then 'die Titelzeile ändern elseif objDR = DialogResult.No then 'nichts tun end if

244

Dialogfelder

Je nach dem vom Dialogfeld gelieferten Ergebnis können Sie eine bedingte Ausführung beginnen. Für jede Schaltfläche in einem Dialogfeld gibt es einen DialogResult-Wert (und noch mehr): 쐽

Abort/Beenden

쐽

Cancel/Abbrechen

쐽

Ignore/Ignorieren

쐽

No/Nein

쐽

None/Kein

쐽

OK

쐽

Retry/Wiederholen

쐽

Yes/Ja

Listing 7.3 zeigt ein Beispiel dafür, wie man DialogResult in einem Meldungsfeld einsetzt. Listing 7.3: Das Ergebnis eines Dialogfeldes abrufen (in C#) 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19:

using System; using System.Windows.Forms; using System.Drawing; namespace TYWinForms.Day7 { public class Listing73 : Form { public Listing73() { if (MessageBox.Show("Wünschen Sie eine Vollbilddarstellung dieser Anwendung?", "Listing 7.3", MessageBoxButtons.YesNo) == DialogResult.Yes) { this.Size = Screen.GetWorkingArea(this).Size; this.DesktopLocation = new Point(0,0); } } public static void Main() { Application.Run(new Listing73()); } } }

In Zeile 9 prüfen Sie das Ergebnis der MessageBox.Show-Methode. Wenn es dem DialogResult.Yes-Wert entspricht (der Benutzer also die JA-Schaltfläche angeklickt hat), führen Sie den Code in den Zeilen 10 bis 11 aus: Er setzt die Größe des Formulars auf die Größe des Benutzerbildschirms und seine Position

245

Mit Dialogfeldern arbeiten

dort auf die obere linke Ecke. Alternativ können Sie die Zeilen 10 bis 11 durch folgenden Code ersetzen, um die Anwendung zu maximieren: this.WindowState = FormWindowState.Maximized;

Weil Sie die MessageBox mit Hilfe des Schaltflächensatzes MessageBoxButtons.YesNo angezeigt haben, weiß die CLR, dass die JA-Schaltfläche den Wert DialogReturn.Yes und die NEIN-Schaltfläche DialogResult.No zurückgeben soll. Erinnern Sie sich an das Beispiel des Word-Dialogfensters »Möchten Sie die Änderungen in [Dokumentname] speichern?«. Klicken Sie auf JA, dann gibt das Dialogfeld Dialogresult.Yes zurück und Word weiß Bescheid: Es führt den Code zum Sichern des Dokuments aus (es öffnet das Dialogfeld DATEI/SPEICHERN UNTER nur, falls es sich um eine neues Dokument handelt) und schließt dann das Fenster. Klicken Sie hingegen auf NEIN, wird DialogResult.No übergeben, das Dokument wird nicht gespeichert und Word wird beendet (sofern Sie den BEENDEN-Befehl in irgendeiner Form erteilt haben). Klicken Sie auf ABBRECHEN, lautet das Ergebnis DialogResult.Cancel und nichts passiert (das Dokument wird weder gespeichert noch geschlossen, auch Word wird nicht beendet). Das Ergebnis eines Dialogfeldes auf diese Weise abzurufen ist eine hervorragende, standardisierte Möglichkeit, um Anwendungen über Benutzeraktionen zu informieren. Was passiert jedoch, wenn Sie Ihr eigenes Dialogfeld erstellt haben? Woher weiß die CLR, dass Ihre ÄNDERN!-Schaltfläche einen Wert DialogResult.Yes zurückgeben soll? Tatsächlich ist es viel einfacher als Sie befürchten. Schaltflächen und Formulare verfügen über eine DialogResult-Eigenschaft, mit der Sie angeben können, welches Ergebnis zurückgegeben werden soll. Schauen wir uns eine modifizierte Version des benutzerdefinierten Dialogfeldes aus Listing 7.1 an, die hier in Listing 7.4 in C#-Code zu sehen ist. Listing 7.4: Eine modifiziertes benutzerdefiniertes Dialogfeld in C# 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15:

246

using System; using System.Windows.Forms; using System.Drawing; namespace TYWinForms.Day7 { public class ChangeCaption2 : Form { private Button btnChange = new Button(); private TextBox tbCaption = new TextBox(); public String Caption { get { return tbCaption.Text; } }

Dialogfelder

16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30:

public ChangeCaption2() { tbCaption.Location = new Point(10,10); btnChange.Text = "Ändern!"; btnChange.Location = new Point(125,10); btnChange.DialogResult = DialogResult.OK; this.Text = "Überschrift ändern "; this.Size = new Size(250,100); this.Controls.Add(btnChange); this.Controls.Add(tbCaption); } } }

Von der Sprache (und der Namensänderung der Klasse in Zeile 7) einmal abgesehen, gibt es in diesem Listing nur zwei Unterschiede zum Listing 7.1. Der Ereignishandler für das Clicked-Ereignis ist jetzt verschwunden, ebenso die Zuweisung eines Delegaten zu der Schaltfläche. Das wird gleich erklärt. Der zweite Unterschied besteht im Hinzufügen der Zeile 22. Hier weisen Sie der btnChange-Schaltfläche den Wert DialogResult.OK zu. Dies bewirkt zweierlei. Erstens gibt es dem übergeordneten Formular den Wert DialogResult.OK zurück (so wie die MessageBox in Listing 7.3 DialogResult.Yes zurückgab). Wird zweitens diese Schaltfläche angeklickt, schließt die CLR das Formular automatisch für Sie. Daher brauchen Sie nicht mehr die Hide-Methode aufzurufen und demzufolge auch keinen Ereignishandler für das Clicked-Ereignis. Indem Sie also die DialogResult-Eigenschaft angegeben haben, weiß die CLR, dass diese Klasse ein Dialogfeld ist und sich entsprechend verhält. Die Hauptanwendung muss sich ebenfalls ein klein wenig ändern. Die ShowChangeBoxMethode aus Listing 7.2 muss wie im folgenden Codestück aussehen: public void ShowChangeBox(Object Sender, EventArgs e) { DialogResult objDR; ChangeCaption2 dlgChangeCaption = new ChangeCaption2(); objDR = dlgChangeCaption.ShowDialog(); if (objDR == DialogResult.OK) { this.Text = dlgChangeCaption.Caption; } this.Text = dlgChangeCaption.Caption; }

247

Mit Dialogfeldern arbeiten

(Vergessen Sie nicht, auch den Rest des Listings in C#-Code umzuwandeln.) Das Ergebnis des neuen Dialogfeldes wird in der objDR-Variablen gespeichert, die in der zweiten Zeile erstellt wurde. Dieser Wert wird dann mit DialogResult.OK verglichen, und falls sie gleichwertig sind, ändert sich die Titelzeile des Formulars. Ist das nicht der Fall, passiert nichts. Ich empfehle

Bitte beachten Sie

Weisen Sie den Schaltflächen in Ihren benutzerdefinierten Dialogfeldern DialogResult-Werte zu. Dies ist eine Standardkonvention und erleichtert Ihnen und denjenigen, die Ihre Klasse verwenden, die Verwendung Ihrer benutzerdefinierten Dialogfelder.

Verlassen Sie sich nicht auf das übergeordnete Formular, dass es Ihr Dialogergebnis interpretiert, selbst wenn Sie der Einzige sind, der es je zu sehen bekommt. Das Zuweisen von DialogResult-Werten sorgt dafür, dass Ihre Anwendung standardisierte Werte verwendet, die leicht auszuwerten sind.

7.4

Standarddialogfelder

Wie gesagt gibt es sieben Standarddialogfelder in .NET (vgl. Aufzählung oben). Sie sind bereits vorgefertigt, um das Ausführen der entsprechenden Aufgaben zu erleichtern. In den folgenden Abschnitten wollen wir etwas über ihren jeweiligen Funktionsumfang erfahren. (Nähere Informationen finden Sie in Anhang B.) Alle sieben Dialogfelder außer PrintPreviewDialog weisen folgende zwei Mitglieder auf: ShowHelp und Reset. Das erste gibt an, ob im Dialogfeld eine HilfeSchaltfläche angezeigt werden soll. Die Reset-Methode setzt alle Eigenschaften eines bestimmten Dialogs auf ihre Vorgabewerte zurück. Diese Methode erweist sich im Umgang mit diesen vielschichtigen Steuerelementen als besonders hilfreich.

Ein- und Ausgabe von Dateien Die zwei Standarddialogfelder für die Ein- und Ausgabe (E/A bzw. I/O) von Dateien sind die Steuerelemente OpenFileDialog und SaveFileDialog. Sie haben eine Reihe von Funktionen gemeinsam, weshalb die meisten ihrer Eigenschaften, die wir hier besprechen, in beiden zu finden sind. Natürlich ist ihre wichtigste Eigenschaft FileName (und FileNames), denn sie gibt an, welche Datei der Benutzer zum Öffnen oder Speichern ausgewählt hat. Ihr Hauptformular kann diesen Wert holen und die betreffende Datei nach Bedarf öffnen oder speichern (mehr dazu an Tag 11). Das Instantiieren und Anzeigen dieser Steuerelemente ist einfach:

248

Standarddialogfelder

dim dlgOpen as new SaveFileDialog dlgOpen.ShowDialog

Dieser Code ergibt das in Abbildung 7.6 dargestellte Dialogfeld.

Abbildung 7.6: Das Steuerelement für den DATEI/SPEICHERN-Dialog ist in den meisten WindowsAnwendungen zu finden.

Beide Dialogfelder geben entweder DialogResult.OK oder DialogResult.Cancel zurück, je nachdem, ob der Benutzer SPEICHERN bzw. ÖFFNEN oder ABBRECHEN angeklickt hat. Daraufhin lässt sich die FileName-Eigenschaft abfragen: if dlgOpen.ShowDialog = DialogResult.OK then Me.Text = dlgOpen.FileName end if

Im OpenFileDialog können Sie dem Benutzer erlauben, mehr als eine Datei auszuwählen, indem Sie MultiSelect auf true setzen. Die FileName-Eigenschaft nimmt dann ein Array von Zeichenfolgen auf, die diese Dateien repräsentieren. Zusätzlich zu diesen Haupteigenschaften (FileName bzw. FileNames) gibt es noch weitere, mit denen Sie die Funktionen dieser Dialogfelder anpassen können. Die Filter-Eigenschaft lässt sich dazu verwenden, die Dateitypen festzulegen, die in den Feldern SPEICHERN UNTER/DATEITYP und ÖFFNEN/DATEITYP zu sehen sind. Diese Filter begrenzen die Typen von Dateien, die der Benutzer speichern oder öffnen kann. Der Filter selbst ist eine speziell formatierte Zeichenfolge. Der folgende Code lässt nur das Öffnen von Word(.doc) und Text- (.txt) Dateien zu: dlgOpen.Filter ="Nur-Text-Dateien (*.txt)|*.txt|Word-Dokumente (*.doc)|*.doc "

Die Zeichenfolge lässt sich in folgende Bestandteile zerlegen: Beschreibung (Erweiterung) | Filterzeichenfolge

249

Mit Dialogfeldern arbeiten

Die Beschreibung ist der benutzerfreundliche Text, den der Benutzer im jeweiligen Dialogfeld angezeigt bekommt. Der senkrechte Strich (das Pipe-Symbol, | ) trennt in dieser Zeichenfolge die Felder. Die Filterzeichenfolge wird vom Dialogfeld dazu verwendet, Dateinamenendungen zu filtern; *.txt bedeutet, dass nur Dateien mit der .txt-Endung im Dialogfeld erscheinen werden. Nachfolgende Dateitypen lassen sich mit dem senkrechten Strich abtrennen. FilterIndex lässt sich verwenden, um den Standardfilter, der vorausgewählt ist, anzugeben. InitialDirectory ist eine Zeichenfolge, die das Anfangsverzeichnis angibt, in dem das

Dialogfeld mit der Anzeige beginnt. Eine Reihe von Eigenschaften fordern den Benutzer unter bestimmten Bedingungen zu Eingaben auf. Setzt man die CheckPathExists-Eigenschaft in beiden Steuerelementen auf true, dann gibt das Dialogfeld eine Warnung aus, falls der aktuell angegebene Pfad nicht existiert. Die CheckFileExists-Eigenschaft des Dialogfeldes OpenFileDialog erledigt die gleiche Aufgabe hinsichtlich einer bestimmten Datei. CreatePrompt und OverwritePrompt im SaveFileDialog ähneln einander; beim ersten wird der Benutzer gefragt, ob eine neue Datei angelegt werden soll, falls sie noch nicht existiert, und das zweite verlangt vom Benutzer eine Entscheidung, ob eine vorhandene Datei überschrieben werden soll.

Farben und Schriftarten wählen Das Steuerelement ColorDialog ist eines der am leichtesten zu erlernenden Dialog-Steuerelemente. Es besitzt nur wenige Eigenschaften, die Sie kennen müssen. Listing 7.5 zeigt ein Beispiel für den Gebrauch dieses Steuerelements beim Einstellen der Hintergrundfarbe für Ihr Formular. Listing 7.5: Die Verwendung des Steuerelements ColorDialog 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14:

250

using System; using System.Windows.Forms; using System.Drawing; namespace TYWinForms.Day7 { public class Listing75 : Form { public Button btColor = new Button(); public Listing75() { btColor.Text = "Farbe ändern!"; btColor.Location = new Point(100,100); btColor.Size = new Size(100,25); btColor.Click += new EventHandler(this.ChangeColor);

Standarddialogfelder

15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30:

this.Controls.Add(btColor); } public void ChangeColor(Object Sender, EventArgs e) { ColorDialog dlgColor = new ColorDialog(); if (dlgColor.ShowDialog() == DialogResult.OK) { this.BackColor = dlgColor.Color; } } public static void Main() { Application.Run(new Listing75()); } } }

Dieses Listing zeigt eine einfache Anwendung mit nur einer Schaltfläche, die das Standarddialogfeld für die Farbauswahl anzeigt. Wählt der Benutzer eine Farbe in ColorDialog aus, wird diese in der Eigenschaft ColorDialog.Color abgelegt. In Zeile 22 nehmen wir diese Farbe und weisen sie dem Wert BackColor des Hauptformulars zu. Abbildung 7.7 zeigt das Ergebnis dieser Anwendung und das Dialogfeld ColorDialog.

Abbildung 7.7: Das Steuerelement ColorDialog ist ein leicht zu bedienendes Dialogfeld.

251

Mit Dialogfeldern arbeiten

Das ist schon alles, was Sie für den Einsatz von ColorDialog benötigen. Das Steuerelement hat noch weitere Funktionen, mit denen der Benutzer mehr Farben als die dargestellten auswählen kann. Wenn Sie AllowFullOpen auf true setzen, kann der Benutzer ein zusätzliches Fenster öffnen (indem er auf die Schaltfläche FARBEN DEFINIEREN klickt, die sich am unteren Rand des Dialogfeldes in Abbildung 7.7 befindet), um eigene Farben zu definieren, die er aus allen Farben auswählt, die ihm das jeweilige Betriebssystem anbietet. (Wenn Sie diese Funktion nicht gestatten wollen, setzen Sie AllowFullOpen auf false und setzen auch die Eigenschaft FullOpen, die die Schaltfläche für benutzerdefinierte Farben anzeigt, auf false.) Nachdem der Benutzer einige selbst definierte Farben ausgewählt hat, können Sie die Eigenschaft CustomColors dazu verwenden, um ein Array von Color-Objekten zurückzugeben. Das Schriftartdialogfeld FontDialog ist ein wenig vielschichtiger, denn es gibt ja eine Vielzahl unterschiedlicher Schriftstile. Die Farbe Blau ist nun mal blau, aber die Schriftart Arial kann Arial fett, kursiv oder Standard sein, und als Größen sind beispielsweise 10, 20 oder 36 Punkt möglich. Und schließlich gibt es noch unterschiedliche Schriftstile wie etwa Skript (Nicht-OEM- und ANSI-Zeichensätze), Vektorschriften, vertikale Schriften und so weiter. Wenn Sie nichts von diesen Details halten, können Sie einfach die Eigenschaft FontDialog.Font verwenden, um die vom Benutzer ausgewählte Schrift zu zurückzugeben – das haben Sie sicherlich schon vermutet: if (dlgFont.DialogResult == DialogResult.OK) { this.Font = dlgFont.Font; }

Das ist wesentlich einfacher als jedes Mal, wenn man die Schriftart ändern möchte, ein neues Font-Objekt erstellen zu müssen! Abbildung 7.8 zeigt das Standarddialogfeld für die Schriftartauswahl.

Abbildung 7.8: Das Standarddialogfeld FontDialog bietet zahlreiche Auswahlmöglichkeiten an.

252

Standarddialogfelder

Alle Felder im Schriftartdialogfeld (Unterstreichen, Größe, Zeichensätze usw.) lassen sich anpassen. Mit AllowScriptChange kann der Benutzer den Standardzeichensatz ändern, während ScriptsOnly nur Skriptschriften anzeigt. AllowSimulations, AllowVectorFonts und AllowVerticalFonts gestatten die Verwendung der angegebenen Schriftarttypen (sie sind per Vorgabe alle auf true gesetzt). FixedPitchOnly erlaubt nur die Anzeige von Schriftarten mit festem Zeichenabstand (z.B. Courier). Mit ShowColor kann der Benutzer die Farbe seiner Schrift ändern (die ColorEigenschaft gibt diese Farbe zurück) und ShowEffects zeigt die Ergebnisse der Unterstrei-

chungsoptionen. Sie können schließlich noch die Eigenschaften MaxSize und MinSize einstellen, damit der Benutzer nur im Bereich zwischen einer maximalen und minimalen Schriftgröße auswählen kann. Die Einstellung dieser Werte auf null versetzt das System in die Lage, diese Werte zu steuern – es wird normalerweise die komplette Bandbreite der Größen erlauben.

Drucken Die letzte Reihe von Standarddialogfeldern, die wir betrachten, befasst sich mit dem Seitendruck: PageSetupDialog, PrintDialog und PrintPreviewDialog. Sie sollten allen vertraut sein, die schon einmal Dokumente in Windows gedruckt haben. PageSetupDialog gestattet die Randeinstellung für ein Dokument, das Ändern der Ausrichtung (Hoch- oder Querformat ), das Ändern des eingestellten Papierformats usw.

Bevor Sie jedoch einen PageSetupDialog-Dialogfeld verwenden können, müssen Sie Ihre Einstellungen auf etwas anwenden können. Dies wird durch das Erstellen eines PageSettings-Objekts bewerkstelligt, woraufhin es der PageSettings-Eigenschaft von PageSetupDialog zugewiesen wird. Sie gibt an, auf welche Objekte diese Einstellungen angewendet werden sollen. Listing 7.6 zeigt eine Beispielanwendung, die genau dies tut. Listing 7.6: Das Einrichten einer Seite 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11:

using using using using

System; System.Windows.Forms; System.Drawing; System.Drawing.Printing;

namespace TYWinForms.Day7 { public class Listing76 : Form { private PageSettings objPageSettings; private Button btShowDialog = new Button(); public Listing76() {

253

Mit Dialogfeldern arbeiten

12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32:

btShowDialog.Text = "Seiteneinstellungen"; btShowDialog.Click += new EventHandler(this.ShowSettings); this.Controls.Add(btShowDialog); } private void ShowSettings(Object Sender, EventArgs e) { if (objPageSettings == null) { objPageSettings = new PageSettings(); } PageSetupDialog dlgSettings = new PageSetupDialog(); dlgSettings.PageSettings = objPageSettings; dlgSettings.ShowDialog(); } public static void Main() { Application.Run(new Listing76()); } } }

Die Verwaltung von Seiteneigenschaften kann etwas kompliziert sein. Erstellen Sie hierzu zunächst ein Objekt System.Drawing.Printing.PageSettings (siehe Zeile 8; beachten Sie das neue using-Statement in Zeile 4). Dieses Objekt wird im Rest Ihrer Anwendung verwendet, daher ist es nötig, ein der ganzen Klasse zur Verfügung stehendes Objekt zu erstellen. In der ShowSettings-Methode in Zeile 18 müssen Sie dieses PageSettings-Objekt überprüfen. Ist es null (oder Nothing in VB .NET), sind diesem Dokument noch keine Eigenschaften zugewiesen worden, so dass Sie dieses Objekt (in Zeile 20) instantiieren müssen. Ist es aber nicht null, wurde das PageSettings-Objekt bereits instantiiert und es wurden Eigenschaften zugewiesen; daher wollen wir es wieder und wieder verwenden. Zeile 23 erzeugt einen neuen PageSetupDialog. In Zeile 24 wird das PageSettingsObjekt (ob neu oder bereits vorhanden) der PageSettings-Eigenschaft zugewiesen. Nun können die vom Benutzer gewählten Einstellungen gespeichert und nach Bedarf auf das Dokument angewendet werden. Die Methode ShowDialog wird in Zeile 25 aufgerufen; beachten Sie, dass Sie ihren DialogResult-Wert nicht prüfen müssen. Der Grund: Der PageSetupDialog kümmert sich selbst darum, die Einstellungen anzuwenden, je nachdem, welche Schaltfläche der Benutzer angeklickt hat. Uns kümmert es daher nicht, ob der Benutzer OK oder ABBRECHEN angeklickt hat, denn der PageSetupDialog handhabt dies intern.

254

Standarddialogfelder

Kompilieren Sie diese Anwendung und führen Sie sie aus. (Wie Sie noch von Tag 2 wissen, befindet sich der Namensraum System.Drawing.Printing in der Assembly System.drawing.dll, so dass Sie beim Kompilieren keine zusätzlichen Referenzen hinzufügen müssen.) Klicken Sie auf die Schaltfläche SEITE EINRICHTEN und ändern Sie einige Seiteneigenschaften. Schließen Sie den Dialog und öffnen ihn erneut mit der Schaltfläche. Beachten Sie, dass die vorgenommenen Änderungen sich immer noch im PageSetupDialog zeigen. Der Grund dafür ist, dass die vorgenommenen Änderungen dem PageSettingsObjekt zugewiesen wurden, welches immer wieder verwendet wird. Abbildung 7.9 zeigt das Ergebnis dieser Anwendung.

Abbildung 7.9: PageSetupDialog stellt ein Dialogfeld zur Seiteneinrichtung zur Verfügung.

Wie die anderen Standarddialogfelder, die wir heute besprochen haben, weist auch PageSetupDialog einige Eigenschaften auf, mit denen Sie das Dialogfeld anpassen können. AllowMargins, AllowOrientation, AllowPaper und AllowPrinter zeigen die Fenster an, in denen der Benutzer jeweils Ränder, Seitenausrichtung (hoch/quer), Papiergröße und Druckeinstellungen ändern kann. Wird die AllowPrinter-Einstellung geändert, benötigen Sie ein PrinterSettings-Objekt, doch dies werden wir an Tag 11 bezüglich Datei-E/A besprechen. MinMargins gibt den geringsten Seitenrand an, den Ihre Anwendung zulässt. Document gibt das PrintDocument-Objekt an, von dem man Seiteneinstellungen bezieht. Das PrintDialog-Steuerelement ist einfacher zu handhaben. Ähnlich wie der PrintSetupDialog enthält es die Eigenschaften Document und PrinterSettings, um die Einstellungen zu überwachen. Damit dieses Steuerelement funktioniert, müssen Sie der PrinterSettings-Eigenschaft ein PrinterSettings-Objekt zuweisen. Doch anders als im PageSetupDialog sollte man die DialogResult-Eigenschaft prüfen, sobald das Dialogfeld geöffnet wird. Abbildung 7.10 zeigt ein typisches DRUCKEN-Dialogfeld.

255

Mit Dialogfeldern arbeiten

Abbildung 7.10: Das Steuerelement PrintDialog stellt ein nützliches Dialogfeld für das Drucken zur Verfügung.

Das letzte Standarddialogfeld, das wir heute erörtern, ist das PrintPreviewDialog-Objekt. Es unterscheidet sich von den anderen Steuerelementen, denn anders als die anderen Standarddialogfelder erbt es nicht von der CommonDialog-Klasse. Es sieht nicht einmal wie ein Standarddialogfeld aus. Auch sein DialogResult muss nicht überwacht werden. Wir brauchen uns beim PrintPreviewDialog-Steuerelement nur um drei Eigenschaften zu kümmern. Document, die erste, gibt das Dokument für die Vorschau an. Doch Vorsicht: Diese Eigenschaft akzeptiert nicht jedes x-beliebige Dokument; sie ist sehr wählerisch. Sie müssen ihr ein PrintDocument-Objekt zuweisen, welches wiederum das Dokument repräsentiert, dessen Vorschau man sehen will. Wir werden dieses Objekt näher an Tag 11 besprechen. Die nächsten beiden Eigenschaften sind einfach. PrintPreviewControl gibt natürlich das Steuerelement PrintPreviewControl im PrintPreviewDialog-Fenster zurück. Dieses Steuerelement zeigt die eigentliche Vorschau an, denn der Rest der Schaltflächen und Steuerelemente von PrintPreviewDialog besteht aus separaten Elementen. Wenn Sie Ihr eigenes benutzerdefiniertes Druckvorschau-Dialogfeld erstellen wollen, werden Sie höchstwahrscheinlich das Steuerelement PrintPreviewDialog dafür verwenden. UseAntiAlias gibt an, ob das Vorschau-Dokument mit Antialiasing behandelt wird, das

heißt, ob die Kanten des Dokuments (genauer: der verwendeten Schriftzeichen) geglättet werden sollen, so dass keine Treppchen oder harten Kanten auftauchen. Das Antialiasing lässt die Darstellung weicher und angenehmer aussehen, natürlich auf Kosten der Schärfe. Abbildung 7.11 zeigt das Steuerelement PrintPreviewDialog in Aktion.

256

Zusammenfassung

Abbildung 7.11: Sie können das Dialogfenster PrintPreviewDialog

dazu verwenden, eine Seitenvorschau eines Dokuments zu erhalten.

7.5

Zusammenfassung

Wie Sie heute erfahren haben, können Dialogfelder weitaus vielschichtiger und funktionsreicher sein als die einfache MessageBox, die Sie bislang verwendet haben. Dialogfelder werden für das Beschaffen von Benutzereingaben eingesetzt, ob das nun ein einfaches Ja oder Nein ist oder eine Auswahl unter Schriftarten und Farben. Zunächst muss man sich merken, dass Dialogfelder modal oder nichtmodal sein können. Ein modaler Dialog hindert den Benutzer daran, zur Hauptanwendung umzuschalten, es sei denn, er antwortet zuerst auf das Dialogfeld. Nichtmodale Dialoge hingegen erlauben das Wechseln zwischen Dialogfeld und Hauptanwendung, doch können sie zu Problemen führen, da man mehr als ein Formular auf einmal steuern muss. Verwenden Sie daher nichtmodale Dialogfelder nur, wenn Sie dem Benutzer lediglich Informationen (z.B. im Hilfe-Fenster) anzeigen müssen, ohne zugleich Informationen einzuholen. Das Ihnen vertrauteste Dialogfeld ist die MessageBox (Meldungsfeld). Dieses Steuerelement besitzt nur eine Methode namens Show, die bis zu sieben Parameter übernehmen kann, um z.B. festzulegen, welches Symbol im Meldungsfeld erscheint, welche Schaltflächen verfügbar sind sowie die Titelzeile und der Text, die anzuzeigen sind. Wenn Sie mehr Funktionen benötigen, als die einfache MessageBox bereitstellt, müssen Sie Ihre eigenen Dialogfeldklassen erstellen. Man erstellt diese Klassen genau wie StandardForm-Klassen; man erbt von der Klasse System.Windows.Forms.Form und stellt Konstruktoren

257

Mit Dialogfeldern arbeiten

und Ereignishandler bereit. Sie können Werte Ihres benutzerdefinierten Dialogfeldes gegenüber dem Hauptformular offen legen, indem Sie (mit Hilfe der Get- und Set-Statements) public-Eigenschaften erzeugen. Ihre Dialogfelder können Werte zurückgeben, die angeben, auf welche Schaltfläche (wie etwa OK oder ABBRECHEN) der Benutzer zum Schließen des Dialogfeldes geklickt hat. Diese Werte befinden sich in der DialogResult-Aufzählung. Das übergeordnete Formular kann auf diese DialogResult-Werte hin prüfen, um herauszufinden, was der Benutzer mit dem Dialogfeld getan hat. Sie haben auch von der Vielzahl der Standarddialogfeld-Steuerelemente erfahren, die .NET bereitstellt. Diese Steuerelemente kapseln gebräuchliche Windows-Funktionen wie etwa die Auswahl von Schriftarten oder Farben, das Drucken und die Druckvorschau, um nur einige zu nennen. Die Themen der nächsten Woche befassen sich mit der Erhöhung des Funktionsumfangs Ihrer Anwendung, so etwa dem Hinzufügen einer Datenbank und von Grafikfähigkeiten. Vergessen Sie nicht das Bonusprojekt »Eine Textverarbeitung erstellen« am Ende dieser Woche anzusehen, bevor Sie fortfahren.

7.6 F

Fragen und Antworten

Worin besteht der Unterschied zwischen den heute erstellten Steuerelementen und öffentlichen Variablen? A

Mit beiden können Sie Daten von einer Klasse an eine andere übergeben. In Listing 7.1 hätten wir beispielsweise die Eigenschaft mit der folgenden Codezeile deklarieren können: public property Caption as String

Und solange Sie die Eigenschaft tbCaption.Text dieser Variable zuweisen, wäre die Funktionalität die gleiche. Der Unterschied in der Verwendung von Eigenschaft und öffentlichen Variablen besteht darin, dass Sie mit der Eigenschaft zusätzlichen Code in den get- und set-Statements ausführen können. Das erweist sich als nützlich, wenn Sie etwa Werte verifizieren müssen, bevor Sie sie zurückgeben: public property Caption as String Get if tbCaption.Text <> "" then return tbCaption.Text else return "Hier befindet sich nichts!"

258

Workshop

end if End Get End Property

Mit einer öffentlichen Variablen lässt sich keine zusätzliche Funktion ausführen. F

Wie bringe ich das Dokument dazu, in meinem Steuerelement PrintPreviewDialog zu erscheinen? A

7.7

Die Antwort erfordert Wissen über eine neue Klasse namens PrintDocument und neue Fertigkeiten, die Sie noch nicht erworben haben. Um nähere Informationen hierzu zu erhalten, lesen Sie bitte Tag 11.

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? Jedes Form-Objekt kann ein Dialogfeld sein. 2. Wie macht man ein Dialogfeld modal bzw. nichtmodal? 3. Wahr oder falsch? Sie können ein MessageBox-Objekt direkt instantiieren. 4. Wie heißen die sieben Parameter, die die MessageBox.Show-Methode übernehmen kann? (Führen Sie nur ihre Typen mit einer kurzen Beschreibung auf.) 5. Welche zwei Vorteile erzielen Sie, wenn Sie in Ihrer benutzerdefinierten Dialogklasse einen DialogResult-Wert zuweisen? 6. Ist das folgende Codestück korrekt? Falls nicht, nennen Sie die Fehler. public property IsClicked as string Get return blnClicked end property

7. Welche zwei Mitglieder haben fast alle Standarddialogfeld-Steuerelemente gemeinsam? Nennen Sie die Ausnahme(n). 8. Schreiben Sie eine Filterzeichenfolge für ein OpenFileDialog-Steuerelement, das Textdateien (*.txt), Bilddateien (*.gif) und Alle Dateien (*.*)anzeigt.

259

Mit Dialogfeldern arbeiten

9. Nennen Sie die Haupteigenschaften (also die Eigenschaften, die Sie am meisten interessieren, wenn der Benutzer eine Auswahl trifft) für die Steuerelemente OpenFileDialog, SaveFileDialog, ColorDialog und FontDialog.

Übung Erstellen Sie in C# eine voll funktionsfähige Anwendung mit Menüs, welche alle Standarddialogfeld-Steuerelemente verwendet. Setzen Sie auch ein nichtmodales Dialogfeld ein, um kontextabhängige Hilfeinformationen anzuzeigen. Wenn sich ein Benutzer von einem Menüelement zum nächsten bewegt, sollte sich der Inhalt dieses Dialogfeldes ändern. (Tipp: Verwenden Sie das MenuItem.Select-Ereignis, um festzustellen, über welchem Menüelement sich die Maus gerade befindet.)

260

Woche 1 – Rückblick Projekt 1: Eine Textverarbeitung erstellen Herzlichen Glückwunsch zum Überstehen der ersten Woche! Sie dürften nun mit dem Schreiben von Windows Forms-Anwendungen in C# und Visual Basic .NET vertraut sein. Ihnen dürften auch die Schwierigkeiten beim Umgang mit Ereignissen und Windows Forms-Steuerelementen bewusst sein. Mit dem bislang erworbenen Wissen sind Sie bereit, praktisch jede einfache Anwendung anzupacken, aber auch einige der vielschichtigeren. Als eine Form der Rekapitulation der vergangenen sieben Tage wird dieses Rückblickkapitel (sowie diejenigen der Wochen 2 und 3) Sie durch den Vorgang der Erstellung Ihres eigenen Textverarbeitungsprogramms führen, und zwar eines Programms, das es mit Microsoft Word aufnehmen könnte. In dieser Lektion legen Sie erst einmal das Fundament für diese Anwendung; das Bonusprojekt am Ende der zweiten Woche wird Ein- und Ausgabefunktionen für Daten und Dateien hinzufügen. Das Projekt 3 wird einige fortgeschrittenere Leistungsmerkmale integrieren. Es wird empfohlen, dass Sie diese Projekte durcharbeiten. Sie machen Sie besser mit Windows Forms-Konzepten vertraut, da Sie Situationen aus der Praxis handhaben werden.

Über das Textverarbeitungsprojekt Dieses Projekt soll Ihnen Gelegenheit geben, an einer Anwendung in jeder Phase ihrer Erstellung zu arbeiten. In dieser Lektion fangen Sie erst einmal mit einem einfachen Entwurf an, installieren die grundlegenden Funktionen und erweitern diese um peppige Zusatzelemente. Dieses Projekt dient auch dazu, Ihre Fähigkeiten zu stählen, was die Entwicklung von Windows Forms-Anwendungen anbelangt. So können Sie sich später in Ihren anderen Projekten sicherer fühlen. Am Ende der zweiten bzw. dritten Woche werden Sie zu diesem Projekt zurückkehren, um die Ergebnisse der weiteren Lektionen zu integrieren. Diese Anwendung, die wir NetWord taufen wollen, wird es dem Benutzer gestatten, Dokumente zu bearbeiten und zu speichern, Suchoperationen aus zuführen, Text zu formatieren und schließlich Dokumente zu drucken und im Web zu surfen. In dieser Lektion jedoch werden wir lediglich das grundlegende Gerüst sowie die Benutzeroberfläche erstellen.

261

Woche 1 – Rückblick

Was Sie benötigen Der wichtigste Teil jedes Textverarbeitungsprogramms ist natürlich die Hauptbedienoberfläche: der Textbereich, in dem der Benutzer Dokumente tippen und bearbeiten kann. Dreimal dürfen Sie raten, wie wir diese Komponente erstellen. Ich hoffe, Sie haben auf das Steuerelement RichTextBox getippt. Bereits an Tag 6 haben wir gesehen, dass dieses Steuerelement beinahe alle Funktionen eines Textverarbeitungsprogramms ausführen kann, vom Formatieren eines Textes bis zur Durchführung einer Suchoperation. Das Einrichten des RichTextBox-Steuerelements bedeutet jedoch nur den halben Sieg. Man muss auch Menüs hinzufügen, mit denen der Benutzer zum Beispiel Dateien öffnen und speichern, Text formatieren und Farben auswählen kann. Die Menüs sowie das RichTextBox-Steuerelement stellen in diesem Projekt die Hauptteile der Anwendung dar. Um die Anwendung noch bedienungsfreundlicher zu machen, sind noch weitere Steuerelemente nötig, so etwa eine Statusleiste und Kontextmenüs. Sie werden im Abschnitt »Einige nützliche Dinge mit Pfiff hinzufügen« weiter unten beschrieben. Obwohl die meisten Textverarbeitungsprogramme MDI-Anwendungen (Multiple Document Interface, Mehrfachdokumentschnittstelle) sind – sie können mehr als ein Dokument zugleich öffnen –, wird unsere erst einmal nur ein einzelnes Dokument anzeigen können. Auf MDI-Anwendungen kommen wir an Tag 10 zurück.

Die Benutzeroberfläche aufbauen Listing R1.1 zeigt das grundlegende Gerüst für unsere Anwendung. Listing R1.1: Die NetWord-Klasse 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12:

262

using System; using System.Windows.Forms; using System.Drawing; namespace TYWinforms.P1 { public class NetWord : Form { public NetWord() { this.Text = "NetWord v.1"; this.Size = new Size(800,600); } public static void Main() {

Woche 1 – Rückblick

13: 14: 15: 16:

Application.Run(new NetWord()); } } }

Speichern Sie dieses Listing unter dem Namen NetWord.cs. Wie Sie sehen, weist der Code außer einer Main-Methode und einem einfachen Konstruktor kaum etwas Bemerkenswertes auf. Das Kompilieren und Ausführen dieser Anwendung wird zu einer leeren Applikation wie in Abbildung R1.1 führen. Wir wollen als Nächstes die Benutzeroberfläche erstellen. Wir müssen das RichTextControl-Steuerelement hinzufügen und alle anderen Steuerelemente, die damit verknüpft sind (wie etwa Menüs). Werfen Sie einen Blick auf Listing R1.2.

Abbildung R1.1: Die bescheidenen Anfänge von NetWord

Listing R1.2: Die Document-Klasse 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12:

using using using using using

System; System.Windows.Forms; System.Drawing; System.Drawing.Printing; System.ComponentModel;

namespace TYWinforms.P1 { public class NetWord : Form { private RichTextBox rtbDocument = new RichTextBox(); private MainMenu mnuMain = new MainMenu(); private MenuItem mniFile = new MenuItem("Datei");

263

Woche 1 – Rückblick

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: 46: 47: 48: 49: 50: 51: 52: 53: 54: 55: 56: 57: 58:

264

private private private private private private

MenuItem MenuItem MenuItem MenuItem MenuItem MenuItem

mniOpen = new MenuItem("Öffnen..."); mniSave = new MenuItem("Speichern"); mniPageSetup = new MenuItem("Seite einrichten..."); mniPrintPreview = new MenuItem ("Druckvorschau"); mniPrint = new MenuItem("Drucken..."); mniExit = new MenuItem("Beenden");

private private private private private private

MenuItem MenuItem MenuItem MenuItem MenuItem MenuItem

mniEdit = new MenuItem("Bearbeiten"); mniUndo = new MenuItem("Rückgängig"); mniCut = new MenuItem("Ausschneiden"); mniCopy = new MenuItem("Kopieren"); mniPaste = new MenuItem("Einfügen"); mniFind = new MenuItem("Suchen...");

private MenuItem mniFormat = new MenuItem("Format"); private MenuItem mniFont = new MenuItem("Schriftart..."); private private private private private private private private private private

Font fntCurrent = new Font("Times New Roman", 10); Color fntColor = Color.Black; FontDialog dlgFont = new FontDialog(); OpenFileDialog dlgOpen = new OpenFileDialog(); SaveFileDialog dlgSave = new SaveFileDialog(); PrintPreviewDialog dlgPrintPreview = new PrintPreviewDialog(); PageSetupDialog dlgPageSetup = new PageSetupDialog(); PrintDialog dlgPrint = new PrintDialog(); PageSettings objPageSettings = new PageSettings(); PrinterSettings objPrintSettings = new PrinterSettings();

public NetWord() { rtbDocument.Dock = DockStyle.Fill; rtbDocument.Font = fntCurrent; rtbDocument.HideSelection = false; mniOpen.Click += new EventHandler(this.FileClicked); mniSave.Click += new EventHandler(this.FileClicked); mniPageSetup.Click += new EventHandler (this.FileClicked); mniPrintPreview.Click += new EventHandler (this.FileClicked); mniPrint.Click += new EventHandler(this.FileClicked); mniExit.Click += new EventHandler(this.FileClicked); mniUndo.Click += new EventHandler(this.EditClicked); mniCut.Click += new EventHandler(this.EditClicked); mniCopy.Click += new EventHandler(this.EditClicked); mniPaste.Click += new EventHandler(this.EditClicked); mniFind.Click += new EventHandler(this.EditClicked);

Woche 1 – Rückblick

59: 60: 61: 62: 63: 64: 65: 66: 67: 68: 69: 70: 71: 72: 73: 74: 75: 76: 77: 78: 79: 80: 81: 82: 83: 84: 85: 86: 87: 88: 89: 90: 91:

mniFont.Click += new EventHandler (this.FormatClicked); mnuMain.MenuItems.Add(mniFile); mnuMain.MenuItems.Add(mniEdit); mnuMain.MenuItems.Add(mniFormat); mniFile.MenuItems.Add(mniOpen); mniFile.MenuItems.Add(mniSave); mniFile.MenuItems.Add("-"); mniFile.MenuItems.Add(mniPageSetup); mniFile.MenuItems.Add(mniPrintPreview); mniFile.MenuItems.Add(mniPrint); mniFile.MenuItems.Add("-"); mniFile.MenuItems.Add(mniExit); mniEdit.MenuItems.Add(mniUndo); mniEdit.MenuItems.Add("-"); mniEdit.MenuItems.Add(mniCut); mniEdit.MenuItems.Add(mniCopy); mniEdit.MenuItems.Add(mniPaste); mniEdit.MenuItems.Add("-"); mniEdit.MenuItems.Add(mniFind); mniFormat.MenuItems.Add(mniFont); this.Text = "NetWord v.1"; this.Name = "NetWord"; this.Size = new Size(800,600); this.Menu = mnuMain; this.Closing += new CancelEventHandler(this.DocumentClosing); this.Controls.Add(rtbDocument); }

Das gesamte Listing besteht lediglich aus dem Konstruktor und der Initialisierung unserer Anwendung. Inzwischen wissen Sie, dass der Großteil des von uns geschriebenen Codes (zumindest in der ersten Woche) aus der Initialisierung der Benutzeroberfläche besteht. Diesem Code kann man sehr leicht folgen. Zeile 9 erzeugt das RichTextBoxSteuerelement, das für die Hauptbenutzeroberfläche benötigt wird. Die Zeilen 11 bis 28 richten die diversen Menüs ein und in Zeile 30 bis 39 werden Einstellungen deklariert, die durchweg verwendet werden (die aktuelle Schriftart, Farbe, Druckeinstellung usw.). Die Zeilen 42 bis 90 richten einige allgemeine Eigenschaften ein und weisen den Menüelementen Delegaten zu.

265

Woche 1 – Rückblick

Es gibt hierzu noch einiges anzumerken. Erstens setzt Zeile 44 HideSelection auf false, was dazu führt, dass markierter Text im RichTextBox-Steuerelement auch dann noch als markiert zu sehen ist, wenn dieses Steuerelement nicht den Fokus hat (das wird bei der Erstellung der Suchfunktion wichtig). Zweitens weist Zeile 88 dem Closing-Ereignis des Formulars einen Delegaten zu. Wir wollen dieses Ereignis überwachen, um herauszufinden, ob sich der Inhalt vor dem Schließen des Fensters geändert hat; falls dem so ist, wollen wir dem Benutzer Gelegenheit zum Speichern seines Dokumentes geben. Wir wollen nun einen Blick auf die Ereignishandler werfen, die in Listing R1.3 zu sehen sind. Listing R1.3: Die Ereignishandler für NetWord 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:

266

private void FileClicked(Object Sender, EventArgs e) { MenuItem mniTemp = (MenuItem)Sender; switch (mniTemp.Text) { case "Öffnen...": if (dlgOpen.ShowDialog() == DialogResult.OK) { //Datei öffnen } break; case "Speichern": if (dlgSave.ShowDialog() == DialogResult.OK) { //Datei speichern } break; case "Seite einrichten...": dlgPageSetup.PageSettings = objPageSettings; dlgPageSetup.ShowDialog(); break; case "Druckvorschau": dlgPrintPreview.Document = new PrintDocument(); dlgPrintPreview.ShowDialog(); break; case "Drucken...": dlgPrint.PrinterSettings = new PrinterSettings(); if (dlgPrint.ShowDialog() == DialogResult.OK) { //drucken

Woche 1 – Rückblick

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: 66: 67: 68: 69: 70: 71: 72: 73: 74: 75: 76: 77:

} break; case "Beenden": this.Close(); break; } } private void EditClicked(Object Sender, EventArgs e) { MenuItem mniTemp = (MenuItem)Sender; switch (mniTemp.Text) { case "Rückgängig": rtbDocument.Undo(); break; case "Ausschneiden": if (rtbDocument.SelectedRtf != "") { rtbDocument.Cut(); } break; case "Kopieren": if (rtbDocument.SelectedRtf != "") { rtbDocument.Copy(); } break; case "Einfügen": rtbDocument.Paste(); break; case "Suchen...": FindDialog dlgFind = new FindDialog(rtbDocument); dlgFind.Show(); break; } } private void FormatClicked(Object Sender, EventArgs e) { MenuItem mniTemp = (MenuItem)Sender; switch (mniTemp.Text) { case "Schriftart...": dlgFont.ShowColor = true; if (dlgFont.ShowDialog() == DialogResult.OK) { fntCurrent = dlgFont.Font; fntColor = dlgFont.Color; rtbDocument.SelectionFont = fntCurrent; rtbDocument.SelectionColor = fntColor;

267

Woche 1 – Rückblick

78: } 79: break; 80: } 81: } 82: 83: private void DocumentClosing(Object Sender, CancelEventArgs e) { 84: if (rtbDocument.Modified) { 85: DialogResult dr = MessageBox.Show("Möchten Sie die Änderungen speichern?", this.Name, MessageBoxButtons.YesNoCancel); 86: 87: if (dr == DialogResult.Yes) { 88: MessageBox.Show("Schade!", this.Name); 89: } else if (dr == DialogResult.Cancel) { 90: e.Cancel = true; 91: } 92: } 93: } 94: 95: public static void Main() { 96: Application.Run(new NetWord()); 97: } 98: } 99: }

Nach unseren Arbeiten an Tag 4 dürfte Ihnen ein Großteil dieses Codes bekannt vorkommen. Sie finden in Zeile 1 die Methode, die alle MenuItems im DATEI-Menü behandelt, den Ereignishandler für das BEARBEITEN-Menü in Zeile 40, denjenigen für das FORMAT-Menü in Zeile 67 und den für das Closing-Ereignis schließlich in Zeile 83. Der Löwenanteil dieses Codes wird verwendet, um genau auszuwerten, welches Menüelement angeklickt wurde. Die Zeilen 4 bis 36 dürften vertraut erscheinen: Sie sind fast identisch mit der Dialogfeld-Lektion an Tag 7. Der einzige Unterschied: Es wurde ein BEENDENMenü hinzugefügt, das die Close-Methode aufruft. Je nachdem, welches Menü angeklickt wurde, erzeugen Sie einen FileOpenDialog, einen FileSaveDialog, einen PageSetupDialog, einen PrintPreviewDialog oder einen PrintDialog. Mit Hilfe der ShowDialog-Methode zeigen Sie das jeweilige Dialogfeld an. Bei den ÖFFNEN-, SPEICHERN- und DRUCKEN-Menüelementen bewerten Sie das Ergebnis des Dialogfelds mit Hilfe der DialogResult-Aufzählung und führen eine dementsprechende Aktion aus. Die Zeilen 43 bis 63 sind sehr ähnlich und führen die Arbeitsschritte RÜCKGÄNGIG, AUSSCHNEIDEN, KOPIEREN und EINFÜGEN aus, indem sie die verschiedenen Methoden des RichTextBox-Steuerelements aufrufen. Bei den Cutund Copy-Methoden müssen Sie zunächst prüfen, ob Text markiert ist, indem

268

Woche 1 – Rückblick

Sie die Eigenschaft SelectedRtf bewerten. Das SUCHEN-Menüelement in Zeile 60 ist etwas Besonderes; es erzeugt ein benutzerdefiniertes Dialogfeld, das Sie im nächsten Abschnitt erstellen werden, und zeigt es an. Die Zeilen 70 bis 78 verhalten sich wie die anderen Fälle. Man zeigt dem Benutzer das Dialogfeld FontDialog an, um ihm die Auswahl einer Schriftart und einer Schriftfarbe zu gestatten. Diese Werte werden in den globalen Einstellungen gespeichert, die Sie in den Zeilen 30 und 31 erzeugt haben, und dann der Schriftart im RichTextBox-Steuerelement zugewiesen. Schließlich findet sich in Zeile 83 noch die DocumentClosing-Methode. Sie erinnern sich, dass das Closing-Ereignis direkt vor dem Schließen des Dokuments stattfindet, was bedeutet, dass man es zur Bewertung aller in letzter Minute geänderten Bedingungen einsetzen kann. Die Zeile 84 prüft die Modified-Eigenschaft der RichTextBox, die Ihnen verrät, ob das Dokument seit dem letzten Speichervorgang (oder in diesem Fall, seit dem letzten Öffnen) geändert wurde. Zeile 85 zeigt eine MessageBox an, die den Benutzer fragt, ob er ohne Speichern der letzten Änderungen fortfahren möchte. Je nach der Antwort tun Sie eines von drei Dingen: 왘

Sie speichern das Dokument nicht.

왘

Sie halten die Anwendung vom Beenden ab (indem Sie die Eigenschaft CancelEventArgs.Cancel auf true setzen).

왘

Sie speichern das Dokument (momentan nicht wirklich, aber wenigstens wissen Sie, wohin der entsprechende Code gehört).

Das ist bereits alles – wenn auch nicht für die Anwendung. Wenn Sie versuchen, diesen Code auszuführen, erhalten Sie eine Fehlermeldung, denn Sie haben bis jetzt noch nicht das Objekt FindDialog erstellt, das von Zeile 61 gefordert wird. Diese Klasse ist in Listing R1.4 zu sehen. Listing R1.4: Die FindDialog-Klasse 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11:

using System; using System.Windows.Forms; using System.Drawing; namespace TYWinforms.P1 { public class FindDialog : Form { private Label lblFind = new Label(); private Label lblReplace = new Label(); private TextBox tbFind = new TextBox(); private TextBox tbReplace = new TextBox(); private Button btFind = new Button();

269

Woche 1 – Rückblick

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: 46: 47: 48: 49: 50: 51: 52: 53: 54: 55: 56: 57:

270

private Button btReplace = new Button(); private Button btReplaceAll = new Button(); private Button btCancel = new Button(); private RichTextBox rtbDoc; public FindDialog(RichTextBox rtbParentDoc): base() { rtbDoc = rtbParentDoc; lblFind.Text = "Suche: "; lblFind.Location = new Point(10,10); lblFind.Width = 50; lblReplace.Text = "Ersetze: "; lblReplace.Location = new Point(10,35); lblReplace.Width = 50; tbFind.Width = 100; tbFind.Location = new Point(60,10); tbReplace.Width = 100; tbReplace.Location = new Point(60,35); btFind.Size = new Size(75,25); btFind.Text = "Suchen"; btFind.Location = new Point(170,10); btFind.Click += new EventHandler(this.ButtonClicked); btReplace.Size = new Size(75,25); btReplace.Text = "Ersetzen"; btReplace.Location = new Point(170,35); btReplace.Click += new EventHandler(this.ButtonClicked); btReplaceAll.Size = new Size(75,25); btReplaceAll.Text = "Alle ersetzen"; btReplaceAll.Location = new Point(170,60); btReplaceAll.Click += new EventHandler(this.ButtonClicked); btCancel.Size = new Size(75,25); btCancel.Text = "Abbrechen"; btCancel.Location = new Point(170,85); btCancel.Click += new EventHandler(this.ButtonClicked); this.Text = "Suchen"; this.Size = new Size(255,140); this.MaximizeBox = false;

Woche 1 – Rückblick

58: 59: 60: 61: 62: 63: 64: 65: 66: 67: 68: 69: 70: 71: 72: 73: 74: 75: 76: 77: 78: 79: 80: 81: 82: 83: 84: 85: 86: 87: 88: 89: 90: 91: 92: 93: 94: 95: 96: 97: 98: 99: 100: 101:

this.MinimizeBox = false; this.FormBorderStyle = FormBorderStyle.FixedDialog; this.TopMost = true; this.Controls.Add(lblFind); this.Controls.Add(lblReplace); this.Controls.Add(tbFind); this.Controls.Add(tbReplace); this.Controls.Add(btFind); this.Controls.Add(btReplace); this.Controls.Add(btReplaceAll); this.Controls.Add(btCancel); } private void ButtonClicked(Object Sender, EventArgs e) { Button btTemp = (Button)Sender; int intLocation; int intCount = 0; switch (btTemp.Text) { case "Suchen": intLocation = rtbDoc.Find(tbFind.Text, rtbDoc.SelectionStart + rtbDoc.SelectionLength, RichTextBoxFinds.None); if (intLocation != -1) { rtbDoc.SelectionStart = intLocation; rtbDoc.SelectionLength = tbFind.Text.Length; rtbDoc.Focus(); } break; case "Ersetzen": intLocation = rtbDoc.Find(tbFind.Text, rtbDoc.SelectionStart + rtbDoc.SelectionLength, RichTextBoxFinds.None); if (intLocation != -1) { rtbDoc.SelectionStart = intLocation; rtbDoc.SelectionLength = tbFind.Text.Length; rtbDoc.SelectedText = tbReplace.Text; rtbDoc.SelectionStart = intLocation; rtbDoc.SelectionLength = tbReplace.Text.Length; } break; case "Alle ersetzen": intLocation = rtbDoc.Find(tbFind.Text); while (intLocation != -1) { rtbDoc.SelectionStart = intLocation; rtbDoc.SelectionLength = tbFind.Text.Length; rtbDoc.SelectedText = tbReplace.Text;

271

Woche 1 – Rückblick

102: 103:

intCount += 1; intLocation = rtbDoc.Find(tbFind.Text, rtbDoc.SelectionStart + rtbDoc.SelectionLength, RichTextBoxFinds.None); } MessageBox.Show(intCount.ToString() + "Vorkommen ersetzt","Suchen"); break; case "Abbrechen": this.Close(); break; } }

104: 105: 106: 107: 108: 109: 110: 111: 112: 113:

} }

Dieses Listing definiert ein benutzerdefiniertes Dialogfeld, das über SUCHENund ERSETZEN-Textfelder sowie Schaltflächen für SUCHEN, ERSETZEN und ALLE ERSETZEN verfügt. Der Code dafür mag ein wenig komplizierter aussehen als in den bisherigen Arbeitsschritten, doch ist er nicht wirklich schwierig. Die Zeilen 1 bis 70 enthalten den Konstruktor- und Initialisierungscode. Hier gibt es nichts Neues, lediglich ein paar Dinge, die zu beachten wären. Erstens erfolgt die Deklaration des RichTextBox-Steuerelements in Zeile 16; diesem Steuerelement wird dann dasjenige Steuerelement zugewiesen, das an den Konstruktor in Zeile 18 übergeben wurde. Wenn wir in Listing P 1.3 zur Zeile 61 zurückgehen, sehen wir, dass wir an den Konstruktor der FindDialog-Klasse das Haupt-RichTextBox-Steuerelement übergeben. Dies wird so gehandhabt, damit Sie beim Suchen von Ihrem SUCHEN-Dialogfeld aus eine einfache Referenz auf dieses Steuerelement haben. Wie man es einsetzt, sehen Sie gleich. Als Nächstes finden Sie im Konstruktor in Zeile 18 einen Aufruf der baseMethode. Das bedeutet, dass der Konstruktor in Zeile 18 vom Konstruktor des RichTextBox-Steuerelements erben sollte und dass alle notwendigen Initialisierungsprozeduren ausgeführt werden. Da .NET dies für Sie tut, ist es im Grunde nicht nötig, dies hier einzufügen, aber es macht es für Sie deutlicher. ButtonClicked in Zeile 72 verwendet ein switch-Statement, um die angeklickte Schaltfläche zu bewerten. In Zeile 79 stoßen Sie auf die Find-Methode, die, wie Sie wissen, bestimmten Text in der RichTextBox sucht. Doch sie weist ein paar zusätzliche Parameter auf: tbFind.Text ist der zu suchende Text, rtbDoc.SelectionStart bezeichnet die Startposition für den Suchvorgang im Text (also die aktuelle Cursorposition in der RichTextBox) und RichTextBoxFinds.None gibt an, wie die Suche durchgeführt werden soll. Die Aufzählung RichTextBoxFinds enthält die Werte MatchCase (Groß-/Kleinschreibung beachten), NoHighlight

272

Woche 1 – Rückblick

(keine Markierung), None, Reverse (umgekehrt) und WholeWord (nach ganzem Wort suchen). Diese Werte lassen sich wie Anchor-Werte kombinieren: RichTextBoxFinds.MatchCase | RichTextBoxFinds.Reverse

Mit Hilfe von RichTextBoxFinds kann der Benutzer spezialisierte Suchvorgänge starten, aber im Augenblick brauchen wir uns nicht darum zu kümmern. Falls die Find-Methode den gesuchten Text nicht findet, gibt sie den Wert –1 zurück. Wir prüfen dies in Zeile 80 und falls Text gefunden wurde, markieren wir ihn mit Hilfe der Eigenschaften SelectionStart und SelectionLength. Am Schluss geben Sie der RichTextBox den Fokus zurück. (Doch weil wir in Zeile 60 für die FindDialog-Klasse TopMost auf true gesetzt haben, wird das Dialogfeld nicht verschwinden, aber die Benutzereingaben gelangen trotzdem zum RichTextBox-Steuerelement.) Bei den case-Zweigen für Suchen und Ersetzen startet die Suche hinter der aktuellen Cursorposition (SelectionStart + SelectionLength). Wird etwas Text markiert, beginnt sie direkt hinter der Markierung. Sie können dieses Verhalten durch Umstellen des zweiten Parameters der Find-Methode auf die Zahl 1 ändern oder indem Sie einfach die zweiten zwei Parameter weglassen, wie es der case-Zweig »Alle ersetzen« in Zeile 97 tut.

Abbildung R1.2: NetWord in Aktion

Die nächsten zwei Fälle, ERSETZEN und ALLE ERSETZEN, funktionieren in ähnlicher Weise. ERSETZEN verwendet die Find-Methode, markiert den angegebenen Text und ersetzt ihn mit Hilfe der SelectedText-Eigenschaft. Daraufhin markiert es das gerade ersetzte Wort. ALLE ERSETZEN tut das Gleiche, nur in einer while-Schleife, so dass man

273

Woche 1 – Rückblick

alle Vorkommen statt nur eines ersetzen kann. Durch jede Iteration der Schleife suchen Sie den angegebenen Text, markieren und ersetzen ihn, woraufhin es zum nächsten Auftreten des gesuchten Textes geht – und so weiter, bis es keine Vorkommen davon mehr gibt (also bis Find –1 zurückgibt). Anschließend wird eine MessageBox angezeigt, um dem Benutzer mitzuteilen, wie viele Textvorkommen ersetzt wurden. Ihre Anwendung ist endlich vollständig. Erledigen Sie Kompilierung und Ausführung und erfreuen Sie sich an den Früchten Ihrer Arbeit. Abbildung R1.2 zeigt das Ergebnis dieser Anwendung.

Einige nützliche Dinge mit Pfiff hinzufügen Ihre Anwendung mag ja vollständig sein, doch sie ist nicht sonderlich benutzerfreundlich. Wir wollen mit ein paar Extrafunktionen NetWord etwas mehr Leben einhauchen. Zunächst fügen wir Ihren Menüelementen Tastenkombinationen (Shortcuts) hinzu. Fügen Sie den folgenden Code in den NetWord-Konstruktor ein: mniOpen.Shortcut = Shortcut.CtrlO; mniSave.Shortcut = Shortcut.CtrlS; mniPrint.Shortcut = Shortcut.CtrlP; mniUndo.Shortcut = Shortcut.CtrlZ; mniCut.Shortcut = Shortcut.CtrlX; mniCopy.Shortcut = Shortcut.CtrlC; mniPaste.Shortcut = Shortcut.CtrlV; mniFind.Shortcut = Shortcut.CtrlF; mniOpen.ShowShortcut = true; mniSave.ShowShortcut = true; mniPrint.ShowShortcut = true; mniUndo.ShowShortcut = true; mniCut.ShowShortcut = true; mniCopy.ShowShortcut = true; mniPaste.ShowShortcut = true; mniFind.ShowShortcut = true;

Die von uns zugewiesenen Tastenkombinationen entsprechen den Standardabkürzungstasten von Windows für die betreffenden Menüoptionen. Als nächsten Schritt erstellen wir ein Kontextmenü, das auf den bereits erzeugten Menüelementen (MenuItem-Steuerelementen) basiert. Je nachdem, was der Benutzer ausgewählt hat, werden unterschiedliche Optionen erscheinen. Das Erstellen des Kontextmenüs ist einfach, doch die Bestimmung dessen, was darin erscheinen soll, ist ein wenig kniffliger. Werfen Sie einen Blick auf folgenden Code:

274

Woche 1 – Rückblick

'in der Klasse private ContextMenu cmnuDocument = new ContextMenu(); ... 'im Konstruktor cmnuDocument.MenuItems.Add(mniCut.CloneMenu()); cmnuDocument.MenuItems.Add(mniCopy.CloneMenu()); cmnuDocument.MenuItems.Add(mniPaste.CloneMenu()); cmnuDocument.MenuItems.Add("-"); cmnuDocument.MenuItems.Add(mniFont.CloneMenu()); cmnuDocument.Popup += new EventHandler(this.HandleContext); rtbDocument.ContextMenu = cmnuDocument; ... 'eine neue Methode private void HandleContext(Object Sender,EventArgs e) { if (rtbDocument.SelectionLength == 0){ cmnuDocument.MenuItems [0 ].Enabled = false; cmnuDocument.MenuItems [1 ].Enabled = false; } else { cmnuDocument.MenuItems [0 ].Enabled = true; cmnuDocument.MenuItems [1 ].Enabled = true; } }

Die erste Zeile erstellt das ContextMenu-Objekt und die nächsten Zeilen weisen ihm diverse Menüelemente zu (mit dem Kontextmenü soll der Benutzer nur ausschneiden, kopieren, einfügen und die Schriftart ändern können). Beachten Sie, dass Sie die CloneMenu-Methode verwenden, um Kopien der fraglichen Menüelemente anzufertigen. Tun Sie dies nicht, dann richten Sie in Ihren Standard-Menüelementen ein Chaos an. Sie müssen das Kontextmenü dem Kontext der Anwendung anpassen (also dem, was der Benutzer gerade tut). Dies erlaubt Ihnen das Popup-Ereignis; es wird direkt vor der Anzeige des Menüs ausgelöst. Wir wollen uns die HandleContext-Methode ansehen, die das Popup-Ereignis handhabt. Es gilt zwei einfache Fälle zu bewerten. Ist in der RichTextBox kein Text markiert, dann sollte man die Menüs AUSSCHNEIDEN und KOPIEREN abschalten (sie sind dann nämlich nutzlos). Dies erfolgt einfach durch das Setzen der Enabled-Eigenschaft auf false – die Menüelemente sind dann zwar noch zu sehen, doch der Benutzer kann sie nicht auswählen. Ist jedoch Text ausgewählt, dann sollte man dafür sorgen, dass diese zwei Menüelemente aktiviert sind; sie sind das zwar per Voreinstellung, doch wenn beim Öffnen des Kontextmenüs kein Text markiert ist, werden sie ausgeschaltet. Mit Hilfe der else-Bedingung aktivieren Sie sie einfach wieder. Lassen Sie uns zum Schluss eine Statusleiste hinzufügen, die dem Benutzer Informationen liefert, etwa die aktuelle Zeilennummer oder die aktuelle Spalte in der Zeile, wo sich der Cursor befindet. Wir brauchen also eine Statuszeile (StatusBar) und einen Statuszeilenbereich (StatusBarPanel).

275

Woche 1 – Rückblick

private StatusBar sbarMain = new StatusBar(); private StatusBarPanel spnlLine = new StatusBarPanel();

Als Nächstes initialisieren Sie diese Steuerelemente im Konstruktor: sbarMain.ShowPanels = true; sbarMain.Panels.Add(spnlLine); spnlLine.AutoSize = StatusBarPanelAutoSize.Spring; spnlLine.Alignment = HorizontalAlignment.Right;

Nun ist Ihre Statusleiste eingerichtet, doch leider macht sie noch nichts. Da Sie die aktuelle Zeile und Spalte überwachen wollen, müssen Sie die Statusleiste bei jeder Änderung in der RichTextBox aktualisieren. Hierfür eignet sich das SelectionChanged-Ereignis hervorragend; es wird bei jeder Veränderung der Cursorposition ausgelöst (durch Tippen, Mausklicks, Drücken der (¢)-Taste usw.). Fügen Sie diesem Ereignis der RichTextBox einen Delegaten hinzu: rtbDocument.SelectionChanged += new EventHandler(this.UpdateStatus);

Der erste Teil der UpdateStatus-Methode kümmert sich um das Auffinden der Zeilennummer. Das ist ein recht einfacher Vorgang und lässt sich mit dem folgenden Code bewerkstelligen: private void UpdateStatus(Object Sender,EventArgs e) { String text = rtbDocument.Text; int intLine = rtbDocument.GetLineFromCharIndex(rtbDocument.SelectionStart) + 1;

Zuerst holen Sie den in der RichTextBox enthaltenen Text, um ihn leichter bearbeiten zu können. Das RichTextBox-Steuerelement verfügt über eine elegante Methode namens GetLineFromCharIndex, die Ihnen verrät, in welcher Zeile sich der Cursor gerade befindet. Dies liefert Ihnen die richtige Zeilennummer selbst dann, wenn es keine Zeilenumbrüche gibt. Wenn etwa die erste Zeile im Steuerelement über zwei Zeilen verläuft, werden diese beiden Zeilen 1 und 2 zurückgeben. Die Lines-Eigenschaft der RichTextBox lässt sich andererseits nicht zum Zeilenzählen verwenden, weil sie keine Zeilenumbrüche berücksichtigt (sie zählt zwei umbrochene Zeilen als eine Zeile). Die Zeichenposition bzw. Spaltennummer in der aktuellen Zeile zu ermitteln, ist ein wenig schwieriger. Um festzustellen, ob man sich am Zeilenanfang befindet, kann man die GetPositionFromCharIndex-Methode der RichTextBox verwenden, welche einen Point mit den Cursorkoordinaten zurückgeben wird. Ist die x-Koordinate gleich 1, dann befinden Sie sich am Rand ganz links außen oder, mit anderen Worten, am Zeilenanfang. Das folgende Codestück führt diese Prozedur aus: int intLine = rtbDocument.SelectionStart; while (rtbDocument.GetPositionFromCharIndex(i).X > 1) --i; String StrChar = (rtbDocument.SelectionStart – i + 1).ToString();

276

Woche 1 – Rückblick

Zuerst setzen wir die Variable i auf die aktuelle Cursorposition. In einer while-Schleife verringern wir i, solange die x-Koordinate für den Point bei Zeichen i größer als 1 ist. Schließlich subtrahieren wir i von unserer Ausgangsposition, um festzustellen, wie weit die Ausgangsposition vom Zeilenanfang entfernt ist. Weisen Sie zum Schluss die sich ergebende Zeichenfolge dem Statusleistenbereich zwecks Ausgabe zu: spnlLine.Text = "Zeile " + intLine.ToString() + " Spalte " + strChar;

Abbildung R1.3 zeigt das Ergebnis. Die Projekte in Woche 2 und 3 werden diese Anwendung erweitern. Am Ende der Woche 2 werden Sie Internetfähigkeiten hinzufügen und NetWord in eine MDI-Anwendung umwandeln. Danach lernen Sie, wie Sie Ihre Anwendung installieren und sie mit anderen Windows-Anwendungen zusammenarbeiten lassen.

Abbildung R1.3: In der Statusleiste werden nun die aktuelle Zeilennummer und Cursorposition in der Zeile korrekt angezeigt.

277

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

T ag 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 2: Funktionen hinzufügen Willkommen zu Ihrer zweiten Woche in der Gesellschaft von Windows Forms! In der vorigen Woche wurden Sie in die verschiedenen Konzepte eingeführt, die bei Windows Forms erforderlich sind. Sie erfuhren, worum es sich bei Windows Forms handelt, wie man sie erstellt und wie man Windows Forms-Steuerelemente verwendet. Nun, da Sie über die Grundlagen verfügen, ist es an der Zeit, zu fortgeschritteneren Themen überzugehen. In dieser Woche lernen Sie, wie Sie Ihren Anwendungen leistungsfähige Funktionen hinzufügen, darunter Datenbankfähigkeiten und viele andere moderne Merkmale. In der dritten Woche werden Sie dann das komplexe Innenleben von Windows Forms kennen lernen und erfahren, wie Sie es nutzen können, um richtig ausgefuchste Anwendungen zu schreiben. Der Tag 8 mit dem Motto »Datenbindung in Windows Forms« lehrt Sie, wie Windows Forms entworfen sind, um mit allen Datentypen umgehen zu können, ohne auf Datenbanken zugreifen zu müssen. Diese Daten können Sie auf jede erdenkliche Weise manipulieren. An Tag 9 mit dem Titel »ADO.NET« lernen Sie, wie Sie anhand des Wissens aus Tag 8 Datenbanken in Ihre Anwendungen integrieren. Tag 10 (»MDI-Anwendungen«) konzentriert sich auf Anwendungen mit der Mehrfachdokumentschnittstelle (Multiple Document Interface), kurz MDI. Mit diesem Applikationstyp können Sie mehrere Fenster zugleich geöffnet halten. »Arbeiten mit der Windows-Ein-/Ausgabe« ist das Motto des elften Tages. Danach beherrschen Sie die Interaktion mit Windows-Dateien – also Speichern, Öffnen, Überschreiben usw. – sowie das Drucken. Wie Sie das Internet in Ihren Anwendungen nutzen, lernen Sie an Tag 12, »Formulare Internet-fähig machen«. Sie erstellen einen einfachen Webbrowser und surfen nach Herzenslust. An Tag 13 unter dem Motto »Grafische Anwendungen mit GDI+« erfahren Sie etwas über GDI+, das Paradigma für die Handhabung von Windows-Grafikaspekten. Sie erlernen nicht nur das Erstellen von »zeichnenden« Anwendungen, sondern auch, auf welche Weise sich GDI+ auf Ihre normalen Anwendungen auswirkt. Tag 14 trägt den Titel »ActiveX«, so dass Sie nun lernen, wie Sie andere Anwendungen und Komponenten mit Ihren eigenen Windows Forms-Anwendungen integrieren! Lassen Sie uns in die zweite Woche starten!

Datenbindung in Windows Forms

8

Datenbindung in Windows Forms

Die Datenbindung ist ein interessanter Begriff in .NET; mit ihrer Hilfe können Sie Daten mit den Steuerelementen in Windows Forms verknüpfen. Diese Fähigkeit erlaubt es Ihnen wiederum, diese Daten leichter anzuzeigen und zu bearbeiten. Nach der heutigen Lektion werden Sie verstehen, dass Datenbindung ein leistungsfähiger Partner sein kann. Heute lernen Sie, 쐽

was man unter Datenbindung versteht,

쐽

wie Sie Daten mit Ihren Steuerelementen verknüpfen,

쐽

was ein DataGrid ist,

쐽

wie Sie feststellen, welche Daten ein Benutzer in einem Steuerelement ausgewählt hat.

8.1

Einführung in die Datenbindung

Das Konzept der Datenbindung zu verstehen, ist manchmal nicht einfach, daher wollen wir ein paar Augenblicke dafür aufbringen. Lassen Sie uns zunächst den Begriff Daten erörtern. In Bezug auf die Datenbindung sind Daten beliebige Arten von Informationen, mit denen eine Anwendung arbeitet (oftmals als Datenmodell bezeichnet). Es könnte sich also um die in Ihrer Anwendung verwendeten Farben, um die Kundenliste in einer Datenbank oder um die Text-Eigenschaft Ihres Formulars handeln. Alle diese Beispiele stehen für Informationen, die Sie in Ihren Anwendungen verarbeiten. In den meisten Fällen will man solche Daten auch einem Benutzer präsentieren. Wenn Sie etwa einen CD-Katalog erstellen, muss der Benutzer seine eigenen Eingaben sehen können. Sie können eine solche Möglichkeit hinzufügen, indem Sie den Text-Eigenschaften diverser Steuerelemente Werte zuweisen, Kombinationsfelder und Listenfelder hinzufügen usw. Die Definition von Daten ist recht unscharf; doch eine exaktere Erklärung ist schwierig, da Daten in so vielfältiger Form vorkommen. Das ist einer der Gründe, warum Datenbindung so wichtig und leistungsfähig ist. Denn einfach ausgedrückt, erlaubt Ihnen Datenbindung, Informationen in einem Windows Forms-Steuerelement zusammenzuführen. Diese Bindung stellt eine Lese-/Schreibbeziehung zwischen den Daten und dem Steuerelement her; das Steuerelement zeigt die Daten in einer benutzerfreundlichen Weise an, und Änderungen im Steuerelement spiegeln sich in den Daten wider. Durch die Datenbindung eines Steuerelements machen Sie es praktisch zum Vehikel für die Anzeige und Bearbeitung von Daten.

282

Einführung in die Datenbindung

Inwiefern unterscheidet sich also Datenbindung von der Wertezuweisung in einem Steuerelement? Für die einfache Datenbindung besteht kaum ein Unterschied. Doch wenn Sie einmal mit komplexer Datenbindung anfangen, erspart sie Ihnen viel Mühe, wenn Sie eine Benutzeroberfläche erstellen, wobei zugleich Ihr Code schlanker und einfacher wird. Stellen Sie sich ein typisches Szenario vor, etwa den erwähnten CD-Katalog. Gibt der Benutzer Informationen zu einem neuen Album ein, lassen sich diese direkt in einem TreeView-Steuerelement anzeigen (siehe Tag 6). Dieser Prozess ist zwar einfach und schnell, doch leider verlieren Sie auf diese Weise Funktionalität. Erstens verfügen Sie über keine besonders gute Aufzeichnung der Daten, außer im TreeView-Steuerelement, welches nicht gerade der optimale Speicherort ist. Und zweitens bleiben die Daten nach der Anzeige auch weiterhin im Steuerelement. Außer durch lange und komplizierte Prozeduren lassen sie sich dort nicht mehr bearbeiten. Statt die Informationen direkt anzuzeigen, können Sie sie auch in eine Datenbank eingeben, sobald der Benutzer sie eingetippt hat. Sie verfügen dann über eine Datenaufzeichnung, die Sie nach Wunsch bearbeiten und in so vielen Steuerelementen anzeigen können, wie Sie wollen, statt in einem einzigen TreeView-Steuerelement. Innerhalb dieses Rahmens verfügen Sie nun über zwei verschiedene Objekte: die Daten und die Steuerelemente, um diese Daten anzuzeigen. Die Daten können Sie an das Steuerelement binden und das Steuerelement realisiert dann alle Aspekte der Anzeige für Sie. Die Interaktion mit dem Steuerelement berührt die Daten direkt. Dieses zweite Modell bietet mehrere Vorteile. Sie erzielen eine Trennung der Anwendungsdaten von der Benutzeroberfläche (die jeweils als die Daten- und die Präsentationsbzw. Benutzeroberflächenschicht bezeichnet werden). Haben Sie sich bereits einmal über Anwendungsentwicklungsmodelle informiert, kennen Sie schon das Dreischichtenmodell: eine Schicht für die Präsentation (in der Benutzeroberfläche), eine für die Daten und eine (in der Mitte) für die Behandlung der Logik (Verarbeitungsregeln) und der Beziehungen zwischen den Daten und der Benutzeroberfläche (User Interface, UI). Durch diese Aufteilung wird Ihre Anwendung weitaus eleganter und anspruchsvoller. Dieses Modell lässt sich einfacher erstellen und verstehen. Sollte außerdem eine der Schichten veraltet oder überflüssig werden, können Sie sie leicht austauschen, ohne Ihre gesamte Anwendung komplett neu oder umschreiben zu müssen. Die Aufteilung in Benutzeroberfläche und Datenebene sollte stets zu Ihren Zielen bei der Anwendungsentwicklung gehören. Datenbindung ist ein ausgezeichnetes Hilfsmittel bei diesem Unterfangen.

Daten aus jeder beliebigen Quelle Daten können in vielfältiger Form auftreten und in den verschiedensten Transportformen vorkommen. Ob Ihre Daten nun aus einer Datenbank stammen oder willkürlich von einem Benutzer eingegeben werden, ist gleichgültig, denn beide können an Windows

283

Datenbindung in Windows Forms

Forms-Steuerelemente gebunden werden. Diese immense Flexibilität erspart Ihnen als Entwickler eine Menge Arbeit bei der Umwandlung von Datentypen und -formen. Sie können einfach die Daten anbinden und dann gehen. XML-Daten werden beispielsweise fast wie solche aus einer relationalen Datenbank behandelt. Es ist gleichgültig, ob einige Daten aus einer Textdatei stammen und die übrigen aus Oracle oder SQL Server – beide Datentypen lassen sich für die Anzeige leicht an Steuerelemente binden. Änderungen im Steuerelement lassen sich in die XML-Datei oder die Datenbank zurückschreiben, so dass man nie Informationen verliert. Wenn Sie morgen etwas über ADO.NET lernen, werden Sie verstehen, wie diese Lese-/Schreibverbindung bei Datenbanken funktioniert.

8.2

Einfache Datenbindung

Wie bereits erwähnt brauchen Sie für die Datenbindung ein paar Daten und ein Steuerelement, um sie daran zu binden. Bei den Daten ist lediglich darauf zu achten, dass sie in einer Form vorliegen, die die IList-Schnittstelle implementiert. Schnittstellen sind ja lediglich wie eine Anforderungsliste: Sie teilen Ihnen mit, was eine Klasse alles benötigt, sagen Ihnen aber nicht, wie Sie das »Zeug« erstellen sollen. Die IList-Schnittstelle definiert die Anforderungen für jedes Objekt, das Daten enthalten kann. Über 40 Objekte verwenden IList, angefangen bei Arrays und StringCollection-Auflistungen bis hin zu etwas selteneren Objekten wie etwa EventDecriptorCollection – für gewöhnlich haben Sie keine Mühe, ein IList verwendendes Objekt zu finden. Um Daten zu binden, fügen Sie der DataBindings-Auflistung ein neues Binding-Objekt hinzu. Dieser Vorgang verläuft genau so wie das Hinzufügen neuer Steuerelemente zur Controls-Auflistung eines Formulars. Alle Windows Forms-Steuerelemente verfügen über diese Auflistung, können also alle Datenbindung nutzen. Ein Blick auf die Syntax: steuerelement.DataBindings.Add("eigenschaft", objekt, "feld")

Steuerelement ist dabei natürlich das Steuerelement, für das Sie eine Datenbindung einrichten wollen. Der erste Parameter namens eigenschaft gibt an, an welche Eigenschaft des Steuerelements Sie Daten binden wollen. Das kann je nachdem variieren, welche Daten Sie anbinden wollen. So könnten Sie etwa eine Namensliste an die Text-Eigenschaft einer Schaltfläche binden, aber eine Farbenliste an die BackColor-Eigenschaft. Datenbindung ist flexibel genug für beides. Der zweite Parameter gibt die datenquelle an. Das kann ein Array, eine Datenbank, eine StringCollection usw. sein. Der dritte Parameter gibt an, welcher Teil – oder welches »Feld« – der Datenquelle gebunden werden soll. Für ein Array ergibt diese Information wenig Sinn, denn es enthält nur willkürliche Daten. Bei einer Datenbank könnten Sie aber etwa das Feld Name einer Tabelle binden. In diesem dritten Parameter würden Sie also »Name« angeben.

284

Einfache Datenbindung

In den nächsten Abschnitten lernen Sie konkretere Beispiele für Datenbindung kennen und erfahren, wie man gebundene Daten bearbeitet.

Eine Schaltfläche mit Daten verbinden Anhand eines simplen Beispiels verwenden wir für die Datenbindung ein Array. Das Beispiel ist in Listing 8.1 zu sehen. Listing 8.1: Eine Schaltfläche mit Daten verbinden 1: 2: 3: 4: 5: 6: 7: 8:

using System; using System.Windows.Forms; using System.Drawing;

namespace TYWinforms.Day8 { public class Listing81 : Form { private Button btData = new Button(); private Color[] arrColors = {Color.Green, Color.Blue,Color.Red, Color.Orange}; 9: 10: public Listing81() { 11: btData.Location = new Point(100,100); 12: btData.DataBindings.Add("BackColor", arrColors, ""); 13: btData.DataBindings.Add("Text", arrColors, ""); 14: 15: this.Controls.Add(btData); 16: } 17: 18: public static void Main() { 19: Application.Run(new Listing81()); 20: } 21: } 22: }

In Zeile 7 erstellen Sie das Steuerelement Button für die Datenbindung. In der Zeile darunter wird ein Array von Color-Objekten erzeugt und instantiiert: Grün, Blau, Rot und Orange. Sie haben also Ihr Steuerelement und die Daten dafür, nun können Sie sie miteinander verbinden. In Zeile 12 verwenden Sie die oben beschriebene Syntax, um das Array an die Schaltfläche zu binden. Beachten Sie die drei Parameter: Der erste gibt die Steuerelementseigenschaft für die Bindung an; da wir ein Array von ColorObjekten verwenden, binden Sie die Farben an die BackColor-Eigenschaft. Der zweite Parameter gibt die Datenquelle an: das in Zeile 8 erstellte Array. Beim

285

Datenbindung in Windows Forms

dritten Parameter handelt es sich lediglich um eine leere Zeichenfolge, da keine bestimmte Eigenschaft des Arrays gebunden werden muss (und kann); daher soll das gesamte Array angebunden werden. Sie haben nun die Farben an die Schaltfläche gebunden. Moment mal!. Zeile 13 scheint eine andere Datenbindungsprozedur aufzuweisen. Hier binden Sie das gleiche Farbenarray an die Text-Eigenschaft des Button-Steuerelements. Die CLR ruft automatisch eine ToString-Methode für die Array-Objekte auf, um die Text-Eigenschaft den Farben richtig zuzuweisen. Zum Schluss wird die Schaltfläche in Zeile 15 dem Formular hinzugefügt. Abbildung 8.1 zeigt das Ergebnis dieser Anwendung.

Abbildung 8.1: Die Datenbindung einer Eigenschaft veranlasst das Steuerelement zur Anzeige der Daten.

Was ist also geschehen? Die BackColor-Eigenschaft des Button-Steuerelements ist nun also auf die erste Farbe im Array, grün, gesetzt worden. Diese Farbe wird gesetzt, ohne dass man der BackColor-Eigenschaft manuell eine Farbe zuweisen müsste. Die Datenbindung kümmert sich selbst darum. Zweitens wird das Wort Green – das Sie sehen, wenn Sie Color.Green.ToString() aufrufen – als Beschriftung des Button-Steuerelements angezeigt. Und wieder brauchen Sie diese Eigenschaft nicht selbst zuzuweisen; das wird für Sie erledigt. Sie können noch mehr erreichen. Da das an das Button-Steuerelement gebundene Array mehr als eine Farbe enthält, können Sie alle Farben durchlaufen lassen. Zu diesem Zweck müssen Sie aber erst ein neues Objekt kennen lernen: BindingContext. In einem Steuerelement zeigt es die Beziehung zwischen Daten und der sie bindenden Steuerelementeigenschaft an. Es gibt an, welches Element in der Datenauflistung auf welche Weise angezeigt werden soll. Um seinen Gebrauch anzusehen, fügen Sie folgenden Code in das Listing 8.1 ein: //im Konstruktor btData.Click += new EventHandler(this.Cycle); ...

286

Einfache Datenbindung

//neue Methode public void Cycle(Object Sender, EventArgs e) { btData.BindingContext [arrColors ].Position += 1; }

Die erste Zeile fügt einen Ereignishandler für das Click-Ereignis hinzu. Sie benutzen dieses Ereignis, um alle Array-Elemente zu durchlaufen. Der Ereignishandler Cycle verwendet den BindingContext des Button-Steuerelements, um den gebundenen Wert zu ändern. BindingContext enthält eine Liste aller an das Steuerelement gebundenen Objekte, so dass Sie das korrekte angeben müssen; dieses referenziert das Array von Farben. Die PositionEigenschaft gibt an, welches Element gerade angezeigt wird, so dass Sie es nur um eins zu inkrementieren brauchen, um zum nächsten zu gelangen. Nun kompilieren Sie die Anwendung und klicken auf die Schaltfläche. Die Eigenschaften BackColor und Text des Button-Steuerelements ändern sich mit jedem Klick – und ohne dass Sie sich mit einer dieser Eigenschaften hätten einzeln abgeben müssen. Dieses Beispiel mag Ihnen ein wenig an den Haaren herbeigezogen erscheinen, doch wenn Sie eine Datenbank mit Tausenden von Kunden haben, können Sie sich vorstellen, wie diese einfache Datenbindungsprozedur das Entwicklerleben leichter machen kann. Zudem spiegeln sich alle im Array vorgenommenen Änderungen auch in der Schaltfläche wider. Sie könnten in Ihrer Anwendung etwa Folgendes hinzufügen: arrColors[2] = Color.Magenta

Die Schaltfläche würde sich dem ohne weiteres anpassen. Einfache Datenbindung ist also nicht schwer.

Das Bearbeiten gebundener Daten Wir wollen uns ein etwas anspruchsvolleres Beispiel ansehen, bei dem ein Kombinationsfeld verwendet wird, mit dem der Benutzer Elemente bearbeiten kann. Mit Kombinationsfeldern und anderen Listenanzeige-Steuerelementen gestaltet sich der Umgang mit den Daten etwas einfacher. Statt Datenbindungen zu entwerfen, können Sie einfach die DataSource-Eigenschaft einstellen, um die Standardeigenschaft des Steuerelements an die Standardeigenschaft der betreffenden Daten zu binden. Im Beispiel des Listings 8.2 präsentiert die Anwendung zwei Steuerelemente: ein Kombinationsfeld (ComboBox) zur Datenanzeige und eine Schaltfläche für die Datenbearbeitung. Wählt der Benutzer eine Farbe aus, kann er die Auswahl wieder ändern, indem er einen neuen Farbenwert in das Textfeld der ComboBox eintippt.

287

Datenbindung in Windows Forms

Listing 8.2: Komplexe Datenbindung 1: 2: 3: 4: 5: 6: 7: 8: 9:

using System; using System.Windows.Forms; using System.Drawing;

namespace TYWinforms.Day8 { public class Listing82 : Form { private ComboBox cboData = new ComboBox(); private Button btChange = new Button(); private Color[] arrColors = {Color.Green, Color.Blue, Color.Red, Color.Orange}; 10: private int intLastIndex; 11: 12: public Listing82() { 13: cboData.Location = new Point(50,75); 14: cboData.DropDownStyle = ComboBoxStyle.Simple; 15: cboData.DataBindings.Add("BackColor", arrColors, ""); 16: cboData.DataSource = arrColors; 17: cboData.SelectedIndexChanged += new EventHandler(this.ChangeColor); 18: 19: btChange.Location = new Point(175,75); 20: btChange.Text = "Ändern"; 21: btChange.Click += new EventHandler(this.EditColor); 22: 23: this.Controls.Add(cboData); 24: this.Controls.Add(btChange); 25: } 26: 27: public void ChangeColor(Object Sender, EventArgs e) { 28: cboData.BindingContext[arrColors].Position = cboData.SelectedIndex; 29: intLastIndex = cboData.SelectedIndex; 30: } 31: 32: public void EditColor(Object Sender, EventArgs e) { 33: if (Color.FromName(cboData.Text).IsKnownColor) { 34: arrColors[intLastIndex] = Color.FromName (cboData.Text); 35: 36: cboData.SelectedText = Color.FromName (cboData.Text).ToString(); 37: cboData.SelectedIndex = intLastIndex; 38: } 39: } 40: 41: public static void Main() { 42: Application.Run(new Listing82()); 43: } 44: } 45: }

288

Einfache Datenbindung

Der Anfang dieses Listings ähnelt dem von Listing 8.1. In Zeile 9 erzeugen Sie ein Farben-Array und eine Schaltfläche in Zeile 8. Doch binden Sie diesmal keine Daten an die Schaltfläche, sondern vielmehr an die ComboBox (Zeile 7). In Zeile 16 setzen Sie die DataSource-Eigenschaft auf das Farben-Array. Das ist alles, was Sie für das Datenbinden tun müssen. Wenn Sie dieses Steuerelement ansehen, entsprechen die Listenelemente den Farben im Array (und der angezeigte Text entspricht der Textdarstellung dieser Farben). Um das Steuerelement etwas zu beleben, binden Sie auch die BackColor-Eigenschaft der ComboBox wie beim Button-Steuerelement in Listing 8.1. Sobald sich der ausgewählte Index ändert, soll sich auch die Farbe des Kombinationsfeldes ändern, daher fügen Sie dem Ereignis SelectedIndexChange einen Ereignishandler hinzu. In den Zeilen 19 bis 21 richten Sie das Button-Steuerelement ein. Der Benutzer wird diese Schaltfläche zur Bestätigung seiner Datenänderungen in der ComboBox verwenden. Klickt er auf die Schaltfläche, modifizieren Sie die Daten und aktualisieren nach Bedarf auch das Kombinationsfeld. Die ChangeColor-Methode – der Ereignishandler für das SelectedIndexChangedEreignis – ist sehr einfach. Mit Hilfe der BindingContext-Eigenschaft der ComboBox setzen Sie die Position auf den gerade ausgewählten Index. Als Nächstes speichern Sie den Index für den späteren Gebrauch; sobald der Benutzer etwas in das Kombinationsfeld eintippt, verliert das gerade ausgewählte seine Markierung. Das führt zu Problemen, wenn Sie versuchen Elemente zu ändern, so dass Sie eine exakte Aufzeichnung des zuletzt ausgewählten Elements bereithalten müssen. In der EditColor-Methode spielen sich die wirklich interessanten Dinge ab. Als Erstes ändern Sie das Array; Sie übernehmen die neue vom Benutzer in das Kombinationsfeld eingegebene Farbe, rufen das damit verknüpfte Color-Objekt mit Hilfe der ColorFromName-Methode ab und weisen es dem ausgewählten Index im Array zu. Klickt der Benutzer nun wieder auf dieses Element, wechselt die Hintergrundfarbe auf den neuen Wert. Beachten Sie jedoch, dass sich der im Kombinationsfeld angezeigte Text nicht ändert, selbst wenn dies der aktuelle Farbwert tut. Der Text ändert sich nicht, weil die ComboBox über keinen Mechanismus verfügt, mit dem sie Änderungen in dem in ihrer DataSourceEigenschaft festgelegten Objekt aufspüren könnte. Daher müssen Sie einfach noch einmal den Text mit Hilfe der ColorFromName-Methode aktualisieren. Zum Schluss setzen Sie das aktuell ausgewählte Element auf das letzte vom Benutzer ausgewählte Element, welches jetzt der neue Wert ist. Kompilieren Sie Listing 8.2 und probieren Sie es aus. Abbildung 8.2 zeigt das Ergebnis.

289

Datenbindung in Windows Forms

Abbildung 8.2: Die ComboBox verwendet gebundene Daten für ihre Hintergrundfarbe.

Formulare mit Daten verbinden Sie werden häufig eine Datenquelle mit einer ganzen Anwendung verknüpfen wollen. Angenommen, Sie haben eine Applikation erstellt, die nur für die Anzeige eines CD-Katalogs verwendet wird. Die Anwendung verfügt über mehrere Steuerelemente, die jeweils mit den Aspekten einer einzelnen CD verbunden sind – eine Beschriftung für den Künstler, ein Textfeld für den Albumtitel, ein Textfeld für den laufenden Musiktitel usw. Sobald der Benutzer zum nächsten Album bzw. Datensatz weiterspringt, gibt es eine Alternative: Statt für jedes Steuerelement des Formulars den Wert BindingContext.Position ändern zu müssen, können Sie ihn einfach für das Form-Objekt ändern: 'VB .NET Me.BindingContext[object].Position += 1 //C# this.BindingContext[object].Position += 1; BindingContext ändert sich dann in jedem einzelnen Steuerelement, das im Formular

angebunden ist.

8.3

Das Steuerelement DataGrid

Das leistungsstarke DataGrid-Steuerelement wurde speziell für den Einsatz bei der Datenbindung entworfen. Es ist bei der Datenanzeige in allen unterschiedlichen Formaten effizient, dabei verfügt es über eine Vielzahl von Anzeigeoptionen, die Sie zur Anpassung einer Benutzeroberfläche verwenden können. Das DataGrid verfügt sogar über eingebaute Funktionen für das Bearbeiten, Hinzufügen und Löschen von Elementen.

290

Das Steuerelement DataGrid

Die Einrichtung des Steuerelements ist einfach: Setzen Sie seine DataSource-Eigenschaft auf die Datenquelle, und schon kann's losgehen. Listing 8.3 zeigt ein einfaches Beispiel auf der Grundlage der Listings 8.1 und 8.2. Listing 8.3: Datenbindung eines DataGrid-Steuerelements 1: 2: 3: 4: 5: 6: 7: 8:

using System; using System.Windows.Forms; using System.Drawing;

namespace TYWinforms.Day8 { public class Listing83 : Form { private DataGrid dgData = new DataGrid(); private Color[] arrColors = {Color.Green, Color.Blue, Color.Red, Color.Orange}; 9: 10: public Listing83() { 11: dgData.DataSource = arrColors; 12: dgData.Size = new Size(800,600); 13: 14: this.Size = new Size(800,600); 15: this.Controls.Add(dgData); 16: } 17: 18: public static void Main() { 19: Application.Run(new Listing83()); 20: } 21: } 22: }

Dieser Code ist fast identisch mit dem in Listing 8.1. Der Unterschied: Statt einer ComboBox verwenden Sie hier ein DataGrid. Kompilieren Sie das Listing und betrachten Sie das Ergebnis, wie es in Abbildung 8.3 zu sehen ist. Was ist nun passiert? Sie haben dem DataGrid bloß ein Array von Farben zugewiesen, also wo kamen dann die ganzen zusätzlichen Informationen her? Die in Abbildung 8.3 zu sehenden Spalten IsEmpty, A, B, IsNamedColorIsKnownColor, Name, G, R und IsSystemColor sind alles Eigenschaften des Color-Objekts. Ungeachtet seiner Farbe verfügt jedes ColorObjekt über diese Eigenschaften. Da Sie dem DataGrid eine Sammlung von Color-Objekten übergaben, nahm es an, dass Sie alle Eigenschaften angezeigt haben wollten. Hätten Sie ihm ein Array von Zeichenfolgen übergeben, würde es einfach die Länge des Textinhalts dieser Zeichenfolgen anzeigen. Tabelle 8.1 führt die gebräuchlichsten UI-Eigenschaften des DataGrid-Steuerelements auf.

291

Datenbindung in Windows Forms

Abbildung 8.3: Das DataGrid zeigt mühelos umfangreiche Datenmengen an. Eigenschaft

Beschreibung

AlternatingBackcolor

Legt die Farbe für jede zweite anzuzeigende Zeile fest (damit der Benutzer die Zeilen besser unterscheiden kann).

BackColor

Legt fest, welche Hintergrundfarbe das Datenblatt an.

BackGroundColor

Legt fest, welche Hintergrundfarbe die Fläche außerhalb des Datenblattes hat.

BorderStyle

Gibt einen der Werte der BorderStyle-Aufzählung an.

CaptionBackColor

Legt fest, welche Hintergrundfarbe der Titelbereich hat.

CaptionFont

Legt die Schriftart für den Titelbereich fest.

CaptionForeColor

Legt die Farbe der Schriftart im Titel fest.

CaptionText

Enthält den im Titel anzuzeigenden Text.

CaptionVisible

Gibt an, ob die Titelzeile sichtbar ist

ColumnHeadersVisible

Gibt an, ob die Spaltenköpfe sichtbar sind.

FlatMode

Gibt an, ob das Datenblatt im Flachmodus angezeigt wird (dieser Modus zeigt keine sichtbaren Linien zwischen Spalten- und Zeilenüberschriften an).

ForeColor

Gibt die Schriftfarbe im Datenblatt an.

GridLineColor

Gibt die Farbe der Datenblattlinien an.

GridLineStyle

Gibt einen der Werte der DataGridLineStyle-Aufzählung an: None: keine Datenblattlinien; Solid: durchgehende Datenblattlinien.

HeaderBackColor

Legt die Hintergrundfarbe der Zeilen- und Spaltenköpfe fest.

HeaderFont

Legt die Schriftart der Spaltenköpfe fest.

HeaderForeColor

Legt die Schriftfarbe der Kopfzeile fest.

Tabelle 8.1: Eigenschaften der DataGrid-Benutzeroberfläche

292

Das Steuerelement DataGrid

Eigenschaft

Beschreibung

LinkColor

Gibt die Farbe von Links an, mit deren Hilfe man zu untergeordneten Tabellen navigieren kann (mehr dazu morgen).

LinkHoverColor

Gibt die alternative Farbe von Links an, falls der Mauszeiger darüber schwebt.

ParentRowsBackColor

Legt die Hintergrundfarbe von übergeordneten Zeilen fest.

ParentRowsForeColor

Legt die Schriftfarbe von übergeordneten Zeilen fest.

ParentRowsLabelStyle

Enthält einen Wert der DataGridParentRowsLabelStyle-Aufzählung: ColumnName: der Name der übergeordneten Spalte TableName: der Name der übergeordneten Tabelle Both: beide Namen None: weder der eine noch der andere Name

ParentRowsVisible

Gibt an, ob übergeordnete Zeilen sichtbar sind.

PreferredColumnWidth

Legt die Breite angezeigter Spalten fest.

PreferredRowHeight

Legt die Höhe angezeigter Zeilen fest.

RowHeadersVisible

Gibt an, ob Titel für Zeilen sichtbar sind.

RowHeaderWidth

Legt die Breite von Zeilentitelzellen fest.

SelectionBackColor

Legt die Hintergrundfarbe einer ausgewählten Zelle fest.

SelectionForeColor

Legt die Schriftfarbe einer ausgewählten Zelle fest.

Tabelle 8.1: Eigenschaften der DataGrid-Benutzeroberfläche (Forts.)

Ein kurzer Blick auf ADO.NET Bevor Sie die Interaktion mit dem DataGrid-Steuerelement erlernen, sollten Sie noch einiges mehr über komplexe Datenstrukturen wissen. Arrays mögen ja schön und gut sein, sind aber leider nicht ganz optimal für die Speicherung und Darstellung von Daten. Sie lassen sich nicht vollständig modifizieren, und Sie können zwar einzelne Elemente im Array ändern, sie aber nicht vollständig entfernen. Wir werfen daher einen kurzen Blick auf einige der Objekte, die Teil von ADO.NET sind, insbesondere auf DataTable und seine Begleiter. Wenn Sie die morgige Lektion beginnen, haben Sie einen Vorsprung.

293

Datenbindung in Windows Forms

Eine DataTable ist eine vollständige Darstellung von Daten in einer Tabelle. Stellen Sie es sich als zweidimensionales Array mit Namen vor. Werfen Sie einen Blick auf Tabelle 8.2, die Informationen über Namen und Handorientierung bereithält. Vorname

Nachname

Handorientierung

Walter

Saravia

Rechtshänder

Eva

Payne

Rechtshänder

Joel

Andres

Linkshänder

Tabelle 8.2: Musterdaten

Diese Tabelle weist drei Datenzeilen und drei Spalten auf, die »Vorname«, »Nachname« und »Handorientierung« heißen. Aus dieser Tabelle können Sie ersehen, dass eine Spalte einen Informationstyp darstellt und eine Zeile die eigentlichen Daten (die Zeile wird im Deutschen auch als »Datensatz« bezeichnet). Eine DataTable ist genau das Gleiche. DataRow-Objekte stellen Zeilen in der DataTable dar und DataColumn-Objekte die Datentypen. Das DataGrid ist demnach optimal für die Informationsdarstellung in einer DataTable geeignet, denn es zeigt Daten im Tabellenformat an, wie Sie noch aus Abbildung 8.3 wissen. Wir wollen lernen, wie man Daten in einer DataTable speichert; diese Prozedur wird Ihnen sehr bekannt vorkommen. Sie müssen zuerst Ihre DataTable erstellen – das geht wie bei jedem anderen Objekt: //C# DataTable objMyTable =new DataTable("Meine Tabelle "); 'VB .NET dim objMyTable as New DataTable("Meine Tabelle ")

Die in Klammern stehenden Wörter stellen den Tabellennamen dar (sie werden für das spätere leichte Auffinden gebraucht). Als Nächstes erzeugen Sie DataColumn-Objekte, die jeweils einen der zu speichernden Informationstypen darstellen, und fügen Sie Ihrer DataTable hinzu. Dieser Vorgang ähnelt dem Hinzufügen von Steuerelementen zu einem Formular: //erzeugen Sie eine Spalte für Integer DataColumn ColumnA = new DataColumn(); ColumnA.DataType = System.Type.GetType("System.Int32 "); ColumnA.ColumnName = "Spalte A "; //erzeugen Sie eine Spalte für Zeichenfolgen DataColumn ColumnB = new DataColumn(); ColumnB.DataType = System.Type.GetType("System.String "); ColumnB.ColumnName ="Spalte B ";

294

Das Steuerelement DataGrid

//fügen Sie sie der Datentabelle hinzu objMyTable.Columns.Add(ColumnA); objMyTable.Columns.Add(ColumnB);

Nun verfügen Sie über eine vollständige, wenngleich etwas leere DataTable (also eine ohne Daten). Sie wird je zwei Datenelemente pro Zeile oder »Datensatz« enthalten: einen Integerwert und einen Zeichenfolgenwert. Um Daten hinzuzufügen, integrieren Sie einfach DataRows. Das folgende Stück Code zeigt eine einfache Möglichkeit die DataTable mit Daten zu füllen, indem man eine for-Schleife verwendet: DataRow myDataRow; for (int i =0; i <= 10; i++) { myDataRow = objMyTable.NewRow(); myDataRow ["Column A "] == i; myDataRow ["Column B "] == i.ToString(); objMyTable.Rows.Add(myDataRow); }

Beachten Sie, dass Sie eine neue DataRow mit Hilfe der NewRow-Methode des bereits vorhandenen DataTable-Objekts anlegen. Durch diese Vorgehensweise stellen Sie sicher, dass Ihre neue Zeile über alle richtigen Spalten und Datentypen verfügt. Sie füllen daraufhin diese Spalten auf, indem Sie sie nach ihren Namen referenzieren. Zum Schluss fügen Sie die neue Zeile der Tabelle hinzu, wie Sie es bei den Spalten taten. Wenn Sie diesen Code ausführen, erhalten Sie die Daten in Tabelle 8.3. Column A

Column B

0

"0"

1

"1"

2

"2"

3

"3"

4

"4"

5

"5"

6

"6"

7

"7"

8

"8"

9

"9"

10

"10"

Tabelle 8.3: Ihre neue DataTable

295

Datenbindung in Windows Forms

Jetzt können Sie Ihre DataGrid.DataSource-Eigenschaft auf Ihre neue DataTable setzen und erhalten schließlich eine Tabelle wie in Abbildung 8.4.

Abbildung 8.4: Das DataGrid zeigt Ihre DataTable-Struktur und -Daten perfekt an.

Die Objekte DataTable, DataColumn und DataRow verfügen über weitaus mehr interessante Eigenschaften als die hier beschriebenen, doch spare ich mir diese Erörterung für morgen auf. Vielmehr wollen wir uns nun ansehen, wie wir diese Daten mit Hilfe des DataGridSteuerelements manipulieren.

Die Interaktion mit einem DataGrid Wenn Sie mit dem vorhergehenden Beispiel etwas experimentiert haben, wissen Sie, dass man Daten ganz leicht bearbeiten kann: Man wählt einfach eine gewünschte Zelle zum Editieren aus und gibt neue Daten ein. Mit dem DataGrid können Sie steuern, wie und ob die Zellen sich editieren lassen, ebenso ihren Stil und ihre Formatierung. Mit Hilfe einer Reihe von Stilobjekten, die Sie auf das DataGrid anwenden, können Sie praktisch jeden Aspekt des DataGrid-Steuerelements ändern. Wir wollen uns zunächst das DataGridTableStyle-Objekt ansehen. Das Erstellen eines Stils ist einfach: DataGridTableStyle dgStyle = new DataGridTableStyle(); dgStyle.MappingName = "Meine Tabelle "; dgStyle.BackColor = Color.Blue; dgData.TableStyles.Add(dgStyle);

Die erste Zeile ist klar: Sie erzeugt ein neues DataGridTableStyle-Objekt. Die zweite Zeile, MappingName, teilt dem DataGrid mit, welche Tabelle die Stile zugewiesen bekommt. Hier verwenden Sie den DataTable-Namen, den Sie im vorhergehenden Abschnitt erzeugt haben. Als Nächstes stellen Sie jede gewünschte Eigenschaft ein und fügen schließlich das DataGridTableStyle-Objekt dem DataGrid hinzu.

296

Das Steuerelement DataGrid

Zu den einstellbaren Stileigenschaften gehören: 쐽

AlternatingBackColor und BackColor

쐽

HeaderBackColor und HeaderForeColor

쐽

GridLineColor und GridLineStyle

쐽

LinkColor

쐽

(gibt an, ob sich das DataGrid bearbeiten lässt)

Kurz gesagt: Das DataGridTableStyle-Objekt verfügt über praktisch jede Eigenschaft wie das DataGrid selbst. Warum also zwei Objekte benutzen? Weil sich das DataGrid an mehr als eine Tabelle zugleich binden lässt (wie Sie morgen sehen). Daher können Sie auch mehrere Stile benutzen – einen für jede Tabelle – ohne das gesamte DataGrid neu formatieren zu müssen. (Deshalb muss unbedingt der MappingName – siehe unten – angegeben werden!) Das DataGridTableStyle gestattet Ihnen die Formatierung jeder Spalte (wie auch ihr Entfernen und Hinzufügen; es gibt übrigens kein DataGridRowStyle). Das DataGridTableStyleObjekt weist einige Eigenschaften auf, die Spalten betreffen: 쐽

Alignment: Gibt die Ausrichtung von Text in der Spalte an.

쐽

HeaderText: Legt den Text in der Spaltenkopfzelle fest.

쐽

NullText: Gibt an, was angezeigt werden soll, falls der Wert für eine bestimmte Zelle gleich null ist (oder Nothing in VB .NET).

쐽

MappingName: Das Gleiche wie für das DataGridTableStyle-Objekt.

쐽

ReadOnly: Gibt an, ob die Daten in der angegebenen Spalte nur gelesen werden dürfen.

쐽

Width: Gibt die Spaltenbreite an.

Alle diese Eigenschaften bieten keine Besonderheiten. Um ein DataGridColumnStyle zuzuweisen, muss man zuerst einen Typ des DataGridTableStyle erstellen. Ein DataGridColumnStyle-Objekt lässt sich nicht direkt erstellen. Statt dessen verwenden Sie entweder DataGridBoolColumn (das Kontrollkästchen in den Zellen anzeigt) oder DataGridTextBoxColumn (das Textfelder anzeigt – der Standardstil), je nach Bedarf. (Jedes Objekt verfügt über weitere anpassbare Eigenschaften; wir kommen gleich darauf zu sprechen.) Dann fügen Sie der Eigenschaft GridColumnStyles den neuen Spaltenstil hinzu: DataGridTableStyle dgTableStyle = new DataGridTableStyle(); // einige Eigenschaften einstellen DataGridTextBoxColumn dgColumnStyle = new DataGridTextBoxColumn(); //einige Spalteneigenschaften einstellen dgTableStyle.GridColumnStyles.Add(dgColumnStyle); dgData.TableStyles.Add(dgTableStyle);

297

Datenbindung in Windows Forms

Wenn Sie eine DataGridTextBoxColumn oder DataGridBoolColumn erstellen, überschreibt dies einige der Standardwerte für jede Spalte. So zeigen etwa die Spaltenkopfzellen die Mapping-Namen. Wenn Sie nun einen Stil mit DataGridTextBoxColumn oder DataGridBoolColumn erstellen, wird der Kopfzeilentext überschrieben und bleibt schließlich leer. Verwenden Sie in diesem Fall die HeaderText-Eigenschaft, um die Kopfzellen einzurichten. So können Sie sich die Bezeichnungsregel merken: Ein DataGrid zeigt eine Tabelle an, und die TableStyles-Eigenschaft definiert den Style (Stil) dieser table (Tabelle) mit Hilfe eines DataGridTableStyle-Objekts. Eine Tabelle wiederum stellt columns (Spalten) in einem grid (Datenblatt) dar. Die GridColumnStyles-Eigenschaft definiert den Style für diese Spalte mit Hilfe eines DataGridColumnStyle-Objekts. In freier Notation sieht dies wie folgt aus: DataGrid.TableStyles = DataGridTableStyle DataGridTableStyle.GridColumnStyle = DataGridColumnStyle

Lassen Sie uns mit der Farbenanwendung fortfahren, die wir oben mit Hilfe von DataGrid- und Stilobjekten erstellt haben. Listing 8.4 zeigt die grundlegende Struktur dieser Anwendung. Listing 8.4: Die erweiterte Farbenanwendung 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23:

298

using using using using

System; System.Windows.Forms; System.Drawing; System.Data;

namespace TYWinforms.Day8 { public class Listing84 : Form { private DataGrid dgData = new DataGrid(); private DataTable objMyTable = new DataTable("Colors"); public Listing84() { DataColumn colName = new DataColumn(); colName.DataType = System.Type.GetType("System.String"); colName.ColumnName = "Farbbezeichnung"; DataColumn colR = new DataColumn(); colR.DataType = System.Type.GetType("System.Int32"); colR.ColumnName = "Rot"; DataColumn colG = new DataColumn(); colG.DataType = System.Type.GetType("System.Int32"); colG.ColumnName = "Grün";

Das Steuerelement DataGrid

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: 66: 67: 68: 69:

DataColumn colB = new DataColumn(); colB.DataType = System.Type.GetType("System.Int32"); colB.ColumnName = "Blau"; objMyTable.Columns.Add(colName); objMyTable.Columns.Add(colR); objMyTable.Columns.Add(colG); objMyTable.Columns.Add(colB); DataRow myDataRow; myDataRow = objMyTable.NewRow(); myDataRow["Farbbezeichnung"] = Color.Blue.Name; myDataRow["Rot"] = Color.Blue.R; myDataRow["Grün"] = Color.Blue.G; myDataRow["Blau"] = Color.Blue.B; objMyTable.Rows.Add(myDataRow); myDataRow = objMyTable.NewRow(); myDataRow["Farbbezeichnung"] = Color.Red.Name; myDataRow["Rot"] = Color.Red.R; myDataRow["Grün"] = Color.Red.G; myDataRow["Blau"] = Color.Red.B; objMyTable.Rows.Add(myDataRow); myDataRow = objMyTable.NewRow(); myDataRow["Farbbezeichnung"] = Color.Green.Name; myDataRow["Rot"] = Color.Green.R; myDataRow["Grün"] = Color.Green.G; myDataRow["Blau"] = Color.Green.B; objMyTable.Rows.Add(myDataRow); myDataRow = objMyTable.NewRow(); myDataRow["Farbbezeichnung"] = Color.PapayaWhip.Name; myDataRow["Rot"] = Color.PapayaWhip.R; myDataRow["Grün"] = Color.PapayaWhip.G; myDataRow["Blau"] = Color.PapayaWhip.B; objMyTable.Rows.Add(myDataRow); dgData.DataSource = objMyTable; dgData.Dock = DockStyle.Fill; this.Size = new Size(800,600); this.Controls.Add(dgData); this.Text = "Listing 8.4"; }

299

Datenbindung in Windows Forms

70: 71: 72: 73: 74:

public static void Main() { Application.Run(new Listing84()); } } }

Die Zeilen 1 bis 4 importieren die notwendigen Namensräume. Vergessen Sie System.Data nicht. Er enthält die diversen DataTable-Objekte. Als Nächstes deklarieren Sie in den Zeilen 8 und 9 ein DataGrid und eine DataTable. In den Zeilen 12 bis 26 findet die Erstellung neuer Spalten für Ihre DataTable statt; in den Zeilen 28 bis 31 fügen Sie sie der Tabelle hinzu. Die Zeilen 33 bis 60 fügen ihr neue Zeilen hinzu. Beachten Sie, dass Sie auf jede Spalte mit dem ihr zuvor gegebenen Namen verweisen. Im Grunde bestehen diese Zeilen aus demselben viermal wiederholten Code, wobei jedes Mal eine andere Farbe verwendet wird: Red, Green, Blue und PapayaWhip (ein zugegebenermaßen interessanter Name). Wenn Sie diese Anwendung ausführen, zeigt sie einfach diese Werte in editierbaren Feldern an. Wir sollten sie etwas interessanter gestalten, etwa indem wir Stile hinzufügen. Listing 8.5 zeigt den im Konstruktor zu platzierenden Code dafür. Listing 8.5: Die Stile für Ihre Farbenanwendung 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20:

300

DataGridTableStyle dgtStyle = new DataGridTableStyle(); dgtStyle.MappingName = "Farben"; DataGridTextBoxColumn dgcNameStyle = new DataGridTextBoxColumn(); dgcNameStyle.MappingName = " Farbbezeichnung"; dgcNameStyle.HeaderText = " Farbbezeichnung"; DataGridTextBoxColumn dgcRedStyle = new DataGridTextBoxColumn(); dgcRedStyle.MappingName = "Rot"; dgcRedStyle.ReadOnly = true; dgcRedStyle.HeaderText = "Rot"; DataGridTextBoxColumn dgcGreenStyle = new DataGridTextBoxColumn(); dgcGreenStyle.MappingName = "Grün"; dgcGreenStyle.ReadOnly = true; dgcGreenStyle.HeaderText = "Grün"; DataGridTextBoxColumn dgcBlueStyle = new DataGridTextBoxColumn(); dgcBlueStyle.MappingName = "Blau"; dgcBlueStyle.ReadOnly = true;

Das Steuerelement DataGrid

21: 22: 23: 24: 25: 26: 27: 28:

dgcBlueStyle.HeaderText = "Blau"; dgtStyle.GridColumnStyles.Add(dgcNameStyle); dgtStyle.GridColumnStyles.Add(dgcRedStyle); dgtStyle.GridColumnStyles.Add(dgcGreenStyle); dgtStyle.GridColumnStyles.Add(dgcBlueStyle); dgData.TableStyles.Add(dgtStyle);

In Listing 8.5 legen Sie den Kopfzellentext für jede Spalte fest und setzen alle außer der »Farbbezeichnung«-Spalte auf readonly. Auf diese Weise kann der Benutzer nur die erste Spalte ändern, nämlich die Farbbezeichnung. Doch die Anwendung ist weiterhin langweilig. Wir wollen eine Methode hinzufügen, die die Farbe des DataGrid-Steuerelements dynamisch ändert. Das CurrentCellChanged-Ereignis wird immer dann ausgelöst, wenn der Benutzer zu einer neuen Zelle im Datenblatt springt. Wir wollen dieses Ereignis überwachen, um Farbwechsel anzuwenden: Klickt der Benutzer auf eine Zelle, ändern Sie die Farbe auf die für diese bestimmte Zelle festgelegte Farbe. Um dies zu bewerkstelligen, fügen Sie Ihrem Konstruktor die folgende Delegaten-Zuweisung hinzu: dgData.CurrentCellChanged += new EventHandler(this.HandleColor);

Dann bauen Sie Ihrer Anwendung folgende Methode ein: public void HandleColor(Object Sender, EventArgs e) { if (Color.FromName(dgData [dgData.CurrentCell ].ToString()).IsKnownColor){ dgData.TableStyles [0 ].ForeColor = Color.FromName(dgData [dgData.CurrentCell ].ToString()); } }

Obwohl sie kompliziert aussieht, ist die Methode doch recht simpel. Zuerst muss man auswerten, ob die Farbe in der Zelle eine gültige ist; da die Zelle editierbar ist, könnte der Benutzer ja hergehen und sie auf einen unzulässigen Wert setzen. Würden Sie versuchen die Farbe mit diesem ungültigen Wert zu modifizieren, würde sich alles in Weiß verwandeln (die Standardfarbe). In der 2. Zeile verwenden Sie ein if-Statement. Zuerst holen Sie die in der Zelle angegebene Farbe mit dem folgenden Befehl: dgData[dgData.CurrentCell].ToString()

Die CurrentCell-Eigenschaft gibt natürlich den aktuellen Wert in der gerade markierten Datenblattzelle zurück. Diese Eigenschaft gibt ein DataGridCell-Objekt zurück, welches Eigenschaften besitzt, um die genaue Position der Zelle im Datenblatt festzustellen. Leider hat es keine Eigenschaften, um Ihnen den Zelleninhalt zu verraten. Sie müssen hierfür die

301

Datenbindung in Windows Forms

Elementauflistung des DataGrid-Steuerelements verwenden, um diesen Wert zu ermitteln, und ihn schließlich noch obendrein in eine Zeichenfolge konvertieren. In Visual Basic .NET würde Ihr Code so aussehen: dgData.Item(dgData.CurrentCell).ToString()

Als Nächstes konvertieren Sie diesen ermittelten Wert mit Hilfe der FromName-Methode in ein Color-Objekt. IsKnownColor liefert einen wahren oder falschen Wert, um anzuzeigen, ob es die Farbe wirklich gibt. In diesem Fall geht es mit folgendem Schritt weiter: dgData.TableStyles [0].ForeColor = Color.FromName(dgData[dgData.CurrentCell ].ToString());

Der erste Teil ist einfach: Sie ändern die ForeColor-Eigenschaft des DataGridTableStyleObjekts im DataGrid. Der zweite Teil ist identisch mit dem vorigen if-Statement, nur dass Sie diesmal die IsKnownColor-Eigenschaft auslassen. Versuchen Sie nun diese Anwendung auszuführen. Sie sollten bemerken können, dass die Schriftfarbe wechselt, sobald Sie zu einer neuen Zelle springen. Sie können sogar eine neue Farbe eintippen und die Zellenfarbe ändert sich entsprechend (vorausgesetzt, Ihre Eingabe bezeichnet eine »echte« Farbe). Abbildung 8.5 zeigt das Ergebnis.

Abbildung 8.5: Ihr DataGrid wechselt seine Farbe.

Die Klassen DataGridTextBoxColumn und DataGridBoolColumn Wie Sie bereits wissen, können Sie ein DataGridColumnStyle-Objekt nicht direkt erstellen; Sie können nur Instanzen der von ihm abgeleiteten Klassen erzeugen (dieser Klassentyp wird als abstrakte Klasse bezeichnet; eine Klasse, von der man keine Instanz erstellen kann, ist abstrakt). Es liegen nur zwei dieser Klassen vor, nämlich DataGridTextBoxColumn und DataGridBoolColumn, und jede besitzt nur wenige interessante Eigenschaften. Die Klasse DataGridBoolColumn zeigt für jede Zeile im DataGrid ein Kontrollkästchen an, mit dem ein wahrer oder falscher Wert angezeigt wird. Diese Spalte verfügt über TrueValue- und FalseValue-Eigenschaften, die die tatsächlichen Werte der Spalte angeben (ob wahr oder falsch, das heißt 1 oder 0, und so weiter). In ähnlicher Weise gibt NullValue den zurückgegebenen Wert an, wenn die gebundenen Daten einen Nullwert enthalten. Man verwendet die AllowNull-Eigenschaft, um Nullwerte zu erlauben oder zu unterbinden.

302

Das Steuerelement DataGrid

Die Klasse DataGridTextBoxColumn zeigt für jede Zeile in der Spalte ein Textfeld an. Eine besonders interessante Eigenschaft ist Format, die festlegt, wie der Text in der Spalte angezeigt werden soll. (Die Formatierung wird nur auf angezeigte Werte angewandt; der eigentliche Wert ändert sich nicht.) Angenommen, Sie haben einen Datumswert wie etwa "1/1/ 00" mit dem DataGrid verbunden. Sie setzen die Format-Eigenschaft auf die Zeichenfolge "D" und der Wert wird als "Samstag, 1. Januar 2000" (bitte auch die Systemeinstellungen beachten!) ausgegeben. Tabelle 8.4 führt die Formatzeichenfolgen und ihre Beschreibungen auf. Zeichenfolgen

Beschreibung

c

Währungsformat (currency). Legt fest, dass die Zeichenfolge als Währung anzuzeigen ist.

d

Dezimalformat (decimal). Die Zeichenfolge soll als Dezimalzahl angezeigt werden (z.B. 45, 12345 usw.)

e

Exponentialformat. Beispiel: 8,32e+12; x2.

f

Festkommaformat. Standardmäßig fügt dieses Format zwei Nullen rechts des Dezimalpunkts und jedes Dezimalwertes ein.

g

Allgemein (general). Diese Zeichenfolge erhält entweder das Dezimal- oder Exponentialformat. Er gibt das betreffende Format zurück, das die angegebene Zeichenfolge mit der geringsten Zeichenzahl repräsentiert.

n

Zahlenformat (number). Dem Dezimalformat ähnlich, jedoch mit Kommas und zwei Dezimalstellen nach dem Komma, etwa 45.324,00.

p

Prozentformat.

r

Schleifenformatbezeichner (Round-trip-Format). Dieses Format wird nur benutzt, wenn exakte Genauigkeit wichtig ist. Ein Double-Wert zum Beispiel ist auf 15 Stellen genau und wenn man ihn in eine Zeichenfolge umwandelt, wird alles jenseits der 15. Stelle gestrichen. Der Schleifenformatbezeichner sorgt dafür, dass diese Werte nicht wegfallen.

x

Hexadezimalformat. Die Zahl "12345" würde man hexadezimal als "3036" ausdrücken.

d

Kurze Datumsform: "28/1/02"

D

Lange Datumsform: "Montag, 28. Januar 2002"

t

Kurze Zeitform: "12:31"

Tabelle 8.4: Codes für das Formatieren von Zeichenfolgen und DateTime-Angaben

303

Datenbindung in Windows Forms

Zeichenfolgen

Beschreibung

T

Lange Zeitform: "3:51:24 PM" oder "17:54:22"

f

Kombination aus Langdatum- und Kurzzeitformat: "Montag, 28. Januar 2002, 12:31"

F

Kombination aus Langdatum- und Langzeitformat: "Montag, 28. Januar 2002, 17:54:22"

g

Kurzdatum und Kurzzeit: "28/1/02 3:51"

G

Kurzdatum und Langzeit: "28/1/02 17:54:22"

m

Tag und Monat: "28. Januar"

r

Das RFC1123-Muster: "Die, 10 Apr 2001 15:51:24 MESZ"

s

Das ISO8601-Muster für Datum und Zeit: "2001-04-10T15:51:24"

u

Universelles Muster für Datum und Zeit: "2001-04-10 15:51:24Z"

U

Universelles Muster für Datum und Zeit: "2001-04-10 15:51:24Z"

y

Jahr und Monat: "Januar 2002"

Tabelle 8.4: Codes für das Formatieren von Zeichenfolgen und DateTime-Angaben (Forts.)

Die Zeichenfolgenwerte in Tabelle 8.4 sind nicht von der Groß-/Kleinschreibung abhängig. Daher ist "c" das Gleiche wie "C". Beachten Sie auch, dass die Ausgaben der Formatzeichenfolgen für Datumswerte von den Ländereinstellungen Ihres jeweiligen PCs abhängen. Sie können jeder Formatzeichenfolge eine Zahl anhängen, die angibt, für wie viele Stellen (digits) die Zeichenfolge ausgeführt werden soll. Wenn Sie die Zahl "0,12345" hätten, würde das "p"-Format die Zeichenfolge als "12,35 %" ausgeben, wobei die Dezimalstellen nach dem Komma zu zwei Stellen auf- oder abgerundet werden. Wollen Sie aber alle ursprünglichen Werte erhalten, hängen Sie die Zahl 3 an: "p3". Es würde die Zeichenfolge nun als "12,345 %" anzeigen. Beim "d"-Format werden je nach Bedarf Nullen angehängt, ohne den Wert der Zahl zu ändern: Bei der Zahl "12345" würde "d6" also "012345" ausgeben. Doch "f6" würde mit demselben Ausgangswert »12345.000000« ausgeben.

304

Das Steuerelement DataGrid

Das Testen von Treffern Das letzte Thema in dieser Lektion ist die Fähigkeit des DataGrid festzustellen, was der Benutzer angeklickt hat, so etwa welche Zelle, welche Beschriftung usw. Dies wird als Treffertest oder Hit-Test bezeichnet. Die HitTest-Methode macht die Ermittlung dieser Information zu einem Kinderspiel. Beim Treffertesten müssen Sie ein Ereignis behandeln, bei dem der Benutzer einen Teil des DataGrid-Steuerelements anklickt. Idealerweise wäre dies das MouseDown-Ereignis, das einen besonderen Delegaten für die Rückgabe der x- und y-Koordinaten des Klicks verwendet. Um diesem Ereignis einen Delegaten zuzuweisen, verwenden Sie eine ungefähr so aussehende Zeile: dgData.MouseDown += new MouseEventHandler(this.HandleClick);

Die Signatur Ihres HandleClick-Ereignisses würde dann so aussehen: private void HandleClick(Object Sender, MouseEventArgs e) {}

Verwenden Sie die X- und Y-Eigenschaften des MouseEventArgs-Objekts, um festzustellen, wo genau der Benutzer geklickt hat. Rufen Sie dann die HitTest-Methode auf, um herauszufinden, mit welchem Teil des DataGrid-Steuerelements diese Koordinaten übereinstimmen. Die HitTest-Methode gibt ein DataGrid.HitTestInfo-Objekt zurück, das die gewünschten Informationen enthält. Das folgende Stück Code zeigt die HandleClickMethode beim Gebrauch der HitTest-Methode: private void HandleClick(Object Sender, MouseEventArgs e) { DataGrid.HitTestInfo myInfo; myInfo = dgData.HitTest(e.X, e.Y); MessageBox.Show("Spalte: " + myInfo.Column.ToString()); MessageBox.Show("Zeile: " + myInfo.Row.ToString()); MessageBox.Show("Typ: " + myInfo.Type.ToString()); }

Die Type-Eigenschaft gibt an, welcher Teil des DataGrid-Steuerelements angeklickt wurde. Sie kann einen der folgenden Werte der Aufzählung DataGrid.HitTestType haben: 쐽

Caption

쐽

Cell

쐽

ColumnHeader

쐽

ColumnResize

쐽

None

쐽

ParentRows

쐽

RowHeader

쐽

RowResize

305

Datenbindung in Windows Forms

Diese Aufzählungswerte geben die damit verbundenen Objekte nicht tatsächlich zurück (beispielsweise liefert DataGrid.HitTestType.Cell kein DataGridCell-Objekt). Diese Werte geben nur den angeklickten Objekttyp an.

8.4

Zusammenfassung

Heute haben Sie etwas über Datenbindung in Windows Forms gelernt. Dabei haben Sie auch eine Reihe von Datenbindungs-Steuerelementen kennen gelernt, etwa das DataGrid. Datenbindung ist eine leistungsfähige Methode, Ihre Benutzeroberfläche mit Ihrem Datenmodell zu verknüpfen. Um ein Steuerelement an Daten zu binden, fügen Sie einfach seiner DataBindings-Eigenschaft eine Datenquelle hinzu und geben die zu bindenden Daten an: MyControl.DataBindings.Add("Text ", DataSource, "optionaler Name der Datenquelle");

Sie können daraufhin die Steuerelementeigenschaft BindingContext.Position verwenden, um durch die verknüpften Daten zu navigieren, einen Datensatz nach dem anderen. Ein Großteil der heutigen Lektion beschäftigte sich mit dem DataGrid-Steuerelement, weil es so nützlich und leistungsstark ist. Damit können Sie Daten leicht in einem Datenblattformat anzeigen, und die Bestandteile können editierbar oder schreibgeschützt (read-only) sein. Setzen Sie einfach die DataSource-Eigenschaft des Steuerelements auf die zu bindenden Daten. Sie können das Aussehen des DataGrid-Steuerelements anpassen, indem Sie die DataGridTableStyle- und DataGridColumnStyle-Objekte verwenden. Ersteres steuert die Anzeige des gesamten DataGrid-Steuerelements, Letzteres die Anzeige pro Spalte. Es muss zuerst ein DataGridTableStyle-Objekt vorliegen, bevor Sie DataGridColumnStyle-Objekte hinzufügen können. Verwenden Sie die Objekteigenschaft MappingName, um festzulegen, welche Mitglieder der Daten anzuzeigen sind. Morgen lernen Sie Datenbanken in Ihre Anwendungen zu integrieren.

306

Fragen und Antworten

8.5 F

Fragen und Antworten

Was, wenn ich nicht alle Eigenschaften eines Objekts in DataGrid anzeigen möchte? A

Falls Sie ein Array verwenden, können Sie nicht viel dagegen tun. Falls Sie auf ein Array angewiesen sind, wird es das Beste sein, ein Array nur derjenigen Eigenschaften zu erstellen, die Sie angezeigt haben wollen. Im Falle einer DataTable erstellen Sie DataGridColumnStyles-Stile für jede anzuzeigende Spalte; diejenigen ohne zugewiesenen Stile werden einfach nicht angezeigt. Morgen erfahren Sie Neuigkeiten über DataSets und DataViews – Teile von ADO.NET – so dass Sie damit auch angezeigte Spalten anpassen können.

F

Gibt es eine Möglichkeit, eine einzelne Zelle in DataGrid anzupassen? A

8.6

Leider nein. Wenn Sie diese Art von Kontrolle über die Anzeige brauchen, dann sollten Sie wahrscheinlich Ihre eigene Benutzeroberfläche erstellen und sich nicht auf das DataGrid stützen.

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. Schreiben Sie ein Statement, das einem Textfeld-Steuerelement namens tbOne eine neue Datenbindung hinzufügt. Binden Sie an die Text-Eigenschaft das Array arrOne. 2. Ist das folgende Statement für das Textfeld aus Frage 1 korrekt? tbOne.BindingContext.Position += 1;

3. Wahr oder falsch? Man kann Daten an ein Form-Objekt binden. 4. Welches Ereignis wird oft verwendet, um die HitTest-Methode aufzurufen, und aus welchem Grund? 5. Wie würde die Anzeige der Zahl "458.34e+04" aussehen, wenn man die Formatzeichenfolge "d3" darauf anwendet?

307

Datenbindung in Windows Forms

6. Welcher Eigenschaft des DataGrid-Steuerelements fügen Sie DataGridTableStyleObjekte hinzu? 7. Welcher Eigenschaft des DataGrid-Steuerelements fügen Sie DataGridColumnStyleObjekte hinzu? 8. Angenommen, Sie haben eine DataTable namens dtData mit zwei Spalten namens ColA und ColB. Erzeugen Sie eine neue, leere Zeile. 9. Erzeugen Sie die ColA-Spalte der in Frage 8 erwähnten DataTable als einen IntegerTyp.

Übung Erstellen Sie eine DataGrid und DataTable verwendende Anwendung, in der der Benutzer seine Kontoführungsinformationen – wie in Quicken oder Microsoft Money – eingeben kann. Gestatten Sie nicht, dass das DataGrid manuell editiert wird, sondern stellen Sie vielmehr dem Benutzer andere Steuerelemente für die Eingabe der Informationen bereit, die dann im DataGrid beim Bestätigen bzw. Absenden angezeigt werden. Um dieses Beispiel einfach zu halten, gestatten Sie momentan nur Abbuchungen.

308

ADO.NET einsetzen

9

ADO.NET einsetzen

Der Einsatz von Datenbanken ist heutzutage häufig eine wichtige Komponente in fast jeder modernen Anwendung. Datenbanken können eine Fülle an Informationen speichern, von Kundendaten für einen multinationalen Konzern bis hin zu den Gästebuchbesuchern auf einer Website. Daraus folgt, dass das Zusammenspiel zwischen einer Anwendung und einer Datenbank oftmals von höchster Bedeutung ist, da entscheidende Daten, die ausgetauscht werden, auf dem Spiel stehen können. ADO.NET ist eine Technologie, mit der Ihre Anwendungen mit praktisch jeder Art von Datenbank oder Speichertechnik kommunizieren können, von Oracle über XML bis zu einfachem Text. Mit diesem leistungsfähigen Mechanismus können Sie Daten anzeigen, abrufen, bearbeiten, aktualisieren oder löschen, wobei Sie nur minimale Mittel benötigen. Dieses Kapitel zeigt, wie Sie ADO.NET verwenden und inwiefern es einen immensen Fortschritt gegenüber früheren Techniken darstellt. Heute lernen Sie, 쐽

wie Sie Datenbanken in Access und SQL Server 2000 erstellen,

쐽

aus welchen Komponenten ADO.NET besteht,

쐽

wie Sie Daten aus einer Datenbank an Ihre Anwendungen binden,

쐽

wie man eine Datenbank aktualisiert,

쐽

wie XML-Daten gelesen und geschrieben werden.

9.1

Was ist ADO.NET?

Vor der Einführung von .NET verwendeten Windows-Anwendungen häufig ActiveX Data Objects (ADO) für den Zugang zu und die Bearbeitung von Datenbanken. ADO ist eine für den Datenzugriff eingesetzte Programmierschnittstelle. Diese Methode war effizient und Entwickler konnten sie recht leicht erlernen und einsetzen. ADO litt jedoch unter einem veralteten Datenzugriffsmodell, das zahlreiche Einschränkungen aufwies, darunter die Unfähigkeit, Daten zu übermitteln. Zusammen mit dem Übergang von standardmäßigen SQL- (Structured Query Language-) Datenbanken zu stärker verteilten Datentypen (wie etwa der Extensible Markup Language, kurz XML) stellte Microsoft ADO.NET vor, die nächste Evolutionsstufe von ADO. ADO.NET stellt eine bedeutende Überarbeitung von ADO dar. Damit können Windows Forms-Anwendungen Daten auf weitaus effizientere und vielfältigere Weise darstellen. Es umfasst den vollen Funktionsumfang von XML und vermag daher leicht mit jeder XMLfähigen Anwendung zu kommunizieren. ADO.NET weist verschiedene neue Merkmale auf, die Ihr Leben als Entwickler erleichtern werden. Sie sollten sich mit ADO.NET vertraut machen, da es wichtig für dynamische Anwendungen ist. Seine Komplexität zu kennen, wird Ihnen später viele Kopfschmerzen ersparen.

310

Was ist ADO.NET?

Abbildung 9.1 zeigt das Datenzugriffsmodell in ADO.NET. Zu OLE DB-konformen Datenquellen wie etwa SQL oder JET (die Microsoft Access Datenbank-Engine) ist ADO.NET vollständig kompatibel. Windows Forms Application

ADO.NET

OLE DB

ODBC

SQL

Jet

etc.

Abbildung 9.1: Die Beziehung zwischen ADO.NET und Windows FormsAnwendungen

ADO.NET gegenüber ADO Obwohl ADO und ADO.NET einige Objekte gemeinsam haben, überwiegen doch die Unterschiede. Während nämlich ADO verbindungsbasiert war, fußt ADO.NET auf kurzen XML-Nachrichtenbasierten Interaktionen mit Datenquellen. Diese Fähigkeit verleiht ADO.NET eine weitaus höhere Effizienz im Zusammenhang mit webbasierten Anwendungen. Einen grundlegenden Wandel stellt in ADO.NET die Integration von XML für den Datenaustausch dar. ADO.NET verwendet XML in allen Transaktionen, wodurch ADO.NET Datenspeicher viel einfacher als ADO erreichen, persistent speichern und mit ihnen Daten austauschen kann. Somit kann ADO.NET auch eine höhere Performanz erzielen, denn XML-Daten lassen sich leicht in alle möglichen Datentypen umwandeln. Ein weiterer Paradigmenwechsel besteht in der Art und Weise, wie ADO.NET mit Datenbanken zusammenspielt. ADO erfordert zwingend das Sperren von Datenbankressourcen und permanente Verbindungen für seine Anwendungen, ADO.NET jedoch nicht mehr. Letzteres ist daher weitaus besser skalierbar, denn die Benutzer balgen sich quasi nicht mehr um die Datenbankverbindungen. Tabelle 9.1 fasst die zwischen ADO und ADO.NET vorgenommenen Änderungen zusammen.

311

ADO.NET einsetzen

In ADO

In ADO.NET

Daten werden dargestellt durch: Recordset, das einer einzelnen Tabelle oder einem Abfrageergebnis ähnelt

DataSet, das mehrere Tabellen aus jeder beliebigen

Datenquelle enthalten kann

Datenzugriff: Greift sequenziell auf Zeilen in einem Recordset zu

Erlaubt vollständig nichtsequenziellen Datenzugriff im DataSet durch eine auflistungsbasierte Hierarchie

Beziehungen zwischen mehreren Tabellen: Erfordert SQL-JOINs -UNIONs, um Daten aus mehreren Tabellen zu einem Recordset zusammenzuführen

Verwendet DataRelation-Objekte, die sich zur Navigation über verbundene Tabellen hinweg eignen

Gemeinsame Datenverwaltung: Erfordert die Konvertierung der Datenquellen Verwendet XML, so dass keine Konvertierung nötig ist Programmierbarkeit Verwendet ein Connection-Objekt, um mit den einer Datenquelle zu Grunde liegenden Konstrukten zu kommunizieren

Verwendet die streng typisierten Charakteristika von XML; erfordert keine Verwendung von Datenkonstrukten; kann alles nach dem Namen referenzieren

Skalierbarkeit Datenbanksperren und -verbindungen führten zu Konkurrenzkampf um die Datenressourcen

Keine Sperren oder langwierigen aktiven Verbindungen; der Konkurrenzkampf wurde eliminiert

Firewalls Voller Probleme, denn Firewalls verbieten viele Arten von Anfragen

Kein Problem, denn XML ist vollständig Firewallsicher

Tabelle 9.1: Zwischen ADO und ADO.NET vorgenommene Änderungen

312

Was ist ADO.NET?

ADO.NET und XML XML ist auch für die Datenbereitstellung ein sehr nützliches Hilfsmittel. Da es vollständig textbasiert ist, können Menschen diese Sprache leicht lesen und schreiben und es lässt sich einfach durch die Sicherheitsmaßnahmen des Internets schleusen. XML speichert Daten, indem es dafür eine hierarchische Darstellung von Feldern und ihren Daten bereitstellt. Wenn Sie eine Datenbank namens Users mit den Feldern Name, UserID und Geburtsdatum hätten, so würde sie in Textform so dargestellt werden: <Users> <User> <UserID /> <User>

Diese Grundstruktur wird als XML-Schema bezeichnet. (Tatsächlich liegen die Dinge etwas komplizierter als hier, die detaillierte Darstellung ginge aber über den Rahmen dieses Buches hinaus.) Mit Hilfe dieses Schemas können Sie daraufhin alle Daten in Ihren Tabellen darstellen: <Users> <User> Chris Payne <UserID>1 27. Juni <User> Eva Payne <UserID>2 15. Juli ... ...

Dieser Code lässt sich von jeder Person mit einer Textverarbeitung (wie etwa NotePad) lesen, wohingegen die entsprechende Datenbanktabelle nur von jemandem gelesen werden kann, der diese bestimmte Datenbankanwendung benutzt oder die Tabelle für eine weitere Datenbankanwendung konvertiert. XML ist eine wirkungsvolle, implementierungsunabhängige Möglichkeit, Daten zu speichern und zu senden – sicherlich einer der Gründe, warum es im Web ein so großer Erfolg geworden ist. Daher erscheint es nur folgerichtig, dass auch Datenbanken und ihre Schnittstellen diese Kommunikationsmethode übernehmen.

313

ADO.NET einsetzen

ADO.NET setzt XML bei jedem Datenaustausch und für interne Darstellungen ein. Sobald Daten aus einer Datenbank geholt werden, werden sie in XML dargestellt und an jeden gewünschten Bestimmungsort geschickt. Da jede Anwendung XML leicht umwandeln kann, sorgt diese Vorgehensweise für eine breitgefächerte Kompatibilität Ihrer Daten.

9.2

Eine Datenbank anlegen

Für die Zwecke dieser Lektion werden Sie es hilfreich finden, eine Datenbank zu haben, die Sie für das Testen der Beispiele verwenden können. Daher beschreibt dieses Unterkapitel, wie man eine Datenbank sowohl in Microsoft Access als auch in SQL Server 2000 erstellt, zwei der meistverbreiteten und am besten erhältlichen Datenbanksysteme.

Eine Access-Datenbank Sie werden die Datenbank, die Sie hier erstellen, in späteren Lektionen wiederverwenden, daher wollen wir etwas Brauchbares entwerfen. Zuerst erzeugen Sie eine Benutzer-Tabelle zur Speicherung folgender Informationen: 쐽

VorName

쐽

NachName

쐽

Adresse

쐽

Stadt

쐽

Bundesland

쐽

PLZ

쐽

Telefonnummer

Diese typische Benutzer-Datenbank lässt sich auf viele verschiedene Anwendungen übertragen. Um die Datenbank in Access zu starten, rufen Sie Access auf und wählen NEU aus dem DATEI-Menü. Wenn Sie das Dialogfeld in Abbildung 9.2sehen, wählen Sie darin die Option LEERE ACCESS-DATENBANK aus, nennen sie TYWinForms.mdb und speichern sie im Ordner C:\Winforms\daten. (Der Ordner ist beliebig wählbar; doch die Beispiele in diesem Buch verweisen auf diesen Ordner.) Nach einem Klick auf OK sollten Sie die folgenden Optionen sehen können: Erstellt eine Tabelle in der Entwurfsansicht, Erstellt eine Tabelle unter Verwendung des Assistenten und Erstellt eine Tabelle in der Datenblattansicht. Wählen Sie Entwurfsansicht und fangen Sie an, Ihre Spalten einzutragen. Tragen Sie VorName in die Spalte FELDNAME ein und wählen

314

Eine Datenbank anlegen

Sie TEXT in der Spalten DATENTYP. Optional können Sie für dieses Feld eine Beschreibung eingeben wie etwa Benutzervorname. Füllen Sie die übrigen Felder der obigen Liste aus, dann sollten Sie eine Tabelle ähnlich der in Abbildung 9.3 erhalten.

Abbildung 9.2: Ausgehend von diesem Dialogfeld können Sie eine neue, leere Datenbank erstellen.

Abbildung 9.3: Hier geben Sie die Feldinformationen der Tabelle ein.

Fügen Sie schließlich eine weitere Spalte namens UserID hinzu, die Ihre Identitätsspalte ist (jeder Wert hier ist eindeutig). Weisen Sie ihr den Datentyp AutoWert zu und rechtsklicken Sie auf den schwarzen Pfeil neben dem Namen. Wählen Sie aus dem Menü PRIMÄRSCHLÜSSEL aus und beachten Sie, wie das Schlüsselsymbol neben dem Namen erscheint. Als Nächstes speichern Sie die Tabelle mit dem Befehl DATEI/SPEICHERN. Der Dateiname sei tblUsers. Wählen Sie zum Schluss DATEI/SCHLIEßEN, um die Tabelle tblUsers zu schließen.

315

ADO.NET einsetzen

Wenn Sie einen Primärschlüssel für mehr als eine Spalte definieren wollen, dann markieren Sie jede Spalte bei gedrückter (Strg)-Taste und rechtsklicken dann, um den Primärschlüssel auszuwählen. Sie können nun Benutzer leicht hinzufügen, indem Sie auf die tblUsers-Option doppelklicken, die im Hauptfenster erscheint. Wenn Sie Daten eingeben, brauchen Sie keinen Wert für die Spalte UserID einzugeben. Eine Zahl wird automatisch eingefügt und bei jedem neuen Datensatz inkrementiert, wie in Abbildung 9.4 zu sehen. Tabelle 9.2 führt die verschiedenen in Access 2000 angebotenen Datentypen auf. Ähnliche Datentypen sind in sämtlichen Datenbanksystemen zu finden, wenn auch die konkreten Namen variieren können. Datentyp

Beschreibung

Autonumber (AutoWert)

Eine automatisch inkrementierte Ganzzahl (Integer), um Zeilen in einer Tabelle eindeutig zu identifizieren.

Currency (Währung)

Wird zur Speicherung von Währungsdaten verwendet.

Date/Time (Datum/Uhrzeit)

Wird für die Speicherung von Datums- und Zeitwerten verwendet. Access 2000 ist in der Lage, Jahreswerte zwischen 100 und 9999 zu speichern.

Memo

Speichert bis zu 65535 alphanumerische Zeichen.

Number (Zahl)

Speichert numerische Werte.

Text

Speichert bis zu 255 alphanumerische Zeichen.

Yes/No (Ja/Nein)

Wird für Spalten verwendet, die nur einen von zwei Werten haben können (ähnlich zu Bit- oder booleschen Typen)

Tabelle 9.2: Die Datentypen in Access 2000

Abbildung 9.4: Sie können jetzt in Ihre neue Tabelle Daten eingeben.

316

Eine Datenbank anlegen

Eine Datenbank in SQL Server 2000 anlegen Das Anlegen einer Datenbank in SQL Server 2000 ist ein wenig komplizierter als in Access, doch der Ablauf ist im Wesentlichen der gleiche. Access ist Ihren individuellen Ansprüchen angemessen, doch SQL Server 2000 wird in der Regel für umfangreichere Datenbanken verwendet, die mehr Sicherheit und Stabilität erfordern. Wir wollen nun die tblUser-Datenbank in SQL Server 2000 erstellen. In Ihrem Startmenü finden Sie die Menügruppe MICROSOFT SQL SERVER: Wählen Sie die Menüoption ENTERPRISE MANAGER. Sofern alles korrekt eingerichtet wurde, sollten Sie ein dem Windows Explorer ähnliches Navigationssystem sehen können, das oben MICROSOFT SQL SERVERS zeigt und den Namen Ihres Servers ein paar Hierarchieebenen darunter. Erweitern Sie den DATENBANKEN-Ordner (siehe Abbildung 9.5) und wählen Sie die Option NEUE DATENBANK aus dem Menü VORGANG bzw. aus dem Menü AKTION, wenn Sie den Enterprise Manager auf dem Client ausführen. (Sie können auch das Kontextmenü nutzen).

Abbildung 9.5: Um Ihre Datenbank zu erstellen, erweitern Sie den Ordner DATENBANKEN und wählen die Option NEUE DATENBANK aus dem Kontextmenü für Vorgänge bzw. Aktionen aus.

Geben Sie als Namen TYWinforms in das Dialogfeld ein, das erscheint. Im Moment akzeptieren Sie einfach die Standardoptionen der Registerkarte ALLGEMEIN und klicken auf OK. SQL Server 2000 wird eine neue Datenbank und ein Transaktionsprotokoll für Sie anlegen. Sie sollten nun TYWINFORMS im Ordner DATENBANKEN sehen können. Als Nächstes erweitern Sie diesen Eintrag in der Strukturansicht und wählen dann den TABELLEN-Knoten.

317

ADO.NET einsetzen

Sie bemerken, das SQL Server 2000 bereits einige Tabellen angelegt hat. Es handelt sich um Systemtabellen, die SQL Server benutzt, um die Elemente, die Sie in die Tabelle stellen, zu registrieren. Ignorieren Sie diese Tabellen für den Moment und wählen Sie NEUE TABELLE aus dem VORGANG-Menü aus. Sie sehen ein Gitter, das dem in Access gezeigten ähnelt. Geben Sie die Informationen wie in Access ein (siehe Abbildung 9.6), nur dass Sie diesmal den varchar-Datentyp anstelle von Text verwenden, denn Text hat in SQL Server 2000 eine andere Bedeutung. Beachten Sie, dass SQL Server 2000 weitaus mehr Datentypen bereitstellt als Access. Dieser Server ist eine leistungsfähigere Anwendung, bei der Entwickler die Datenbankoptionen mit viel größerer Feinheit einstellen können. Markieren Sie im SPALTEN-Bereich in der unteren Dialogfeldhälfte (siehe Abbildung 9.6) das UserID-Feld und wählen Sie JA für die Eigenschaft Identität. Dann klicken Sie auf dieses Feld mit der rechten Maustaste und wählen PRIMÄRSCHLÜSSEL FESTLEGEN aus. Speichern Sie als Nächstes diese Tabelle als tblUsers, indem Sie die Entwurfsansicht mit einem Klick auf die Steuerschaltfläche X rechts oben schließen, die Frage nach dem Speichern der Tabelle mit JA beantworten und dann den gewünschten angeben. Um in Ihre Tabelle Daten eingeben zu können, klicken Sie mit der rechten Maustaste auf die Tabelle und wählen TABELLE ÖFFNEN/ALLE ZEILEN ZURÜCKGEBEN aus, um einen tabellarischen Dateneingabemechanismus ähnlich dem in Access zu öffnen. Tragen Sie ein paar Namen und Adressen ein. (Tragen Sie jedoch nichts im UserID-Feld ein.) Klicken Sie auf das Ausrufezeichen (= Ausführen) im Menü, um die UserIDs automatisch zu erhöhen. Schließen Sie zu guter Letzt Ihre neue Tabelle durch einen Klick auf die SCHLIEßENSteuerschaltfläche.

Abbildung 9.6: Um eine Tabelle zu erstellen, geben Sie Feldnamen und Datentypen ein.

318

SQL für die Datenbankabfrage

Ich empfehle

Bitte beachten Sie

Verwenden Sie SQL Server, wenn Sie eine Setzen Sie SQL Server nicht für sehr einfache umfangreiche Datenbanklösung entwickeln, für Datenbanken mit nur wenigen Tabellen ein. die Performance wichtig ist und die fortgeschrit- Das führt zu Komplikationen, die unnötig sind. tene Datenbankfunktionen erfordert.

9.3

SQL für die Datenbankabfrage

Die Structured Query Language (SQL) ist ein Industriestandard, um an eine Datenbank Befehle auszugeben. Anwendungen wie SQL Server, Access und Oracle verwenden gleichermaßen SQL, um Daten zu manipulieren (wiewohl jede ihre eigene Methode hat, SQL einzusetzen). Die grundlegenden Fähigkeiten von SQL bestehen im Abrufen, Bearbeiten und Löschen von Daten, doch in Wirklichkeit handelt es sich um eine leistungsfähige und komplizierte Sprache, von der wir aber einen Großteil nicht in diesem Buch besprechen werden. Um aber mit ADO.NET arbeiten zu können, benötigen Sie eine gewisse Vertrautheit mit SQL, und die folgenden Abschnitte bilden eine kurze Einführung. Wie jede Programmiersprache verfügt auch SQL über Statements, die ausgeführt werden (doch anders als etwa C# muss SQL nicht kompiliert werden). Die vier wichtigen Statements, die Sie zwingend für die Zwecke dieser Lektion kennen müssen, sind SELECT, DELETE, INSERT und UPDATE; zum Glück folgen sie alle einer ähnlichen Syntax.

Das SELECT-Statement SELECT ist wohl das gebräuchlichste SQL-Statement. Sein Zweck ist im Grunde, eine Reihe von Daten aus einer Datenbanktabelle zu holen. Die Syntax dafür sieht so aus: SELECT Auswahlliste FROM Tabellenname [WHERE Suchbedingung] ORDER BY Sortierausdruck [ASC | DESC ]}

Die Struktur folgt grundlegenden Mustern des Englischen. Auswahlliste ist im Allgemeinen eine durch Kommas getrennte Liste der Spalten, die Sie abrufen wollen. VorName, NachName würde so etwa die Werte in diesen beiden Spalten zurückgeben. Zudem können Sie ein Sternchen verwenden, um alle Spalten einer bestimmten Tabelle (siehe Tipp) zurückzugeben. Tabellenname ist der Name derjenigen Tabelle, aus der die Daten geholt werden sollen.

319

ADO.NET einsetzen

Hier ist ein einfaches SELECT-Statement, das Sie für die von Ihnen angelegten Datenbanken verwenden könnten: SELECT * FROM tblUsers

Dieses Statement gibt alle Zeilen aller Spalten in der tblUsers-Tabelle zurück. Sie können damit tun, was Sie wollen. Das folgende Statement ist in der Funktion identisch: SELECT UserID, VorName, NachName, Adresse, Stadt, Bundesland, PLZ, Telefonnummer FROM tblUsers

Sie sollten SELECT * nicht verwenden, weil es oft mehr Daten liefert als Sie brauchen, und das kann zu reduzierter Performanz führen. Sie sollten statt dessen ausdrücklich nur diejenigen Spalten angeben, die Sie brauchen. Das ist zwar mehr Mühe beim Codeschreiben, doch Ihr Code wird dafür schneller ausgeführt. SELECT-Statements geben stets alle Zeilen in der Datenbank zurück, es sei denn, man schränkt dies durch eine WHERE-Bedingung ein. Sie können WHERE verwenden, um zusätzliche Kriterien für die zurückgegebenen Daten anzugeben. Eine WHERE-Bedingung kann im Grunde jedes logische Statement sein, ähnlich wie das if-Statement in normalen Programmiersprachen. Hier ein Beispiel: SELECT FROM tblUsers WHERE VorName = 'Chris' SELECT FROM tblUsers WHERE Stadt = 'ASP-Stadt' und NachName = 'Mitchell'

Das erste Statement gibt nur Datensätze zurück, in denen das Feld VorName den Wert Chris aufweist. Das zweite Statement gibt nur diejenigen Datensätze zurück, in denen Stadt gleich ASP-Stadt ist und das NachName-Feld Mitchell enthält. Um Jokerzeichen für Ihre WHERE-Bedingung zu verwenden, gibt es das LIKE-Schlüsselwort gefolgt von (einem oder mehreren) Jokerzeichen. Die Tabelle 9.3 führt die Operatoren auf, die das LIKE-Schlüsselwort akzeptiert. Operator

Übersetzung

*

Eine Zeichenfolge von null oder mehr Zeichen (in SQL Server wird dieses Zeichen durch % dargestellt).

_ (ein Unterstrich)

Genau ein Zeichen.

[]

Ein bestimmtes Zeichen in vorgegebener Menge.

Tabelle 9.3: Jokerzeichen für den LIKE-Operator in Access

320

SQL für die Datenbankabfrage

Die folgenden Statements demonstrieren den Gebrauch von LIKE: 1 2 3

SELECT * FROM tblUsers WHERE VorName LIKE '*s*' SELECT * FROM tblUsers WHERE VorName LIKE '_hris' SELECT * FROM tblUsers WHERE VorName LIKE '[abcd]hris'

Das SQL-Statement in Zeile 1 gibt jede Zeile zurück, in der der Vorname im Wert ein s enthält. Der Sternchen-Operator * funktioniert in SQL auf gleiche Weise wie in Windows und bedeutet null oder mehr Zeichen. Das Statement in Zeile 2 gibt alle Datensätze zurück, in denen der Vorname ein Zeichen enthält, das von der Zeichenfolge hris gefolgt wird. Auf Grund der vorliegenden Daten ergibt dieses Statement nur einen Datensatz, aber Sie sehen den Sinn. Zeile 3 gibt jeden Datensatz zurück, in dem der Vorname eine Zeichenfolge enthält, die mit einem der Buchstaben a, b, c oder d beginnt, gefolgt von der Zeichenfolge hris. Die ORDER BY-Klausel gibt die Reihenfolge an, in der die Daten zurückgegeben werden, so etwa in alphabetischer Reihenfolge. Verwendet man diese Bedingung nicht, kann man nie wissen, in welcher Reihenfolge man die Daten aus der Datenbank erhält. Mögen sie auch in alphabetischer Reihenfolge eingegeben worden sein, so heißt dies noch lange nicht, dass man sie auch in dieser Reihenfolge wieder herausbekommt. Mit der ORDER BY-Klausel können Sie festlegen, wie die Spalten sortiert werden, etwa so: SELECT * FROM tblUsers ORDER BY VorName ASC

Dieses Statement gibt alle Datensätze in alphabetisch nach Vornamen sortierter Reihenfolge zurück. Die Sortieroption DESC dreht diese Reihenfolge um (ASC = ascending, aufsteigend; DESC = descending, absteigend). Sie können mehrere, durch Komma abgegrenzte Spaltennamen in der ORDER BY-Klausel angeben, und zwar für jede Spalte mit ihrer eigenen Sortierreihenfolge. SQL verwendet die zusätzlichen Spalten, falls die erste duplizierte Daten (Verdopplungen) enthält. Geben Sie aber keinesfalls Spalten an, die nicht in der Tabelle vorhanden sind. Sie können SELECT-Statements einsetzen, um Daten aus mehr als einer Tabelle auf einmal zurückzugeben. Für das Tabellenname-Argument verwenden Sie dann einfach eine durch Kommas getrennte Liste von Tabellennamen. Normalerweise bestehen zwischen mehreren Tabellen Beziehungen, aber dieses Thema ginge über das Anliegen dieses Kapitels hinaus. Alle anderen SQL-Statements, die wir heute betrachten, folgen derselben grundlegenden Form wie die SELECT-Abfrage. Daher verwenden wir weniger Zeit darauf.

321

ADO.NET einsetzen

Das INSERT-Statement Ein weiteres gebräuchliches SQL-Statement ist INSERT, das neue Zeilen (also neue Daten) in eine Datenbanktabelle einfügt. Seine grundlegende Syntax sieht wie folgt aus: INSERT [INTO] Tabellenname [(Spaltenliste)] VALUES (DEFAULT | NULL | Ausdruck)

Dieses problemlose Statement ähnelt der Syntax von SELECT. Wir wollen ein Beispiel auf der Basis unserer Benutzer-Datenbank erstellen: INSERT INTO tblUsers (VorName, NachName, Adresse, Stadt, Bundesland, PLZ, Telefonnummer) VALUES ('Chris', 'Payne', 'ASP-Straße 135', ASP-Stadt', 'Florida', '36844', '8006596598')

Dieses Statement fügt eine neue Zeile mit den in der VALUES-Klausel angegebenen Feldwerten ein. Der in VALUES gelieferte Datentyp muss mit dem Datentyp in der entsprechenden Spalte übereinstimmen, oder man erhält eine Fehlermeldung. Wenn Sie eine Spalte angeben, müssen Sie auch einen Wert angeben, oder Sie bekommen noch eine Fehlermeldung.

Das UPDATE-Statement Das UPDATE-Statement aktualisiert vorhandene Zeilen in einer Datenbanktabelle. Sie können hier eine WHERE-Bedingung einbauen, um nur eine Untermenge der Tabellenwerte zu aktualisieren. Die Syntax sieht wie folgt aus: UPDATE Tabellenname SET Spaltenname = (DEFAULT | NULL | Ausdruck) [WHERE Suchbedingung]

Lassen Sie die WHERE-Bedingung weg, werden die angegebenen Spalten in jeder Zeile der Datenbank aktualisiert. Setzen Sie dieses Statement nur mit größter Vorsicht ein, denn damit können Sie Ihre Daten komplett ruinieren! Indem wir wieder unsere Datenbanktabelle tblUser verwenden, lässt sich UPDATE im Beispiel so verwenden: UPDATE tblUsers SET Adresse = 'ASP-Straße 136', 'Stadt = ASP-Weiler' WHERE VorName = 'Chris' AND NachName = 'Payne'

Dieses Statement ändert die Werte Adresse und Stadt für diejenigen Datensätze, in denen das Feld VorName den Wert Chris und das Feld NachName den Wert Payne enthält. Das ist momentan nur ein einziger Datensatz. Sie können nur die in der Spaltenname-Liste benötigten Spalten angeben. Die WHERE-Bedingung ist identisch mit der für das SELECT-Statement; Sie können auch hier wieder Jokerzeichen verwenden.

322

Einführung in DataSet

Das DELETE-Statement Das letzte hier behandelte Statement ist DELETE, welches Zeilen aus einer Datenbank löscht. Die Syntax sieht wie folgt aus: DELETE FROM Tabellenname WHERE (Suchbedingung)

In diesem einfachen Statement gibt es lediglich die sehr wichtige WHERE-Bedingung zu beachten. Denn wird sie nicht angegeben, löscht DELETE alle Zeilen aus der gesamten Datenbanktabelle – ein recht katastrophales Ereignis (außer wenn man eine Sicherheitskopie hat). Wieder ist die WHERE-Bedingung die gleiche wie für SELECT – ein Beispiel: DELETE FROM tblUsers WHERE VorName = 'Chris'

Dieses Statement löscht nur Datensätze, in denen der VorName auf Chris lautet.

9.4

Einführung in DataSet

In ADO.NET dreht sich alles um das DataSet. Dieses Objekt ist ein brandneues Konzept, das das althergebrachten Recordset aus ADO ersetzt. Das DataSet ist ein einfacher speicherresidenter Datenspeicher, der ein einheitliches Programmiermodell für den Datenzugriff bereitstellt, unabhängig vom jeweiligen Datentyp. Stellen Sie sich DataSet als eine Art Miniaturdatenbank vor. Anders als das Recordset enthält das DataSet vollständige Datenmengen, darunter Bedingungen, Beziehungen und sogar mehrere Tabellen auf einmal. Das DataSet-Objektmodell ist in Abbildung 9.7 zu sehen. Wenn Sie eine Verbindung zur Datenbank aufbauen, geben Sie ihr quasi eine Schachtel und befehlen dem Datenspeicher, diese mit etwas zu füllen. Sie können sie mit Datentabellen füllen, mit eigenen Daten von sonst wo oder mit anderen Daten. Ein DataSet ist eine solche Schachtel; die Datenbank übergibt Ihnen Kopien aller Daten, um die Sie bitten – und diese können Sie in der Schachtel herumtragen, ohne zugleich eine Verbindung zur Datenbank aufrechterhalten zu müssen. Abbildung 9.7 enthält auch ein DataTable-Objekt, das eine einzelne Datenbanktabelle darstellt. (Das DataSet verwaltet eine Auflistung dieser Tabellen im TablesCollection-Objekt.) Die DataTable ist eine vollständige Repräsentation der entsprechenden Tabelle inklusive aller Beziehungen und Schlüsselbedingungen. Sie enthält zwei weitere Auflistungen namens Rows und Columns, die jeweils die Daten und das Tabellenschema darstellen. Mit dem Objekt RelationsCollection können Sie über Tabellen je nach deren Beziehungen untereinander navigieren. Sie brauchen in Ihren SQL-Abfragen keine Joins und Unions mehr (die alte Methode zur Verknüpfung von Tabellen), denn ADO.NET macht das

323

ADO.NET einsetzen

DataSet ExtendedProperties RelationsCollection TablesCollection DataTable ChildRelations Columns

DataColumns

Constraints DefaultView ExtendedProperties ParentRelations PrimaryKeys Rows

DataRows

Abbildung 9.7: Das DataSet-Objektmodell enthält vollständige Mengen von Daten.

Navigieren viel einfacher. Die eigentlichen Beziehungen werden durch DataRelationObjekte dargestellt, die Informationen über die beiden zu verknüpfenden Tabellen enthalten, so etwa über die Primär- und Fremdschlüsselbeziehungen sowie die Namen der Beziehungen. Mit Hilfe des DataRelation-Objekts können Sie sogar Beziehungen hinzufügen. ADO.NET erzwingt zudem Schlüsseleinschränkungen; damit können Sie keine Tabelle derartig ändern, dass die Beziehung zu einer anderen Tabelle verletzt würde. Das ExtendedProperties-Objekt umfasst zusätzliche Informationen wie etwa Benutzernamen und Kennwörter. Kurzum, das DataSet ist ein vielseitiges Hilfsmittel. Es ist völlig gleich, wo die Daten herkommen oder wohin sie gehen; das DataSet ist völlig von jedem Datenspeicher abgetrennt. Daher können Sie DataSet als eine eigenständige Entität behandeln. Wie gesagt, kann DataSet mehrere DataTables enthalten. Da Sie bereits wissen, wie man DataTables erstellt, beherrschen Sie bereits die Methode, DataSets zu erstellen. Angenommen, Sie haben bereits eine Tabelle erzeugt und mit Zeilen und Spalten gefüllt, dann ist alles, was Sie noch tun müssen, sie dem DataSet hinzuzufügen: DataSet MyData = new DataSet("Meine Daten"); MyData.Tables.Add(Tabelle)

Diese Fähigkeit mag ja interessant sein, hat aber noch wenig praktischen Nutzen. Warum sollten Sie schließlich von Hand mehrere DataTables erzeugen, um sie dann in ein DataSet zu stecken? Diese Fähigkeit wird aber nützlicher, sobald Sie mit Datenbanken zu tun haben.

324

Das Objektmodell von ADO.NET

9.5

Das Objektmodell von ADO.NET

Nun ist es an der Zeit, mit einer Datenbank zu kommunizieren. In den folgenden Abschnitten betrachten Sie die Objekte im ADO.NET-Gerüst. Um mit Daten in einer Windows Forms-Anwendung zu interagieren, befolgen Sie diese fünf allgemeinen Schritte: 1. Erstellen Sie ein Objekt für eine Datenbankverbindung. 2. Öffnen Sie die Datenbankverbindung. 3. Füllen Sie ein DataSet mit den gewünschten Daten. 4. Richten Sie (optional) ein DataView-Objekt für die Datenanzeige ein. 5. Binden Sie ein Steuerelement an das DataSet oder die DataView. Da Sie schon gestern den fünften Schritt gründlich untersucht haben, konzentrieren Sie sich heute auf die ersten vier. Das erfolgt in den nächsten Abschnitten. Sie werden zwei verschiedene Objekttypen verwenden. Eine Menge ist ausschließlich für SQL Server reserviert (Sie können das den SQL-Provider nennen), und die andere ist für alles andere bestimmt (Sie können das den OLE DB-Provider nennen). Der OLE DB-Provider funktioniert auch mit dem SQL Server, doch der SQL-Provider nutzt einige spezielle Charakteristika von SQL Server, die ihn effizienter machen. Die zwei verschiedenen Objektmengen werden jeweils durch die Präfixe Sql oder OleDB gekennzeichnet. Meist können Sie zwischen den beiden wechseln, indem Sie einfach das Präfix austauschen. Alle Eigenschaften und Methoden sind fast identisch. In diesem Buch konzentrieren wir uns auf den SQL-Provider. Bevor wir Code schreiben, wollen wir einen Blick auf die ADO.NET-Steuerelemente werfen, die wir einsetzen: 쐽

SqlConnection-Objekt: Dieses Steuerelement stellt eine Datenbankverbindung dar.

쐽

SqlDataAdapter-Objekt: Dieses Mehrzweckwerkzeug dient der Kommunikation mit

einer Datenbank nach dem Aufbau einer Verbindung (etwa um Daten abzurufen, einzufügen oder zu aktualisieren). 쐽

SqlCommand-Objekt: Dieses Steuerelement stellt einen einzelnen von SqlAdapter

erzeugten Befehl dar. Das Objekt enthält Informationen über das SQL-Statement, das Sie auszuführen versuchen, und ist eng mit dem SqlAdapter verknüpft. 쐽

DataSet: Das kennen Sie schon: die unverbundene Darstellung einer Datenbank.

325

ADO.NET einsetzen

Die Schritte 1 und 2 sind mit dem SqlConnection-Objekt verbunden, während Schritt 3 mit den Objekten SqlDataAdapter und SqlCommand arbeitet. Sie werden alle diese Objekte gleich einsetzen.

Verbindung zur Datenbank aufnehmen und Daten abrufen Die Datenbankverbindung wird mit Hilfe des SqlConnection-Objekts gehandhabt (oder auch OleDBConnection, je nach Präfix). Alles was Sie dazu brauchen ist eine Verbindungszeichenfolge (Connection String) – eine Zeichenfolge, die .NET mitteilt, wo sich die Datenbank befindet, um welchen Datenbanktyp es sich handelt, welche Version das ist usw. Dieser Verbindungszeichenfolge ist jedoch allgemein gehalten, so dass Sie sie nach dem ersten Erstellen nicht noch einmal schreiben müssen. Je nach der verwendeten Datenbank ändert sich die Zeichenfolge. Das folgende Stück Code zeigt Beispielzeichenfolgen für SQL Server und Access: //SQL Server "Initial Catalog=TYWinforms;Data Source=localhost;" //Access, C# "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + "C:\\winforms\\data\\TYWinforms.mdb;User ID=blah;Password=blah"; //Access, VB .NET "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" & _ "C:\\winforms\\data\\TYWinforms.mdb;User ID=blah;Password=blah";

In C# besitzt das Backslash-Zeichen (\) eine besondere Bedeutung, daher muss man ihm einen weiteren Backslash voranstellen, um diese besondere Bedeutung zu unterdrücken und literales Zeichen darzustellen. VB .NET hingegen kennt solche Einschränkungen nicht. Als Nächstes müssen Sie mit der Verbindungszeichenfolge ein SqlConnection-Objekt erzeugen: String strConn = "Initial Catalog=TYWinforms;Data Source=localhost;"; SqlConnection objConn = new SqlConnection(strConn);

Der nächste Schritt besteht im Füllen des DataSets mit den gewünschten Daten. Dafür müssen Sie ein paar SQL-Statements schreiben. Listing 9.1 zeigt eine einfache Anwendung, die diese Statements schreibt und die Daten daraufhin in einem DataGrid anzeigt.

326

Das Objektmodell von ADO.NET

Listing 9.1: Auf eine Datenbank (tblUsers) zugreifen 1: using System; 2: using System.Windows.Forms; 3: using System.Drawing; 4: using System.Data; 5: using System.Data.SqlClient; 6: 7: namespace TYWinforms.Day9 { 8: public class Listing91 : Form { 9: DataGrid dgData = new DataGrid(); 10: DataSet objDS = new DataSet(); 11: 12: public Listing91() { 13: String strConn = "Initial Catalog=TYWinforms;DataSource=localhost;User ID=sa"; 14: SqlConnection objConn = new SqlConnection(strConn); 15: 16: SqlDataAdapter objCmd = new SqlDataAdapter("SELECT * FROM tblUsers", objConn); 17: objCmd.Fill(objDS, "tblUsers"); 18: 19: dgData.DataSource = objDS; 20: dgData.DataMember = "tblUsers"; 21: dgData.Dock = DockStyle.Fill; 22: 23: this.Controls.Add(dgData); 24: } 25: 26: public static void Main() { 27: Application.Run(new Listing91()); 28: } 29: } 30: }

Sie sollten die Angabe localhost in Zeile 13 Ihrer eigenen Installation von SQL Server anpassen. Die Standardeinstellung localhost könnte zwar funktionieren, doch Sie sollten dies auf jeden Fall noch einmal im SQL Enterprise Manager prüfen. SQL Server lässt sich für folgende Arten von Anmeldekonten konfigurieren: Windows NT/2000-Konten (Windows-Authentifizierung), SQL Server-Konten (SQL Server-Authentifizierung) oder beide Kontenarten (gemischter Modus). "sa" ist das SQL Server-Konto für den Systemadministrator. Ist Ihr SQL Server jedoch auf Windows-Authentifizierung eingestellt, sollten Sie eine Verbin-

327

ADO.NET einsetzen

dungszeichenfolge wie die folgende verwenden, die dann Ihr Windows NT/ 2000-Konto (statt Ihr SQL Server-Konto) verwendet, um Sie zu authentifizieren: "Initial Catalog=TYWinforms;Data Source=localhost;Trusted_Connection=true;";

Beachten Sie zunächst die Integration der Namensräume System.Data und System.Data.SqlClient (Letzterer hieße System.Data.OleDBClient, falls Sie mit dem OLE DB-Provider arbeiten). Sie sind für die verschiedenen Datenverbindungsobjekte notwendig. In den Zeilen 13 und 14 erstellen Sie die Verbindungszeichenfolge und das SqlConnection-Objekt. In Zeile 16 wird Ihnen das SqlDataAdapter-Objekt vorgestellt. Es ist ein Mehrzweckwerkzeug für Datenbanken; es kann SQL-Statements ausführen, Daten zurückgeben und DataSets füllen. Sie verwenden es hier, um ein SELECT-Statement auszuführen und das DataGrid-Steuerelement zu füllen. Der Konstruktor für dieses Objekt übernimmt zwei Parameter: Der erste besteht aus dem auszuführenden SELECT-Statement (hier holen Sie einfach alle Datensätze aus der Tabelle tblUsers) und der zweite aus dem SqlConnection-Objekt, das den SqlDataAdapter darüber informiert, wo er nach den Daten suchen soll. (Mehr dazu gleich.) In Zeile 17 rufen Sie die Fill-Methode auf. Sie ist recht interessant, führt sie doch im Grunde das ihr zugeleitete SELECT-Statement aus, erstellt ein DataTable-Objekt, dessen Zeilen das Ergebnis des SELECT-Statements sind, und steckt diese DataTable in ein DataSet. Die zwei Parameter dieser Methode sind das DataSet, um dort die gelieferten Ergebnisse zu platzieren, und der Name der erstellten DataTable.

Abbildung 9.8: Ihr gebundenes DataGrid zeigt die Informationen aus der Datenbank an.

328

Das Objektmodell von ADO.NET

Der Rest des Codes bindet Daten an das DataGrid; es dürfte Ihnen noch von gestern bekannt sein. Sie setzen die Eigenschaft DataSource auf das neu gefüllte DataSet und die DataMember-Eigenschaft auf die im DataSet enthaltene DataTable. Wenn Sie das DataMember nicht näher bestimmen, zeigt das DataGrid die Objekte im DataSet und nicht die Daten an (anders ausgedrückt erscheint in der Tabelle »tblUsers« anstelle der Benutzer). Ihrer Anwendung Datenbankfunktionen hinzuzufügen, ist also recht einfach und erfordert lediglich fünf bis sechs Zeilen Code. Listing 9.1 produziert das in Abbildung 9.8 gezeigte Ergebnis.

Daten bearbeiten Mit dem SqlDataAdapter können Sie zudem Daten bearbeiten, wobei die Statements UPDATE, INSERT und DELETE verwendet werden können. Es stehen verschiedene Eigenschaften extra für diese Befehle bereit. Der SqlDataAdapter verfügt über die Eigenschaften UpdateCommand, InsertCommand, DeleteCommand und SelectCommand. SelectCommand wird im Konstruktor gefüllt (Zeile 16 von Listing 9.1) und ausgeführt, sobald die Fill-Methode aufgerufen wird. Die anderen Eigenschaften werden ausgeführt, wenn die Update-Methode des SqlDataAdapters aufgerufen wird, doch dabei gibt es einen Haken. Diese Statements kommen nur dann zur Ausführung, wenn sich bereits Daten im zugrunde liegenden DataSet geändert haben. Nehmen Sie an, Sie wollen sämtliche Vorkommen des Namens Christopher in der Benutzer-Datenbank in Chris ändern. Theoretisch könnten Sie eine UpdateCommand-Eigenschaft wie die folgende verwenden: objCmd.UpdateCommand = new SqlCommand("Update tblUsers SET VorName = 'Chris' WHERE VorName = 'Christopher'); objCmd.Update();

Sie erstellen ein neues SqlCommand-Objekt, übergeben ihm das passende UPDATE-Statement und rufen dann die Update-Methode zwecks Ausführung des Statements auf. Theoretisch sollte dieses Vorgehen zuerst das DataSet aktualisieren und dann die Änderungen zurück in die Datenbank schreiben. Es funktioniert aber nicht wie erwartet. Im Wesentlichen diktiert dieses Statement, auf welche Weise Änderungen im DataSet in die Datenbank zurückgeschrieben werden sollen. Die Update-Methode prüft das DataSet, um festzustellen, ob sich Werte geändert haben. Ist das nicht der Fall, passiert nichts. Andernfalls nimmt der SqlDataAdapter nur die geänderten Datensätze, führt das SQLStatement an ihnen aus und schreibt die Ergebnisse zurück in die Datenbank. Im obigen Codestück würde der vom Benutzer geänderte Christopher-Datensatz in der Datenbank zu Chris aktualisiert werden, ungeachtet des Wertes, den der Benutzer wirklich

329

ADO.NET einsetzen

geändert hat (weil es das UPDATE-Statement eben so festlegt). Würde der Benutzer einen anderen Datensatz ändern, der Christopher nicht enthielte, würde nichts passieren (weil die WHERE-Bedingung im UPDATE-Statement diese Datensätze ausschließt). Dieses Vorgehen ist mühselig. Will man Daten ändern, muss man sie erst von Hand im DataSet ändern und dann ein passendes SQL-Statement schreiben, das die Änderungen

zurück in die Datenbank schreibt. Das ist zeitraubend und obendrein fehlerträchtig. Zum Glück stellt ADO.NET ein Objekt namens SqlCommandBuilder zur Verfügung, das all diese SQL-Befehle automatisch für Sie erstellt. Wenn also der Benutzer im DataGrid ein Feld ändert, brauchen Sie sich nicht um die auszuführenden SQL-Befehle zu kümmern. Sie rufen nur die Update-Methode auf, fertig. Um dieses Objekt zu verwenden, fügen Sie die folgende Zeile nach Zeile 17 in Listing 9.1 ein: SqlCommandBuilder objBuilder = new SqlCommandBuilder(objCmd);

Diese Zeile erzeugt ein SqlCommandBuilder-Objekt für den bereits erstellten SqlDataAdapter. Das Objekt fungiert als Wachhund: Es beobachtet alles, was bei den Daten vor sich geht und erzeugt rasch ohne Ihr Zutun die passenden SQL-Befehle. Wir wollen die Daten in Listing 9.1 editierbar machen. Fügen Sie zuerst dem CurrentCellChanged-Ereignis des DataGrid-Steuerelements einen Delegaten hinzu, damit Sie wissen, wann der Benutzer mit dem Bearbeiten einer Zelle fertig ist: dgData.CurrentCellChanged += new EventHandler (this.UpdateData);

Dann fügen Sie den Ereignishandler hinzu, der einfach die Update-Methode des SqlDataAdapters aufruft: public void Update(Object Sender, EventArgs e) { objCmd.Update(objDS, "tblUsers"); }

Sofern Sie bereits den SqlCommandBuilder erstellt haben, schreibt dieses Statement alle Änderungen am DataSet (via DataGrid) in die Datenbank zurück, so dass sie zu dauerhaften Änderungen werden. Der erste Parameter ist das betreffende DataSet und der zweite die DataTable im DataSet, in der Änderungen erfolgen. Kompilieren Sie diese Anwendung neu und führen Sie sie aus. Jede von Ihnen vorgenommene Änderung wird nun automatisch in die Datenbank zurückgeschrieben. Um dies zu testen, ändern Sie ein paar Einträge und schließen dann die Anwendung. Sie können sie wieder öffnen, um zu sehen, ob die Änderungen permanent sind, oder Sie können die Datenbankanwendung (SQL Server oder Access) direkt öffnen, um die Änderungen zu sehen. Diese Einsatzweise des SqlCommandBuilder-Objekts funktioniert nur dann, wenn die zurückgegebenen Daten einen Primärschlüssel enthalten. Beim Aufbau der Tabelle tblUsers haben Sie den Primärschlüssel auf das Feld UserID gesetzt. Dementsprechend können Sie den Primärschlüssel per Programmcode unter Verwendung Ihres DataTable-Objekts setzen:

330

Das Objektmodell von ADO.NET

DataColumn[] arrKeys = {myTable.Columns["Spalte A"]}; myTable.PrimaryKey = arrKeys;

Die PrimaryKey-Eigenschaft der DataTable übernimmt ein Array von DataColumn-Objekten, weshalb Sie in diesem Codestück ein Array erstellen. Außerdem muss das SelectCommand zuerst mit einem SELECT-Statement gefüllt werden. Ihre Datenbankanwendung ist nunmehr voll funktionsfähig. Sie können Daten anzeigen, Benutzer können diese ändern und die Datenbank wird aktualisiert. Wir wollen uns ein weiteres Beispiel ansehen, das in Listing 9.2 abgedruckt ist. Diesmal verwenden Sie kein DataGrid-Steuerelement zur Datenanzeige, sondern vielmehr einige Textfelder, die nur einen Datensatz auf einmal anzeigen. Sie stellen Schaltflächen bereit, damit Benutzer durch die Datensätze navigieren können, sowie eine SPEICHERN-Schaltfläche, mit der die Benutzer Änderungen in die Datenbank schreiben können. Listing 9.2: Eine etwas komplexere Datenbankanwendung 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:

using using using using using

System; System.Windows.Forms; System.Drawing; System.Data; System.Data.SqlClient;

namespace TYWinforms.Day9 { public class Listing92 : Form { DataSet objDS = new DataSet("tblUsers"); SqlDataAdapter objCmd; TextBox tbFirstName = new TextBox(); TextBox tbLastName = new TextBox(); Label lblFirstName = new Label(); Label lblLastName = new Label(); Button btNext = new Button(); Button btPrev = new Button(); Button btSave = new Button(); public Listing92() { lblFirstName.Location = new Point(10,10); lblFirstName.Text = "VorName: "; lblLastName.Location = new Point(10,35); lblLastName.Text = "NachName: "; tbFirstName.Location = new Point(75,10); tbLastName.Location = new Point(75,30); btNext.Text = "Nächster";

331

ADO.NET einsetzen

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: 66: 67: 68: 69: 70: 71: 72: 73:

332

btNext.Location = new Point(150,75); btNext.Click += new EventHandler(this.MoveNext); btPrev.Text = "Voriger"; btPrev.Location = new Point(10,75); btPrev.Click += new EventHandler(this.MovePrev); btSave.Text = "Speichern"; btSave.Location = new Point(75,125); btSave.Click += new EventHandler(this.Save); String strConn = "Initial Catalog=TYWinforms;DataSource=localhost;User ID=sa"; SqlConnection objConn = new SqlConnection(strConn); objCmd = new SqlDataAdapter("SELECT * FROM tblUsers", objConn); objCmd.Fill(objDS, "tblUsers"); SqlCommandBuilder objBuilder = new SqlCommandBuilder(objCmd); tbFirstName.DataBindings.Add("Text", objDS, "tblUsers.VorName"); tbLastName.DataBindings.Add("Text", objDS, "tblUsers.NachName"); this.Controls.Add(tbFirstName); this.Controls.Add(tbLastName); this.Controls.Add(lblFirstName); this.Controls.Add(lblLastName); this.Controls.Add(btNext); this.Controls.Add(btPrev); this.Controls.Add(btSave); } private void Save(Object Sender, EventArgs e) { this.BindingContext[objDS, "tblUsers"].EndCurrentEdit(); objCmd.Update(objDS, "tblUsers"); } private void MoveNext(Object Sender, EventArgs e) { this.BindingContext[objDS, "tblUsers"].Position += 1; } private void MovePrev(Object Sender, EventArgs e) { this.BindingContext[objDS, "tblUsers"].Position -= 1; } public static void Main() {

Das Objektmodell von ADO.NET

74: 75: 76: 77:

Application.Run(new Listing92()); } } }

Listing 9.2 weist eine Menge vielschichtiger Funktionen auf, daher wollen wir es lieber Zeile für Zeile durchgehen. In den Zeilen 1 bis 5 importieren Sie Namensräume. Die Zeilen 9 bis 18 richten die verschiedenen Objekte und Steuerelemente ein, die Sie in der Anwendung verwenden werden. Die Zeilen 21 bis 38 richten diverse Eigenschaften der Formularsteuerelemente ein und weisen ihnen ein paar Delegaten zu. Ab Zeile 40 erstellen Sie eine Datenbankverbindung mit Hilfe der Standardverbindungszeichenfolge. In den Zeilen 43 und 44 setzen Sie ein SqlDataAdapterObjekt ein, um Datensätze aus der Datenbank zu holen und damit ein DataSet zu füllen. In Zeile 45 erzeugen Sie Ihr SqlCommandBuilder-Objekt, um sicherzustellen, dass SQL-Befehle automatisch erzeugt werden, sobald Änderungen in der Tabelle erfolgen. In den Zeilen 47 und 48 binden Sie als Nächstes Elemente der gelieferten Daten mit Hilfe ihrer DataBindings-Eigenschaften an die TextBox-Steuerelemente. Denken Sie daran, dass die drei Parameter für die Add-Methode nacheinander die Eigenschaft der anzubindenden TextBox, das Datenquellenobjekt und das anzubindende Feld in der Datenquelle sind. Die Werte tblUsers.VorName und tblUsers.NachName geben die Spalten für Vor- und Nachnamen in tblUsers an. Würden Sie sie an ein DataGrid binden, könnten Sie einfach tblUsers als Feldname verwenden, doch bei TextBox-Steuerelementen müssen Sie etwas genauer sein. Schließlich wollen Sie nicht mehr als eine Spalte an eine TextBox binden. Gehen wir zu den Ereignishandlern über. Sowohl die MoveNext- und MovePrevMethoden ändern die Position-Eigenschaft des BindingContext-Objekts, damit man in den Datensätzen vor- und zurückblättern kann (Zeilen 66 und 70). Beachten Sie, dass Sie den BindingContext der Form bearbeiten und nicht jede gebundene TextBox einzeln. Wenn Sie das Formular manipulieren, werden alle gebundenen Steuerelemente im Formular ebenfalls modifiziert. Bevor wir die Save-Methode in Zeile 59 untersuchen, schauen wir uns an, was mit der Anwendung passiert. Wenn Sie sie ausführen, sehen Sie Vor- und Nachnamen des ersten Datensatzes in der Datenbank, wie in Abbildung 9.9 zu sehen. Sie können auf die Schaltfläche NÄCHSTER klicken, um zum nächsten Datensatz zu blättern, so dass sich der Text im Textfeld ändert. Die Schaltfläche VORIGER blättert einen Datensatz zurück.

333

ADO.NET einsetzen

Abbildung 9.9: Sie sehen den Vor- und Nachnamen, wenn Sie Daten an die TextBox-Steuerelemente binden.

Wenn Sie Elemente bearbeiten, geht etwas Seltsames im Hintergrund vor sich. Ändert man den Wert in einem der Textfelder, aktualisiert es theoretisch sofort das DataSet; dann können Sie die Update-Methode von SqlDataAdapter aufrufen, um die Änderungen in die Datenbank zurückzuschreiben. Tatsächlich werden die Änderungen am DataSet erst dann vorgenommen, wenn sie BindingContext bestätigt hat. Dies kann an mehreren Stellen erfolgen (dazu gehört das Ändern der Position-Eigenschaft). Jetzt haben wir ein Problem: Angenommen, der Benutzer ändert den Wert des Vornamens im Textfeld und klickt dann auf die Schaltfläche SPEICHERN. Weil der BindingContext noch keine Gelegenheit hatte, die Änderungen abzusegnen, hat sich das DataSet noch nicht geändert – auch die Datenbank wird sich nicht ändern. Sie brauchen eine Möglichkeit, wie Sie BindingContext zwingen können, die Änderungen zu bestätigen, damit das Speichern der Änderungen stattfinden kann. Die EndCurrentEdit-Methode aus Zeile 60 macht genau dies. Sie schreibt alle anstehenden Änderungen in das DataSet, ohne die Position-Eigenschaft ändern zu müssen. Danach können Sie einfach die Update-Methode aufrufen, wie in Zeile 62 zu sehen. Jetzt ist Ihre Anwendung vollständig.

9.6

Andere ADO.NET-Objekte

Bis hierher haben Sie die Objekte SqlDataAdapter und DataSet verwendet, um Datenquellen zu verarbeiten. Obwohl diese Objekte leistungsfähig und notwendig sind, erweisen sie sich für manche Zwecke als weniger geeignet. Das DataSet beispielsweise kann unter Umständen ein recht sperriges Objekt sein, da es ja eine komplette Mini-Datenbank an Informationen zu pflegen hat, inklusive Tabellenstruk-

334

Andere ADO.NET-Objekte

turen, Einschränkungen, Indizes, Beziehungen usw. Zuweilen benötigt man diese Extrafunktionen gar nicht. Um diesen Missstand zu beheben, führt ADO.NET die Objekte SqlDataReader und OleDbDataReader ein. Diese Objekte erhalten nicht ihre eigene Kopie der Datenbank aufrecht, sondern holen vielmehr einen Datensatz nach dem anderen – deshalb erfordern sie eine ständige Verbindung zur Datenbank (anders als der unverbundene Datenspeicher des DataSets). Die DataReader-Objekte weisen daher einen eingeschränkten Funktionsumfang auf; man kann zum Beispiel nicht laufend zwischen Datensätzen hin und her springen, ohne für das ständige Neuholen von Daten einen Preis an Performanz zu zahlen. Um ein DataReader-Objekt nutzen zu können, müssen Sie zuerst die Objekte SqlCommand und OleDbCommand einsetzen. Beide stellen einen an einer Datenbank ausgeführten SQLBefehl dar und können ein Ergebnis liefern oder auch nicht. Sie haben sie bereits eingesetzt. Wenn Sie den SqlDataAdapter-Eigenschaften für das Aktualisieren, Einfügen, Löschen oder Auswählen etwas zuweisen, dann erzeugt .NET für Sie verschiedene SqlCommand-Objekte dafür. Es sind diese hinter den Kulissen agierenden Objekte, die eigentlich die Datenbank abfragen und Ergebnisse liefern; der SqlDataAdapter ist lediglich der Nutznießer ihrer harten Arbeit. Ein SqlCommand-Objekt lässt sich auf verschiedene Art und Weise erstellen. Sie können ihm je nach Bedarf ein SQL-Statement zur Ausführung übergeben, ein SQL-Statement und ein SqlConnection-Objekt oder auch rein gar nichts. Hier ist ein Beispiel: SqlCommand objCmd = new SqlCommand("SELECT *FROM tblUsers"); //oder SqlCommand objCmd = new SqlCommand("SELECT *FROM tblUsers", objConn); //oder SqlCommand objCmd = new SqlCommand();

Stellen Sie nicht einen oder mehrere dieser Werte während der Instantiierung des Objekts bereit, so können Sie dies mit Hilfe der Eigenschaften CommandText und Connection durchführen. Sobald Sie Ihr SqlCommand-Objekt haben, können Sie einen SQL-Befehl auf unterschiedliche Weise ausführen. Wenn Ihre Abfrage keine Daten liefert (etwa bei einem DELETE-Statement), dann können Sie die Methode ExecuteNonQuery verwenden: SqlCommand objCmd = new SqlCommand("DELETE FROM tblUsers ", objConn); objCmd.ExecuteNonQuery();

Liefert Ihre Abfrage einen Einzelwert, lässt sich die ExecuteScalar-Methode einsetzen. Sie holt die erste Spalte der ersten Zeile in den gelieferten Ergebnissen – so wie in diesem Beispiel: SqlCommand objCmd = new SqlCommand("SELECT COUNT(*)FROM tblUsers", objConn); int intCount = (int)objCmd.ExecuteScalar();

Wollen Sie Ihre Daten als XML geliefert bekommen, können Sie die ExecuteXmlReaderMethode einsetzen, die ein XmlReader-Objekt zurückgibt.

335

ADO.NET einsetzen

Wenn Sie schließlich Ihre Daten mit Hilfe eines SqlDataReader-Objekts verarbeiten wollen, steht dafür die ExecuteReader-Methode bereit: SqlDataReader objReader; SqlCommand objCmd = new SqlCommand("SELECT *FROM tblUsers ", objConn); objReader = objCmd.ExecuteReader();

Die einfache Anwendung in Listing 9.3 verwendet SqlDataReader, um die Ergebnisse aus einer Datenbank anzuzeigen. Listing 9.3: Die Verwendung eines SqlDataReaders 1: using System; 2: using System.Windows.Forms; 3: using System.Drawing; 4: using System.Data; 5: using System.Data.SqlClient; 6: 7: namespace TYWinforms.Day9 { 8: public class Listing93 : Form { 9: Label lblData = new Label(); 10: 11: public Listing93() { 12: lblData.Dock = DockStyle.Fill; 13: 14: String strConn = "Initial Catalog=TYWinforms;DataSource=localhost;User ID=sa"; 15: SqlConnection objConn = new SqlConnection(strConn); 16: objConn.Open(); 17: 18: SqlDataReader objReader; 19: SqlCommand objCmd = new SqlCommand("SELECT UserID, FirstName FROM tblUsers", objConn); 20: objReader = objCmd.ExecuteReader(); 21: 22: while (objReader.Read()) { 23: lblData.Text += objReader.GetInt32(0) + ": " + objReader.GetString(1) + "\n"; 24: } 25: 26: objReader.Close(); 27: objConn.Close(); 28: 29: this.Controls.Add(lblData); 30: } 31:

336

Andere ADO.NET-Objekte

32: 33: 34: 35: 36:

public static void Main() { Application.Run(new Listing93()); } } }

In den Zeilen 14 und 15 legen Sie ganz normal mit der Erzeugung eines SqlConnection-Objekts los. In Zeile 16 müssen Sie die Verbindung mit Hilfe der Open-Methode öffnen. Verwenden Sie den SqlDataAdapter, ist dieser Schritt nicht erforderlich, doch der SqlDataReader benötigt ja eine offene Verbindung, um arbeiten zu können. Die Zeilen 18 bis 20 erstellen ein SqlDataReaderObjekt sowie ein SqlCommand-Objekt mit einer SQL-Abfrage, bevor sie die ExecuteReader-Methode aufrufen, um die Abfrageergebnisse im Reader abzulegen. Die Read-Methode von SqlDataReader springt so lange zum nächsten Datensatz in der Ergebnismenge, bis deren Ende erreicht ist, woraufhin sie dann false zurückgibt. Daher verwendet man in Zeile 22 eine while-Schleife, um so alle Datensätze im Reader zu durchlaufen. Sobald das Ende der Datensätze erreicht ist, endet die while-Schleife. Das SqlDataReader-Objekt verfügt über eine Reihe von Get-Methoden, die die Werte aus der Ergebnismenge holen. Welche Methode sie genau benutzen, hängt jeweils vom zu erwartenden Datentyp ab. So liefert beispielsweise die GetString-Methode einen Zeichenfolgenwert und GetInt32 einen Integerwert. Diese Methoden übernehmen alle einen einzelnen Parameter, der angibt, welches Feld (bzw. welche Spalte) des aktuellen Datensatzes geliefert werden soll. In Zeile 23 holen Sie die ersten und zweiten Spaltenwerte jedes Datensatzes, wobei es sich um UserID und VorName aus der Tabelle tblUsers handelt. Nachdem alle Datensätze durchlaufen wurden, sorgen Sie für das Schließen des Readers und der SqlConnection-Objekte, indem Sie deren jeweilige Close-Methode verwenden, wie in den Zeilen 26 und 27 zu sehen. Listing 9.3 produziert das in Abbildung 9.10 gezeigte Ergebnis.

Abbildung 9.10: Sie können mit dem SqlReader-Objekt durch Datensätze blättern.

337

ADO.NET einsetzen

Ich empfehle

Bitte beachten Sie

Verwenden Sie einen SqlDataReader, wenn Sie Setzen Sie den SqlDataReader nicht ein, wenn Daten nur anzeigen, aber nicht bearbeiten wollen. Sie dem Benutzer gestatten wollen Daten zu bearbeiten oder wenn Sie komplexe Operationen mit diesen Daten ausführen müssen (wie etwa das Bearbeiten der Tabellenbeziehungen). Verwenden Sie dann statt dessen SqlDataAdapter oder DataSet.

Parametrisierte Abfragen und gespeicherte Prozeduren Eine gespeicherte Prozedur ist eine Reihe von einem oder mehreren SQL-Statements, die außerhalb einer Anwendung vordefiniert wird. In der Datenbank hat sie ihren Platz neben den Tabellen. Sie werden für Ihre Datenbankinteraktionen häufig gespeicherte Prozeduren einsetzen. Sie sind schneller als normale SQL-Statements, denn sie werden kompiliert. Sie tragen zudem dazu bei, dass Ihre Anwendung leichter zu pflegen ist: Wenn sich Ihre Datenanforderungen ändern sollten, gestaltet sich das Aktualisieren der gespeicherten Prozeduren weitaus einfacher, als die Abfragen in Ihrer Anwendung umzuschreiben und sie neu zu kompilieren. In Access werden gespeicherte Prozeduren als Abfragen bezeichnet; sie verwenden eine etwas andere Syntax als die in SQL Server. In diesem Buch beschränken wir uns auf gespeicherte Prozeduren in SQL Server. Um in SQL Server eine gespeicherte Prozedur zu erstellen, öffnen Sie den Enterprise Manager und expandieren die Liste der Datenbanken so weit, bis Sie den Abschnitt GESPEICHERTE PROZEDUREN unterhalb der TYWinforms-Datenbank sehen. Rechtsklicken Sie auf diesen Abschnitt und wählen Sie NEUE GESPEICHERTE PROZEDUR aus. Für unsere Zwecke wollen wir alles etwas einfacher halten. Tippen Sie den folgenden Code in das nun erscheinende Fenster: CREATE PROCEDURE qryGetUser (@intUserID int ) AS SELECT *FROM tblUsers WHERE UserID =@intUserID

Ihr Fenster sollte so aussehen wie das in Abbildung 9.11. Diese Abfrage liefert die kompletten Informationen über einen bestimmten Benutzer, wie durch die Verwendung der Benutzer-ID deutlich gemacht wird. Elegant an dieser Abfrage ist, dass die Benutzer-ID variieren kann: Die Abfrage akzeptiert einen Parameter namens @intUserID, den Ihre Anwendung bereitstellen muss, um die richtigen Ergebnisse zu erhalten. Sehen wir uns an, wie man diesen Parameter bereitstellen kann.

338

Andere ADO.NET-Objekte

Abbildung 9.11: Benutzen Sie dieses Fenster, um in SQL Server eine gespeicherte Prozedur zu erstellen.

Alle Parameter müssen Teil eines SqlCommand-Objekts sein (das bedeutet, dass Sie entweder einen SqlDataAdapter und ein DataSet oder einen SqlDataReader einsetzen, um Ihre Daten abzurufen). Mit Hilfe der oben erstellten gespeicherten Prozedur qryGetUser erzeugt das folgende Stück Code ein SqlCommand-Objekt mit den notwendigen Parametern: SqlCommand objQuery = new SqlCommand("qryGetUser ", objConn); objQuery.CommandType = CommandType.StoredProcedure; objQuery.Parameters.Add("@intUserID ", SqlDbType.Int, 4).Value = 1;

Die Deklaration des SqlCommand-Objekts beginnt wie üblich, mit einer Ausnahme: Statt der auszuführenden SQL-Anweisung übergeben Sie dem Objekt den Namen der gespeicherten Prozedur. In der zweiten Zeile müssen Sie die CommandType-Eigenschaft auf den StoredProcedure-Wert der CommandType-Aufzählung setzen. Andere Werte in dieser Aufzählung sind Text (der Standardwert, der bei Übergabe einer SQL-Anweisung verwendet wird) und TableDirect, welcher einfach die Struktur einer Tabelle liefert (dieser letzte Wert funktioniert nur im Zusammenspiel mit einem OLE DB-Provider). Zum Schluss fügen Sie der Parameters-Eigenschaft des SqlCommand-Objekts einen neuen Parameter hinzu. Der erste Parameter für die Add-Methode ist der Name des erwarteten Parameters in der gespeicherten Prozedur; er muss den gleichen Namen tragen wie in der gespeicherten Prozedur. Der zweite Parameter gibt den Datentyp des Parameters an; Tabelle 9.4 führt die möglichen Werte der SqlDbType-Aufzählung auf. Der dritte Wert gibt die Größe an (dieser Wert wurde beim Erstellen der Tabelle gesetzt; er braucht nicht exakt genau zu sein). Mit Hilfe der Value-Eigenschaft setzen Sie dann den Wert fest, den der Parameter der gespeicherten Prozedur verwenden soll. In unserem Fall läuft es darauf hinaus, dass Sie die Informationen für den Benutzer mit der Benutzer-ID 1 zurückerhalten.

339

ADO.NET einsetzen

SqlDbType-Wert

Entsprechender .NET-Typ

BigInt

Int64

Binary

Array des Typs Byte

Bit

Boolean

Char

String

DateTime

DateTime

Decimal

Decimal

Float

Double

Image

Array des Typs Byte

Int

Int32

Money

Decimal

NChar

String

NText

String

NVarChar

String

Real

Single

SmallDateTime

DateTime

SmallInt

Int16

SmallMoney

Decimal

Text

String

Timestamp

DateTime

TinyInt

Byte

UniqueIdentifier

Guid

VarBinary

Array des Typs Byte

VarChar

String

Variant

Object

Tabelle 9.4: Werte der SqlDbType-Aufzählung

340

Andere ADO.NET-Objekte

Da Sie nun ein SqlCommand-Objekt inklusive Parametern haben, können Sie damit tun, was Sie wollen. Um beispielsweise Daten für einen SqlDataReader zurückzuerhalten, verwenden Sie folgenden Code: SqlDataReader objReader; objReader = objQuery.ExecuteReader();

Wenn Sie hingegen ein DataSet füllen wollen, setzen Sie folgenden Code ein: DataSet objDS = new DataSet(); SqlDataAdapter objCmd = new SqlDataAdapter(); objCmd.SelectCommand = objQuery; objCmd.Fill(objDS, "tblUsers ");

Im zweiten Codestück weisen Sie das SqlCommand-Objekt der SelectCommand-Eigenschaft des SqlDataAdapters zu. Je nachdem, was die gespeicherte Prozedur eigentlich bewirkt, hätten Sie statt dessen auch die UpdateCommand-, InsertCommand- oder DeleteCommand-Eigenschaften angeben können. Es gibt eine Alternative: Bei Verwendung des SqlDataAdapters brauchen Sie nicht zwingend ein separates SqlCommand-Objekt anzulegen. Sie können auf den notwendigen Befehl auch aus der SelectCommand-Eigenschaft heraus verweisen: SqlDataAdapter objCmd = new SqlDataAdapter("qryGetUser ",objConn); objCmd.SelectCommand.CommandType = CommandType.StoredProcedure; objCmd.SelectCommand.Parameters.Add("@intUserID ", SqlDbType.Int, 4).Value = 1;

Das Objekt DataView Eine DataView ist die benutzerdefinierte Ansicht einer DataTable. Sie können also eine vorhandene mit Daten gefüllte DataTable auswählen und sie mit Filtern Ihren Wünschen anpassen. Dafür brauchen Sie also weder Ihre DataTable zu ändern noch Ihre Datenbank laufend neu abzufragen: Es ist einfach eine gefilterte Ansicht. Sie können die DataView an die Steuerelemente in Windows Forms binden. Eine DataView erstellen Sie ganz einfach, indem Sie ihr die anzupassende Tabelle mitteilen: DataView myView = new DataView (objDS.Tables["tblUsers"]);

Sie können die RowFilters-Eigenschaft für das Filtern der Ergebnisse einsetzen; im Grunde funktioniert diese Eigenschaft wie die WHERE-Klausel in einem SQL-Statement. Das folgende Statement würde zum Beispiel nur diejenigen Datensätze zur Anzeige bringen, in denen das VorName-Feld das Wort »Christopher« enthält. myView.RowFilter = "VorName = 'Christopher'";

341

ADO.NET einsetzen

Die Sort-Eigenschaft der DataView, mit der Sie die Sortierreihenfolge der Daten ändern können, folgt der gleichen Syntax wie ORDER BY in SQL-Befehlen: myView.Sort = "VorName ASC, NachName DESC";

Die RowStateFilter-Eigenschaft filtert Datensätze gemäß ihrem aktuellen Status, beispielsweise, ob sie bearbeitet wurden, unverändert geblieben sind oder hinzugefügt wurden: myView.RowStateFilter = DataViewRowState.Unchanged;

Diese Werte lassen sich mit Hilfe des Operators | verknüpfen (OR in VB .NET). Die möglichen Werte in der DataViewRowState-Aufzählung lauten wie folgt: 쐽

Added: Gibt an, dass die Zeile neu ist.

쐽

CurrentRows: Schließt unveränderte, neue und bearbeitete Zeilen mit ein.

쐽

Deleted: Gibt eine gelöschte Zeile an.

쐽

ModifiedCurrent: Gibt den aktuellen Wert aller Zeilen an, nachdem eine beliebige

Zeile geändert wurde. 쐽

ModifiedOriginal: Gibt den ursprünglichen Wert aller Zeilen an, nachdem eine beliebige Zeile geändert wurde.

쐽

None: Gibt Zeilen an, die keinen Status haben.

쐽

OriginalRows: Gibt alle ursprünglichen Zeilen an, darunter auch die unveränderten

und gelöschten Zeilen. 쐽

Unchanged: Gibt eine unveränderte Zeile an.

Sie können die Art und Weise steuern, wie der Benutzer mit der DataView interagiert, indem Sie die Eigenschaften AllowDelete, AllowEdit und AllowNew verwenden. Da die DataView als Operationsbasis ein DataTable-Objekt benötigt, können Sie eine DataView nicht zusammen mit einem SqlDataReader-Objekt einsetzen. Nutzen Sie statt dessen die Objekte DataSet und SqlDataAdapter.

9.7

XML im Zusammenhang mit ADO.NET

ADO.NET ist eng mit XML verzahnt. ADO.NET verwendet XML in sämtlichen Transaktionen, so dass es vielseitiger verwendbar und effizienter wird. Sie können folglich leicht von ADO.NETs Kernobjekt, dem DataSet, zu XML gelangen und umgekehrt. Die meisten der XML-bezogenen Funktionen, die Sie mit ADO.NET ausführen wollen, lassen sich mit nur zwei Methoden bewerkstelligen: ReadXml und GetXml. Die erste lädt

342

XML im Zusammenhang mit ADO.NET

XML aus jedem beliebigen XML-basierten Objekt (etwa einer Textdatei, aus einem Datenstrom, einem XML-Dokument usw.) und legt die Ergebnisse in einem DataSet ab. Die zweite Methode nimmt umgekehrt Daten aus einem DataSet und liefert eine Zeichenfolge, die den XML-Code enthält, der die Daten darstellt. Wir wollen uns ein konkretes Beispiel ansehen. Listing 9.4 zeigt das XML-Codestück vom Kapitelanfang: Listing 9.4: XML-Beispieldaten 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12:

<Users> <User> Chris Payne <UserID>1 27. Juni <User> Eva Payne <UserID>2 15. Juli

Speichern Sie Listing 9.4 als Sample.xml im Ordner C:\winforms\data. Dieser XML-Code präsentiert eine Datenbank namens Users mit einer Tabelle namens User. Diese Tabelle umfasst drei Spalten: Name, UserID und Geburtsdatum. Als Nächstes zeigt Listing 9.5 eine einfache Anwendung, die die XML-Daten lädt und bindet. Listing 9.5: XML-Daten mit ADO.NET binden 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15:

using using using using using

System; System.Windows.Forms; System.Drawing; System.Data; System.Data.SqlClient;

namespace TYWinforms.Day9 { public class Listing95 : Form { DataSet objDS = new DataSet(); TextBox tbName = new TextBox(); TextBox tbGeburtsdatum = new TextBox(); Label lblName = new Label(); Label lblGeburtsdatum = new Label();9

343

ADO.NET einsetzen

16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38: 39:

public Listing95(){ lblName.Location = new Point(10,10); lblName.Text = "Name: "; lblGeburtsdatum.Location = new Point(10,35); lblGeburtsdatum.Text = " Geburtsdatum: "; tbName.Location = new Point(75,10); tbGeburtsdatum.Location = new Point(75,30); objDS.ReadXml("c:\\winforms\\data\\sample.xml"); tbName.DataBindings.Add("Text ", objDS, "User.Name "); tbGeburtsdatum.DataBindings.Add("Text ", objDS, "User.Geburtsdatum "); this.Controls.Add(tbName); this.Controls.Add(tbGeburtsdatum); this.Controls.Add(lblName); this.Controls.Add(lblGeburtsdatum); } public static void Main(){ Application.Run(new Listing95()); } } }

Der Großteil dieses Codes initialisiert die Benutzeroberfläche. Interessant wird es erst ab Zeile 24, in der Sie die ReadXml-Methode zum Laden einer Datei einsetzen. Der Parameter zeigt den Pfad zur fraglichen Datei an. In den Zeilen 26 und 27 binden Sie ganz normal die zwei TextBox-Steuerelemente. Sorgen Sie jedoch dafür, dass der dritte Parameter die Struktur des XML-Dokuments richtig widerspiegelt. Listing 9.5 führt zu dem in Abbildung 9.12 gezeigten Ergebnis. Was passiert nun, wenn die Daten aktualisiert werden? Kann man die Update-Methode aufrufen, um die Änderungen ins XML-Dokument zurückzuschreiben? Leider nicht. Die einzige Möglichkeit, die XML-Quelle zu aktualisieren, besteht darin, explizit eine XML-Datei zu schreiben, doch dieser Vorgang ist zum Glück einfach. Zuerst erstellen Sie ein Objekt XmlDataDocument, um den XML-Code aus dem DataSet zu holen. Dann setzen Sie dessen Save-Methode ein, um die Datei zu schreiben: using System.Xml; ... XmlDataDocument objXml = new XmlDataDocument(objDS); objXml.Save("c:\\winforms \\data \\sample2.xml ");

344

Zusammenfassung

Abbildung 9.12: Sie können die Anwendung in Listing 9.5 verwenden, um XML-Daten anzubinden.

Ein XmlDataDocument-Objekt ist in der XML-Welt das Äquivalent zum SqlDataAdapter. Dieses Objekt ist mit dem DataSet verknüpft, so dass Sie auf einfache Weise vom einen zum anderen gelangen. Die erste Zeile im obigen Codestück instantiiert ein neues XMLDataDocument-Objekt und übergibt ihm das fragliche DataSet. Die Save-Methode schreibt die XML-Daten zum angegebenen Pfad. Das XMLDataDocument weist noch einige weitere nützliche Mitglieder auf, die wir hier aber nicht erörtern werden. Eine komplette Referenz dazu finden Sie in der Dokumentation des .NET Framework SDK.

9.8

Zusammenfassung

Heute haben Sie eine Menge über Datenbanken gelernt: von ihrer Erstellung in Access und SQL Server über den Einsatz parametrisierter gespeicherter Prozeduren bis hin zum Einsatz von XML. Mit ADO.NET kann man auf fast jedes Datenbanksystem mit Hilfe einer einfachen Verbindungszeichenfolge zugreifen, die angibt, wo sich die Daten befinden, welche Erlaubnis für den Zugriff nötig ist usw. Sie haben von SQL-Statements wie SELECT, INSERT, DELETE und UPDATE erfahren. Mit Hilfe dieser Statements können Sie Daten aus jedem Datenbanksystem, das sie unterstützt, holen und bearbeiten. Jedes Statement befolgt eine ähnliche Syntax, so dass man sie leicht alle erlernen kann, sobald man eines kennt. DataSet ist das zentrale Objekt in ADO.NET. Es stellt eine vollständige Mini-Datenbank dar. Wird das DataSet mit den Objekten SqlDataAdapter und OleDbDataAdapter sowie mit

Datenbindung gekoppelt, lassen sich dem Benutzer Daten auf einfache Weise präsentieren. Sobald man die Update-Methode des SqlDataAdapters mit dem SqlCommandBuilderObjekt verknüpft, kann man Änderungen in die Datenbank zurückschreiben, um sie dauerhaft zu speichern.

345

ADO.NET einsetzen

Zusätzlich zum DataSet gibt es die DataReader-Objekte, die zwar effizienter einzusetzen sind, aber einen geringeren Leistungsumfang besitzen. Diese Objekte lassen sich mit Hilfe der ExecuteReader-Methode des SqlCommand-Objekts füllen. Das DataView-Objekt erlaubt Ihnen, die Anzeige Ihrer DataTable-Objekte wirkungsvoll anzupassen, wodurch Ihnen erspart bleibt, mühevoll immer und immer wieder SQL-Statements ausführen zu müssen, sobald Sie Daten filtern wollen. Zum Schluss lernten Sie, wie ADO.NET und das DataSet mit Hilfe der Methoden ReadXml und GetXml auch XML-Daten laden und bearbeiten können. Diese Daten lassen sich genau wie andere Daten binden, Änderungen lassen sich mit Hilfe der Save-Methode des XMLDataDocument-Objekts in die XML-Dateien zurückschreiben.

9.9 F

Kann ich das ADO-Recordset weiterhin mit ADO.NET und dem DataSet verwenden? A

F

Fragen und Antworten Ja. Mit Hilfe der Fill-Methode können Sie ein DataSet mit Daten aus einem Recordset füllen, doch auf Grund von Beschränkungen in ADO geht das nicht auch umgekehrt. Dieser Vorgang erfordert, die ADO-Typbibliotheken in das .NET Framework zu importieren. (Mehr dazu an Tag 14, wenn es um den Einsatz von ActiveX geht.)

Warum sind gespeicherte Prozeduren effizienter als normale SQL-Statements? Sollte ich also statt dessen immer gespeicherte Prozeduren verwenden? A

Gespeicherte Prozeduren sind aus zwei Gründen effizienter. Zum einen sind sie kompiliert und kompilierte Anwendungen sind stets schneller als unkompilierte. Zweitens hat SQL Server einen so genannten »Ausführungsplan«. Wurde eine gespeicherte Prozedur bereits einmal ausgeführt, weiß SQL Server genau, wo er die Daten suchen soll und wie er sie am besten holt. Dieser Ausführungsplan steigert die Ausführungsgeschwindigkeit einer Abfrage enorm. Der Haken dabei ist nur, dass dieser Ausführungsplan bei normalen Abfragen nicht gespeichert wird und SQL Server ihn bei der nächsten Ausführung der Abfrage neu erstellen muss. Die Antwort auf die Frage, ob man gespeicherte Prozeduren stets normalen Abfragen vorziehen sollte, ist umstritten. Die Wahl bleibt Ihnen überlassen. Doch zum Glück gibt es ein paar Richtlinien, um Ihnen dabei zu helfen. Im Allgemeinen verwenden Sie eine gespeicherte Prozedur, wenn 왘

346

Ihre Abfrage über ein einfaches SELECT-Statement hinausgeht. (Je komplizierter ein SQL-Statement, desto höher sein Ressourcenbedarf, besonders dann, wenn kein Ausführungsplan zur Verfügung steht.)

Workshop

F

왘

Sie wissen, dass sich die Abfrage künftig ändern könnte, da sich das Datenmodell ändert.

왘

die Abfrage häufig ausgeführt wird, also häufiger als ein- oder zweimal pro Anwendungsnutzung.

왘

Sie mit einer umfangreichen Datenmenge hantieren müssen.

Kann ich die Daten in einem SqlDataReader binden? A

Leider nicht. Weil der SqlDataReader nur jeweils einen Datensatz aus einer Datenquelle holen kann, können Sie ihn nicht binden. Aus diesem Grund sollten Sie beim DataSet bleiben, wenn Sie den Benutzer Daten bearbeiten lassen wollen.

9.10 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. Schreiben Sie ein SELECT-Statement, das aus der tblUsers-Tabelle nur solche Datensätze holt, in denen der Wert für das Feld UserID zwischen 5 und 10 liegt. 2. Welche Parameter fordert das SqlCommandBuilder-Objekt für seinen Konstruktor? 3. Ein SqlCommandBuilder erzeugt SQL-Befehle nur dann automatisch, wenn ein Primärschlüssel existiert. Warum? 4. Wahr oder falsch? Meist können Sie die Vorsilbe Sql durch OleDb ersetzen, um die Objekte im OLE DB-Provider nutzen zu können. 5. Ist es ausreichend, die DataSource-Eigenschaft eines DataGrid-Steuerelements auf ein gefülltes DataSet zu setzen? 6. Schreiben Sie für ein gegebenes SqlCommand-Objekt namens objCmd ein Statement, das einen Parameter namens @Geburtsdatum mit einem Wert von 1/7/01 hinzufügt. 7. Nennen Sie die Methode, die veranlasst, dass Änderungen sofort in ein DataSet geschrieben werden.

347

ADO.NET einsetzen

Übung Erstellen Sie eine Anwendung, mit der der Benutzer SQL-Statements in ein Textfeld eingeben kann. Sollte das Statement Ergebnisse liefern, legen Sie sie in einem DataSet ab und gestatten Sie dessen Bearbeitung. Kümmern Sie sich nicht darum, ob die Abfrage im richtigen Format eingegeben wird; Fehlerprüfungen werden erst an Tag 21 durchgenommen.

348

MDI-Anwendungen erstellen

0 1

MDI-Anwendungen erstellen

Bis jetzt haben Sie lediglich Anwendungen mit einer Einzeldokumentschnittstelle (Single Document Interface, SDI) erstellt: Sie verfügen nur über eine Schnittstelle, mit der der Benutzer zusammenarbeitet. Bei einer Mehrfachdokumentschnittstelle (Multiple Document Interface, MDI) kann der Benutzer mit mehreren Ausgaben der gleichen Schnittstelle gleichzeitig arbeiten, so dass sich die Produktivität erhöht. Heutzutage sind viele Anwendungen MDI-Applikationen. In der heutigen Lektion lernen Sie, wie Sie MDI-Anwendungen erstellen. Die Grundlagen zu erwerben ist einfach, doch die Handhabung all dieser Schnittstellen zugleich erfordert ein wenig Feingefühl. Heute lernen Sie, 쐽

was MDI ist und wie Ihnen dieses Konzept hilft,

쐽

wie Sie eine Excel-ähnliche Benutzeroberfläche erstellen,

쐽

wie man gleichzeitig Menüs und Ereignisse in mehreren Dokumenten verarbeitet,

쐽

wie Sie Ihre MDI-Dokumente miteinander kommunizieren lassen.

10.1 Einführung in die Mehrfachdokumentschnittstelle Was eine MDI-Anwendung bedeutet und darstellt, lernen Sie am besten am praktischen Beispiel. Abbildung 10.1 zeigt die MDI-Merkmale von Microsoft Excel in Aktion und Abbildung 10.2 zeigt Adobe Framemaker. Wäre Excel eine SDI-Anwendung, könnte man nur mit einem Dokument auf einmal arbeiten und nicht drei Dokumente gleichzeitig geöffnet halten, wie in Abbildung 10.1 zu sehen. Jede Schnittstelle – oder jedes Dokument – ist selbstständig und unabhängig von den anderen. Was man in der einen tut, betrifft die anderen nicht. Jedes Dokument kann seine jeweils eigene Menge an Daten, Objekten, Parametern usw. verwalten. Gegenüber SDI-Anwendungen bietet eine MDI-Anwendung mehrere Vorteile. Der erste ist offensichtlich: ein Zuwachs an Produktivität für den Benutzer. Theoretisch könnte er in zwei offenen Fenstern mehr Arbeit erledigen als in nur einem; das ist schon die ganze Idee, die sich hinter einem Multitasking-Betriebssystem verbirgt. Wäre es produktiver, nur eine Anwendung oder ein Dokument auf einmal zu benutzen, hätte sich das Windows-Betriebssystem wohl niemals so erfolgreich entwickelt. MDI-Anwendungen sind nützlich für Datenanalyseprogramme wie etwa Excel. Ist mehr als ein Dokument geöffnet und folglich auch mehr als eine Datenmenge zu bearbeiten, kann der Benutzer Daten leichter analysieren und vergleichen.

350

Einführung in die Mehrfachdokumentschnittstelle

Abbildung 10.1: Mit einer MDIAnwendung können Sie mehrere Schnittstellen auf einmal nutzen.

Abbildung 10.2: Adobe Framemaker stellt einen anderen Typ von MDI bereit.

Mit MDI-Anwendungen können Sie einem Benutzer ein Mehr an Informationen zur Verfügung stellen. Denken Sie z.B. an Visual Studio. Es verfügt über mehrere Fenster, um verschiedenartige Informationen anzuzeigen: Eines zeigt die Eigenschaften des aktuellen Objekts, eines die Hierarchie der Windows Forms-Steuerelemente in einem Formular und

351

MDI-Anwendungen erstellen

ein drittes den Formularcode. Werden in mehreren Fenstern unterschiedliche Facetten einer Anwendung angeboten, kann der Benutzer mehr Arbeit mit weniger Aufwand bewältigen. Ein Einzeldokument in einer MDI-Anwendung lässt sich maximal vergrößern, um alle anderen Dokumente zu verdecken. Auf diese Weise verhält sie sich fast wie eine SDI-Applikation; sogar die Menüs verschmelzen, um ein einzelnes, geöffnetes Fenster zu reflektieren. Durch diese Flexibilität kann der Benutzer die Art der Umgebung wählen, in der er gerne arbeitet. Doch MDI-Anwendungen haben auch ihre Nachteile. Als bedeutendster stellt sich oft ihr Hunger auf Systemressourcen heraus. Je mehr Dokumente man auf einmal geöffnet hat, desto mehr Rechenkapazität wird benötigt, was sich wiederum nachteilig auf die entsprechende Anwendung auswirkt, wenn nicht sogar auf Windows selbst. Dies bekommt eine erhöhte Bedeutung in Anwendungen wie Adobe Photoshop, in denen jedes Dokument große Grafiken beinhalten kann, manche bis zu mehreren Megabyte groß. Manche Anwendungen eignen sich nicht für ein Dasein als MDI. Die weiter vorn in diesem Buch entwickelte CD-Katalog-Anwendung ist ein gutes Beispiel dafür. Es gibt einfach keinen Grund, warum sie MDI-fähig sein sollte. Schließlich arbeiten Sie darin mit nur einer CD-Sammlung; MDI könnte in diesem Fall sogar zu einer gewissen Verwirrung des Benutzers beitragen. MDI ist sowohl für den Benutzer als auch den Entwickler komplizierter, was eigentlich gar nicht sein muss.

MDI-Menüs Ein interessantes Merkmal von MDI-Anwendungen ist ihr Umgang mit Menüs. Herkömmliche Menüs sind ja meist statisch: Die verfügbaren Menüs und Optionen ändern sich nicht (obwohl Microsoft Word 2000 Sie vom Gegenteil zu überzeugen versucht). Ganz gleich, was Sie tun, so haben Sie doch stets die gleichen Auswahlmöglichkeiten. Doch im Fall von MDI kann jedes Fenster seinen eigenen Satz an Menüs haben. Dieses Feature erlaubt Ihnen, bestimmte Tätigkeiten nur im aktuellen Dokument auszuführen. Je nachdem, was Sie in der Anwendung tun, können sich die Menüs ändern. Auch die Anwendung in ihrer Gesamtheit kann ihre eigenen Menüs haben, die alle Dokumente betreffen. Sie haben wahrscheinlich in den meisten MDI-Anwendungen ein FENSTER-Menü bemerkt. Es bietet Möglichkeiten, wie man die geöffneten Fenster organisieren kann, etwa durch Nebeneinanderlegen oder Übereinanderstapeln. Werden die verschiedenen Dokumente ausgewählt, so mag es vorkommen, dass Menüelemente miteinander verschmelzen, damit sie nicht mehr als einmal angezeigt werden. Dieses Verhalten lässt sich vollständig steuern.

352

Eine MDI-Anwendung erstellen

10.2 Eine MDI-Anwendung erstellen Um eine MDI-Anwendung auf die Beine zu stellen, sind mindestens zwei Dinge nötig: Erstens braucht man ein Haupt- oder übergeordnetes (Parent-) Fenster, um alle anderen offenen Dokumente zu beherbergen. Dieses übergeordnete Fenster sollte nur sehr wenige Benutzeroberflächenelemente aufweisen, denn die meisten davon sind in den anderen Dokumenten enthalten. Das übergeordnete Fenster ist eine Klasse, die von der Klasse System.Windows.Forms.Form erbt (genau wie alle anderen Windows Forms-Anwendungen). Als Zweites brauchen Sie eine Klasse, die die untergeordneten (Child-) Dokumente definiert. Sie erbt vom gleichen Namensraum wie das übergeordnete Fenster, doch sie sollte alle für die Anwendung nötigen Oberflächenelemente umfassen. Ebenso wie bei benutzerdefinierten Dialogfeldern (siehe Tag 7) brauchen Sie auch hier keine Main-Methode im untergeordneten Dokument. Wir wollen uns ein einfaches Beispiel für Parent-Child-Formulare ansehen. Als Erstes zeigt Listing 10.1 die Klasse des untergeordneten Dokuments. Listing 10.1: Die Klasse des untergeordneten MDI-Dokuments 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21:

using System; using System.Windows.Forms; using System.Drawing; namespace TYWinforms.Day10 { public class Document : Form { private Button btClick = new Button(); public Document() { btClick.Text = "Close Me!"; btClick.Location = new Point(100,100); btClick.Click += new EventHandler(this.Close); this.Controls.Add(btClick); } private void Close(Object Sender, EventArgs e) { this.Close(); } } }

Die Document-Klasse in Zeile 10 weist keine Besonderheiten auf; sie sieht genau wie jede andere Windows-Anwendung aus, nur dass sie keine Main-Methode besitzt. Beachten Sie das Steuerelement im Formular (Zeile 7), Button, das das Formular auf einen Klick hin

353

MDI-Anwendungen erstellen

schließt (Zeile 18). Beachten Sie auch den Namen der Klasse: Document. Diese Information wird im übergeordneten MDI-Fenster wichtig, das in Listing 10.2 zu sehen ist. Listing 10.2: Das übergeordnete MDI-Fenster 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.Day10 { public class Listing102 : Form { public Listing102() { this.IsMdiContainer = true; Document doc = new Document(); doc.MdiParent = this; } public static void Main() { Application.Run(new Listing102()); } } }

Die Klasse Listing102 in Listing 10.2 ist hinsichtlich der Anzahl der Codezeilen sogar noch einfacher. Drei Zeilen betreffen den MDI-Aspekt: 8, 10 und 11. Zeile 8 verwendet die Eigenschaft IsMdiContainer, um anzugeben, dass dieses Formular andere, nämlich untergeordnete Dokumente aufzunehmen vermag. Diese Eigenschaft ist vom Objekt System.Windows.Forms.Form geerbt, so dass Sie nun jede Windows Forms-Anwendung MDI-fähig machen können, indem Sie einfach diese Eigenschaft auf true setzen. Als Nächstes erzeugen Sie eine neue Instanz der in Listing 10.1 erstellten Document-Klasse. In Zeile 11 teilen Sie diesem neuen Objekt mit, wem es sich sozusagen unterzuordnen hat. Sie setzen die MdiParent-Eigenschaft auf das aktuelle Formular, welches durch this angegeben wird (Me in VB .NET). Auch diese Eigenschaft ist geerbt, so dass auch jede Windows Forms-Anwendung den untergeordneten Part in einer MDI-Anwendung einnehmen kann. Sobald Sie diese Anwendung kompiliert und ausgeführt haben, sehen Sie das Formular wie in Abbildung 10.3 . Sie können feststellen, dass Sie nun ein übergeordnetes Formular haben, welches einfach den Behälter für das untergeordnete Dokument darstellt. Sie können sodann das untergeordnete Dokument auf jede gewünschte Weise bearbeiten – es maximieren oder minimie-

354

Eine MDI-Anwendung erstellen

ren usw. Wenn Sie die in Listing 10.1 angelegte Schaltfläche anklicken, wird das untergeordnete Dokument geschlossen und das leere übergeordnete Formular bleibt zurück.

Abbildung 10.3: Ihre erste MDI-Anwendung sollte ungefähr so aussehen.

Sie können die Zeilen 10 und 11 wiederholt verwenden, um neue untergeordnete Dokumente zu erzeugen. Häufig bringt man diesen Code in einem Ereignishandler für Menüelemente unter, damit der Benutzer steuern kann, wann er neue Dokumente anlegt. Um dies zu erreichen, modifizieren Sie den Konstruktor von Listing 10.1 entsprechend dem folgenden Codefragment: public Document(String strName) { this.Text = strName; ...

Dieser neue Konstruktor übernimmt eine Zeichenfolge, die der Titelzeile des Formulars zugewiesen ist. In Listing 10.2 fügen Sie dann eine Variable hinzu, die die Anzahl der Dokumente und Menüobjekte verfolgt. Ändern Sie Listing 10.2 wie folgt ab: public class Listing102 : Form { private int intCounter = 0; private MainMenu mnuMain = new MainMenu(); public Listing102() { MenuItem miFile = mnuMain.MenuItems.Add("&Datei"); MenuItem miNew = miFile.MenuItems.Add("&Neu"); miNew.Click += new EventHandler(this.HandleMenu); this.Menu = mnuMain; ...

Die intCounter-Variable wird jedes Mal erhöht, wenn der Benutzer ein neues Dokument öffnet; mit Hilfe dieser Zahl lässt sich jedes neue untergeordnete Dokument leicht referen-

355

MDI-Anwendungen erstellen

zieren. Das DATEI-Menü ist ein Standardmenü mit einem NEU-Menüelement, das veranlasst, dass ein neues Dokument angelegt wird. Im nächsten Schritt verschieben Sie die Zeilen 10 und 11 aus Listing 10.2 in eine neue Methode, nämlich den Ereignishandler für das NEU-Menüelement, wie im folgenden Codeabschnitt zu sehen: public void handleMenu(Object Sender, EventArgs e) { intCounter++; Document doc = new Document("Dokument " + intCounter.ToString()); doc.mdiParent = this; doc.Show(); }

Dieser Code nutzt den modifizierten Konstruktor der zuvor erstellten Document-Klasse. Er übergibt der neuen Klasse eine Zeichenfolge, die ihre Beschriftung wird. Vergessen Sie nicht die Show-Methode aufzurufen, um das neue untergeordnete Dokument anzuzeigen. Dieser Schritt war nicht notwendig, als sich dieser Code noch im Klassenkonstruktor befand, doch das hat sich nun geändert. Nun kompilieren Sie diese Anwendung neu und probieren das NEU-Menüelement aus. Abbildung 10.4 zeigt das Ergebnis, das mehrere untergeordnete Dokumente enthält.

Abbildung 10.4: Der Benutzer kann steuern, wie viele Fenster geöffnet werden.

356

Eine MDI-Anwendung erstellen

Theoretisch könnte man unbegrenzt viele Fenster öffnen. Wollten Sie diese Anzahl begrenzen, brauchen Sie einfach nur die intCounter-Variable zu prüfen, bevor ein neues Dokument angelegt wird. Liegt die Zahlenangabe über Ihrem Schwellenwert, erzeugen Sie kein neues Document-Objekt. Beachten Sie auch, dass jedes neue Dokument eine benutzerfreundliche Titelzeile aufweist: Dokument 1, Dokument 2 usw. Wenn Sie eines der untergeordneten Fenster maximieren, verschwindet diese Titelzeile jedoch. Um diesen Makel zu beheben, legen Sie eine Überschrift für das übergeordnete MDI-Formular fest: this.Text = "Listing 10.2";

Wenn Sie nun die Fenster maximieren, ändert sich die Titelzeile von »Listing 10.2« auf eine Weise, dass sie das passende untergeordnete Fenster widerspiegelt: »Listing 10.2 – Dokument 1«, »Listing 10.2 – Dokument 2« usw. .NET handhabt einen großen Teil der Probleme, wenn man mit mehreren untergeordneten Fenstern umgeht, das ist aber noch nicht alles. Auch Menüs werden für Sie automatisch gehandhabt. Wenn ein untergeordnetes Dokument über ein verknüpftes Menü verfügt, ändert sich die Menüleiste des übergeordneten Formulars so, dass sie das aktuelle bzw. aktive Dokument widerspiegelt. Wir wollen ein einfaches Menü zur Document-Klasse hinzufügen, damit der Benutzer die Hintergrundfarbe des Formulars ändern kann; für diese Anwendung verwenden wir das gängige ColorDialogDialogfeld. Als Erstes fügen Sie das Menü ein wie im folgenden Code zu sehen: private MainMenu mnuMain = new MainMenu(); public Document(String strName){ MenuItem miFormat = mnuMain.MenuItems.Add("Format " + strName); MenuItem miColor = miFormat.MenuItems.Add("&Farbe..."); miColor.Click += new EventHandler(this.HandleMenu); this.Menu = mnuMain; ...

Beachten Sie, dass der Menüname so festgelegt wurde, dass er den Namen des untergeordneten Dokuments reflektiert. Diese Namenskonvention wird Ihnen beim Überblick über das aktive Fenster helfen. Als Nächstes fügen Sie den Ereignishandler für das Menü hinzu: private void HandleMenu(Object Sender,EventArgs e) { ColorDialog dlgColor = new ColorDialog(); if (dlgColor.ShowDialog()== DialogResult.OK) { this.BackColor = dlgColor.Color; } }

Schlagen Sie bei Bedarf noch einmal Tag 7 nach, um Ihr Gedächtnis aufzufrischen, was Standarddialogsteuerelemente betrifft. Im Wesentlichen zeigt die Methode das ColorDialog-Steuerelement an, und wenn der Benutzer eine Farbe auswählt und auf die OK-Schaltfläche klickt, ändert sich die Hintergrundfarbe des jeweiligen untergeordneten Formulars.

357

MDI-Anwendungen erstellen

Wenn Sie jetzt die Anwendung ausführen, bemerken Sie als Erstes, dass das dem untergeordneten Dokument hinzugefügte Menü in der Menüleiste des übergeordneten Formulars angezeigt wird. Dass das Menü hier platziert wird, hilft, ein Durcheinander zu vermeiden. Beachten Sie außerdem, dass sich die Menübeschriftung ändert, wenn man auf unterschiedliche untergeordnete Dokumente klickt – dies spiegelt das aktive untergeordnete Dokument wider. Sobald alle untergeordneten Fenster geschlossen wurden, verschwindet das neue FORMAT-Menü. Wir wollen noch ein weiteres verbreitetes Merkmal einer MDI-Anwendung betrachten: die Fensteranordnung. Fast jede MDI-Anwendung weist standardmäßig ein FENSTER-Menü auf, mit dem der Benutzer die untergeordneten Fenster innerhalb des übergeordneten Fensters übersichtlicher anordnen kann. Diese Fenster enthalten in der Regel eine Liste aller offenen untergeordneten Fenster, so dass man leicht jenes auswählen kann, zu dem man wechseln möchte – das erspart das Durchsuchen aller Fenster, bis man auf das gewünschte stößt. Wir wollen die verschiedenen Möglichkeiten betrachten, wie man Fenster anordnen kann: 쐽

ÜBERLAPPEND: Fenster werden bei dieser Einstellung übereinander gestapelt, mit nur gerade mal so viel Verschiebung, dass noch die Titelzeile des darunter liegenden Fensters zu sehen ist.

쐽

NEBENEINANDER: Fenster werden so angeordnet, dass sie sich nicht überschneiden. Jedes Fenster ist genau so hoch wie das übergeordnete Formular, doch die Fenster teilen sich die Breite des Hauptformulars gleichmäßig untereinander auf.

쐽

UNTEREINANDER: Der gleiche Fall, nur dass diesmal die Aufteilung senkrecht erfolgt, die Breite aber jeweils der des übergeordneten Formulars entspricht.

Diese Layouts sind in der Aufzählung MdiLayout definiert: MdiLayout.Cascade, MdiLayout.TileHorizontal und MdiLayout.TileVertical. Die LayoutMdi-Methode des FormObjekts kann diese Werte dazu verwenden, Fenster entsprechend anzuordnen. Wir wollen die Anwendung noch einmal modifizieren, um diese Layouts zu nutzen. Listing 10.3 zeigt die neue Version des Listings 10.2 und enthält alle bislang gemachten Änderungen. Listing 10.3: Das vollendete übergeordnete MDI-Formular 1: 2: 3: 4: 5: 6: 7: 8: 9: 10:

358

using System; using System.Windows.Forms; using System.Drawing; namespace TYWinforms.Day10 { public class Listing102 : Form { private int intCounter = 0; private MainMenu mnuMain = new MainMenu(); public Listing102() {

Eine MDI-Anwendung erstellen

11: 12: 13: 14:

MenuItem miFile = mnuMain.MenuItems.Add("&Datei"); MenuItem miNew = miFile.MenuItems.Add("&Neu"); MenuItem miWindow = mnuMain.MenuItems.Add("&Fenster"); miWindow.MenuItems.Add("Überlappend", new EventHandler(this.ArrangeWindows)); miWindow.MenuItems.Add("Untereinander", new EventHandler(this.ArrangeWindows)); miWindow.MenuItems.Add("Nebeneinander", new EventHandler(this.ArrangeWindows));

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: 46: 47: 48: 49: 50: 51: 52: 53: 54: 55:

miNew.Click += new EventHandler(this.HandleMenu); miWindow.MdiList = true; this.IsMdiContainer = true; this.Menu = mnuMain; this.Size = new Size(800,600); this.Text = "Listing 10.2"; } private void ArrangeWindows(Object Sender, EventArgs e) { MenuItem miTemp = (MenuItem)Sender; switch (miTemp.Text) { case "Überlappend": this.LayoutMdi(MdiLayout.Cascade); break; case "Untereinander": this.LayoutMdi(MdiLayout.TileHorizontal); break; case "Nebeneinander": this.LayoutMdi(MdiLayout.TileVertical); break; } } private void HandleMenu(Object Sender, EventArgs e) { intCounter++; Document doc = new Document("Dokument " + intCounter.ToString()); doc.MdiParent = this; doc.Show(); } public static void Main() { Application.Run(new Listing102()); } } }

359

MDI-Anwendungen erstellen

Der neue Code für das FENSTER-Menü findet sich in den Zeilen 13 bis 16. Sie erzeugen zunächst das FENSTER-Menü und dann drei Untermenüs für jede der drei Fensteranordnungen. Beachten Sie, dass sie alle auf denselben Ereignishandler namens ArrangeWindows zeigen. In Zeile 19 setzen Sie die MdiList-Eigenschaft des neuen FENSTER-Menüs auf true, um Ihrer Anwendung mitzuteilen, dass dieses Menü für die Steuerung von untergeordneten MDI-Fenstern vorgesehen ist. Im Wesentlichen wird dieses Menü Menüelemente automatisch hinzufügen und entfernen, die die gerade geöffneten untergeordneten Dokumente widerspiegeln. Werden diese dynamischen Menüelemente angeklickt, erhält das passende untergeordnete Fenster den Fokus, um Benutzereingaben zuzulassen. Springen wir zur ArrangeWindows-Methode in Zeile 27. Sie wollen feststellen, welches Menüelement für die Fensteranordnung angeklickt worden ist und die untergeordneten Fenster entsprechend arrangieren. Zuerst konvertieren Sie die Sender-Variable (welche das Objekt darstellt, das das Ereignis auslöste) in ein MenuItem, damit Sie die nötigen Eigenschaften und Methoden verwenden können. Das switch-Statement wertet die Beschriftung des angeklickten MenuItems aus. Der entsprechende case-Zweig ruft die LayoutMdi-Funktion auf und übergibt ihr einen der Werte der MdiLayout-Aufzählung.

Abbildung 10.5: Das Nebeneinanderlegen von Fenstern ist nur eine Ihrer LayoutOptionen.

360

Eine MDI-Anwendung erstellen

Nun kompilieren Sie diese Anwendung und führen sie aus. Sie werden bemerken, dass sich das FENSTER-Menü beim Hinzufügen neuer Dokumente dynamisch ändert, um die neuen Fenster zu reflektieren. Klicken Sie auf die verschiedenen Layout-Optionen, um sie zu testen. Abbildung 10.5 zeigt ein Beispiel.

Verschiedene Arten von untergeordneten Fenstern erstellen Bis jetzt haben Sie MDI-Anwendungen erstellt, die mehrere Instanzen desselben untergeordneten Dokuments aufweisen. Es ist jedoch nicht zwingend, dass Sie Ihre Anwendungen in dieser Weise erstellen: Jedes untergeordnete Dokument kann von einem völlig verschiedenen Objekttyp sein, solange nur alle von der Klasse System.Windows.Forms.Form erben. Wir wollen einmal ein brauchbares Beispiel erstellen. Viele Anwendungen (wie etwa Visual Studio) verfügen über »Symbolleisten« und »Eigenschaftenfenster«, die man auf dem Bildschirm bewegen kann. Diese Fenster werden zusätzlich zur zentralen Benutzeroberfläche bereitgestellt, welche meist für die Dateneingabe vorgesehen ist, und bieten weitere hilfreiche Funktionen an, die sonst nicht direkt zugänglich sind. Bedenken Sie jedoch, dass sich für das, was Sie mit einem untergeordneten MDI-Dokument vorhaben, möglicherweise ein benutzerdefiniertes nichtmodales Dialogfeld besser eignet. Jede Vorgehensweise hat ihre Vor- und Nachteile, daher sollten Sie Ihre Wahlmöglichkeiten genau gegeneinander abwägen, bevor Sie sich für die vielschichtige Welt von MDI entscheiden. Ich empfehle

Bitte beachten Sie

Verwenden Sie MDI und untergeordnete Dokumente, wenn Sie den Desktop des Benutzers nicht überladen möchten. und der Benutzer leicht einen Bildlauf durchführen kann, um verborgene Bereiche von untergeordneten Dokumenten einzusehen (wie zum Beispiel in Microsoft Excel).

Setzen Sie MDI nicht ein, wenn Sie ein Fenster brauchen, das mehrere untergeordnete Dokumente auf einmal beeinflussen kann. Ein Beispiel dafür wäre ein Fenster mit Schaltflächen, die automatisch Text im aktiven untergeordneten Fenster einfügen können. Würden Sie in diesem Fall ein untergeordnetes MDI-Dokument verwenden, könnten Sie den Text nicht im aktiven untergeordneten Fenster einfügen, weil dieses ja das Fenster mit den Schaltflächen wäre. Sie würden Ihre Referenz auf das beabsichtigte Ziel dieser Operation verlieren.

361

MDI-Anwendungen erstellen

10.3 Die Besonderheiten von MDI-Formularen steuern Es bereitet keine besondere Mühe, eine MDI-Anwendung zu erstellen. Um das absolute Minimum an Funktionsumfang zu erzeugen, muss man nur ein paar Codezeilen einfügen (vorausgesetzt, man hat bereits seine untergeordnete Dokumentklasse). Unter der Oberfläche erfordert das Steuern von MDI-Anwendungen jedoch wesentlich mehr.

Menüs Wenn sowohl den über- als auch untergeordneten Dokumenten Menüs zugeordnet sind, ändert sich die Menüleiste des übergeordneten Dokuments, wenn das jeweilige untergeordnete Dokument aktiv ist. Dies wird als Zusammenführen von Menüs (Menu Merging) bezeichnet; die Menüs des untergeordneten und übergeordneten Fensters verschmelzen zu einer Menüleiste. Sind die unterschiedlichen Menüs eindeutig, erfolgt die Verschmelzung anstandslos, wie Sie heute bereits bemerken konnten. Der Vorgang wird jedoch etwas interessanter, sobald man auf doppelte Menüelemente stößt. Lassen Sie uns sehen, was in einer solchen Lage passiert. Fügen Sie dem Konstruktor der Document-Klasse in Listing 10.1 folgenden Code hinzu: MenuItem miFile = mnuMain.MenuItems.Add("Datei");

Abbildung 10.6: Die Anwendung verfügt jetzt über zwei DATEI-Menüs.

362

Die Besonderheiten von MDI-Formularen steuern

Nun verfügen sowohl das übergeordnete als auch das untergeordnete Formular über ein DATEI-Menü. Kompilieren Sie diese Anwendung und führen Sie sie aus. Wenn Sie ein neues untergeordnetes Dokument öffnen, erhalten Sie die Fenster, die Sie in Abbildung 10.6 sehen. Die Menüs des übergeordneten und des untergeordneten Fensters sind jetzt miteinander verschmolzen und Sie haben zwei DATEI-Menüs! Sicherlich ist das nicht gerade das, was Sie wollen. Irgendwie müssen Sie die Anwendung wissen lassen, dass die zwei DateiMenüs eigentlich dasselbe Menü sind und dass ihre Inhalte kombiniert werden sollen. Zum Glück kann Ihnen die MenuMerge-Aufzählung helfen. Tabelle 10.1 beschreibt die Werte dieser Aufzählung. Wert

Beschreibung

Add

Das Standardverhalten. Ein untergeordnetes Menüelement wird der übergeordneten Menüleiste hinzugefügt, ganz gleich, ob bereits eines existiert (dies führt zum Problem des »doppelten DATEI-Menüs«).

MergeItems

Alle Untermenüs dieses Menüelements werden mit denen des übergeordneten Menüs, die den gleichen Platz im Menü innehaben, zusammengeführt.

Remove

Dieses MenuItem wird beim Zusammenführen nicht verwendet; es wird vielmehr weggelassen und nicht in der kombinierten Menüleiste auftauchen.

Replace

Dieses MenuItem wird jedes vorhandene MenuItem, das den gleichen Platz in dem Menü innehat, ersetzen. Das untergeordnete Menüelement hat stets Vorrang vor dem des übergeordneten. Sie verwenden diesen Wert, wenn Sie die Ereignishandler für ein bestimmtes Menüelement überschreiben wollen.

Tabelle 10.1: Die Werte der MenuMerge-Aufzählung

Damit alle Werte (außer Remove) funktionieren, muss allen MenuItems ein MenuMerge-Wert zugewiesen werden – d.h. sowohl im übergeordneten als auch im untergeordneten Formular. Um den Wert zuzuweisen, fügen Sie in die Listings 10.1 und 10.2 folgende Codezeile ein: miFile .MergeType = MenuMerge.MergeItems;

Wenn Sie nun die Anwendung ausführen und ein untergeordnetes Dokument anlegen, erscheint nur ein DATEI-Menü. Versuchen Sie nun dem Listing 10.1 folgende Zeile hinzuzufügen; sie fügt einfach ein Untermenü in das DATEI-Menü des untergeordneten Dokuments ein: MenuItem miNew = miFile.MenuItems.Add("Neu");

363

MDI-Anwendungen erstellen

Führen Sie die Anwendung erneut aus. Was passiert, wenn Sie ein untergeordnetes Dokument anlegen? Die DATEI-Menüs verschmelzen, aber nun haben Sie zwei NEU-Untermenüs. Um dieses Problem zu beheben, können Sie entweder in beiden Listings MergeType = MenuMerge.Replace festlegen (was dazu führen würde, dass das Menüelement des untergeordneten Dokuments das des übergeordneten Formulars ersetzen würde) oder Sie geben in beiden Listings MergeType = MenuMerge.Remove an. Das übrig bleibende Menüelement entspricht der entgegengesetzten Klasse, in der Sie MenuMerge.Remove angeben. Wenn Sie z.B. Remove in der übergeordneten Klasse angeben, dann ist das untergeordnete Menüelement dasjenige, das in der Menüleiste angezeigt wird; nur seine Funktion wird ausgeführt, sobald man es anklickt. Beachten Sie, dass das ganze Thema der Zusammenführung nur Elemente betrifft, die im Menü den gleichen Platz innehaben. Angenommen, Sie haben ein Menü des übergeordneten Dokuments mit folgenden Elementen (von oben nach unten): DATEI, NEU, SPEICHERN, SCHLIEßEN. Ein korrespondierendes untergeordnetes Dokumentenmenü besitzt folgende Elemente (wiederum von oben nach unten): DATEI, NEU, SCHLIEßEN. Die jeweiligen Menüs DATEI und NEU sollten gemäß den soeben genannten MenuMerge-Regeln gehandhabt werden. Mit den Menüelementen danach gibt es jedoch ein kleines Problem. Stellen Sie sich vor, Sie wollen das SCHLIEßEN-Menü des untergeordneten Dokuments das SCHLIEßEN-Menü des übergeordneten Dokuments überschreiben lassen. Daher setzen Sie MergeType = MenuMerge.Remove in der übergeordneten Klasse und MergeType = MenuMerge.Replace in der untergeordneten Klasse. Dieses Vorgehen sollte funktionieren, oder? Leider klappt das nicht ganz. Das SCHLIEßEN-Menü des übergeordneten Dokuments verschwindet zwar wie erwartet, doch das übergeordnete SPEICHERN-Menü wird nun durch das untergeordnete SCHLIEßEN-Menü ersetzt, so dass das Menüsystem durcheinander gerät und der Benutzer ernsthaft verwirrt ist. Obwohl wir wissen, dass das SCHLIEßEN-Menü des übergeordneten Dokuments dem gleichnamigen Menü des untergeordneten Dokuments entsprechen sollte, weiß es die Anwendung nicht. Vielmehr kann sie nur auf der Grundlage der Position des Menüelements im Menü operieren. SCHLIEßEN befindet sich im übergeordneten Menü an Position 3 (die Zählung beginnt bei Null) und im untergeordneten Menü an Position 2. Die Wege dieser beiden Menüelemente werden sich also nie kreuzen, weshalb sie auch nie verschmelzen können. Die Position 2 im übergeordneten Menü wird nämlich vom SPEICHERN-Menü eingenommen, so dass es vom MergeType des untergeordneten SCHLIEßENMenüs betroffen wird. Doch zum Glück gibt es auch für dieses Problem eine Lösung. Die MergeOrder-Eigenschaft von MenuItems lässt sich dazu benutzen, eine Reihenfolge zu diktieren und somit auch die Parent-Child-Menübeziehung, in der die Menüelemente auftauchen. Im obigen Beispiel können Sie beide SCHLIEßEN-Menüelemente auf denselben MergeOrder-Wert setzen:

364

Die Besonderheiten von MDI-Formularen steuern

miClose.MergeOrder = 3

Nun weiß die Anwendung nicht nur, dass diese beiden Menüelemente einander entsprechen, sondern sie wird sie auch in der aufsteigenden Reihenfolge der MergeOrder-Werte anordnen. Mit anderen Worten: Ein Menüelement mit MergeOrder gleich 0 wird an der Spitze des Menüs platziert, das Element mit MergeOrder gleich 1 folgt unmittelbar darunter usw. Beachten Sie, dass die Menüelemente nicht an die durch MergeOrder vorgeschriebene Position verschoben werden. Daher ist die Anfangsposition weiterhin durch die Reihenfolge diktiert, in der Sie MenuItems zum Menü hinzufügen. Welchen MergeOrder-Wert Sie nun tatsächlich setzen, ist eigentlich nicht wichtig; Sie können ohne weiteres die MergeOrder des SCHLIEßEN-Menüelements auf 1000 setzen. Windows Forms ist intelligent genug, um keine 999 leeren Menüelemente vor das fragliche Menüelement zu setzen (es sei denn, Sie befehlen, 999 leere Stellen einzufügen). Die MergeOrder ist nur eine willkürliche Zahl, die die Parent-Child-Beziehungen und die Anordnung von zusammengeführten Elementen regelt. Elemente mit höherer MergeOrderZahl werden in einem Menü stets tiefer einsortiert als Elemente mit einer niedrigeren MergeOrder. Daher mag es nicht in jedem Fall von Vorteil sein, die MergeOrder-Werte fortlaufend zu nummerieren, also 0 für das erste Element, 1 für das zweite und so weiter. Was, wenn Ihre untergeordnete Anwendung ein Menüelement hat, das Sie zwischen zwei Menüelementen im übergeordneten Menü einschieben wollen? In diesem Fall würde es helfen, zwischen den MergeOrder-Werten einen gewissen Abstand vorzusehen, so dass man später noch expandieren kann. Abbildung 10.7 illustriert das geschilderte Konzept.

Untergeordnete Fenster In vielen Fällen müssen Sie wissen, welches untergeordnete MDI-Fenster das aktive ist. Angenommen, Sie führen eine Suche in einem RichTextBox-Steuerelement durch oder fügen Text aus einer anderen Anwendung ein. Die Eigenschaft ActiveMdiChild des übergeordneten Formulars liefert ein Form-Objekt, das dem untergeordneten Fenster entspricht. Wir wollen Ihrem übergeordneten Formular ein FARBE-Menü hinzufügen, das ein ColorDialog-Dialogfeld anzeigt und die Farbe des aktiven untergeordneten Fensters ändert. Zu diesem Zweck fügen Sie dem Listing 10.2 folgenden Code hinzu: MenuItem miFormat = mnuMain.MenuItems.Add("Farbe "); MenuItem miColor = miFormat.MenuItems.Add("&Farbe..."); miColor.Click += new EventHandler(this.ChangeColor);

365

MDI-Anwendungen erstellen

Elternmenü

Kindmenü

Neu, MergeOrder = 0 Öffnen, MergeOrder = 5 Drucken, MergeOrder = 10 Beenden, MergeOrder = 100

Neu, MergeOrder = 0 Speichern, MergeOrder = 2 Speichern als, MergeOrder = 3 Rückgängig, MergeOrder = 9 Schließen, MergeOrder = 11

Merged Menu Neu, MergeOrder = 0 Speichern, MergeOrder = 2 Speichern als, MergeOrder = 3 Öffnen, MergeOrder = 5 Rückgängig, MergeOrder = 9 Drucken, MergeOrder = 10 Schließen, MergeOrder = 11 Beenden, MergeOrder = 100

Abbildung 10.7: Die genauen MergeOrder-Werte sind unwesentlich; nur auf die relativen Werte kommt es an.

Nun fügen Sie den ChangeColor-Ereignishandler hinzu: private void ChangeColor(Object Sender,EventArgs e){ ColorDialog dlgColor = new ColorDialog(); if (dlgColor.ShowDialog()== DialogResult.OK){ if (ActiveMdiChild != null){ ActiveMdiChild.BackColor = dlgColor.Color; } } }

Diese Methode erstellt zunächst ein Dialogfeld ColorDialog und zeigt es an, damit der Benutzer eine Farbe auswählen kann. Bevor Sie fortfahren, müssen Sie prüfen, ob der Benutzer in der Anwendung schon ein untergeordnetes Fenster erzeugt hat. Ist das nicht der Fall und versuchen Sie auf die Eigenschaft ActiveMdiChild zuzugreifen, erhalten Sie eine Fehlermeldung. Zum Schluss legen Sie die Eigenschaften des ActiveMdiChild-Formulars genau wie für jedes andere Form-Objekt fest. Sie können sich auch benachrichtigen lassen, sobald ein untergeordnetes Fenster aktiviert wird oder vom Benutzer den Fokus erhält. Dafür steht das Ereignis MdiChildActivate zur Verfügung. Fügen Sie den folgenden Code Ihrem übergeordneten Formular hinzu: //außerhalb des Konstruktors private StatusBar sbarMain = new StatusBar(); //innerhalb des Konstruktors this.Controls.Add(sbarMain); this.MdiChildActivate += new EventHandler(this.UpdateStatus);

366

Die Besonderheiten von MDI-Formularen steuern

Als Nächstes fügen Sie die UpdateStatus-Methode ein: private void UpdateStatus(Object Sender,EventArgs e) { sbarMain.Text = ActiveMdiChild.Text +": " + ActiveMdiChild.BackColor.ToString(); }

So einfach ist das! Abbildung 10.8 zeigt ein Beispiel.

Abbildung 10.8: Abbildung 10.8: Das Ereignis MdiChildActivate

kann Sie darüber unterrichten, sobald ein untergeordnetes Fenster den Fokus erhält.

Sollten Sie jemals auf ein untergeordnetes Dokument zugreifen müssen, bei dem es sich nicht um das aktive untergeordnete Dokument handelt, können Sie die MdiChildrenEigenschaft einsetzen, die ein Array aller untergeordneten Formulare liefert, seien sie nun aktiv oder nicht.

Auf untergeordnete Steuerelemente zugreifen Der Zugriff auf untergeordnete Formulare ist also nicht besonders schwierig. Das ist jedoch beim Zugriff auf ihre Steuerelemente ganz anders. Da Sie schließlich praktisch alle Steuerelemente mit Hilfe des private-Modifizierers erstellt haben, dürften sie über das übergeordnete Formular nicht zugänglich sein, oder? Zum Glück lautet die Antwort »nein«. Die in einem untergeordneten Formular enthaltenen Steuerelemente können Sie über die Controls-Eigenschaft des untergeordneten Dokuments erreichen. Betrachten Sie bitte den in einem übergeordneten Konstruktor enthaltenen Code:

367

MDI-Anwendungen erstellen

string StrText; Document doc = new Document("Neues Dokument"); doc.MdiParent = this; strText = doc.Controls[0].Text;

Dieser Befehl ruft die Text-Eigenschaft dessen ab, was auch immer das erste Steuerelement im untergeordneten Formular ist. Wir wollen ein realistischeres Beispiel erstellen. Listing 10.4 zeigt ein neues übergeordnetes Anwendungsformular, das ein neues untergeordnetes Formular erzeugt, zu dem wir gleich noch kommen. (Der Einfachheit halber wurden die standardmäßigen Windows-Menüs und Ereignishandler in diesem Code weggelassen.) Listing 10.4: Ein eindringendes übergeordnetes Steuerelement 1: using System; 2: using System.Windows.Forms; 3: using System.Drawing; 4: 5: namespace TYWinforms.Day10 { 6: public class Listing104 : Form { 7: private int intCounter = 0; 8: private MainMenu mnuMain = new MainMenu(); 9: 10: public Listing104() { 11: MenuItem miFile = mnuMain.MenuItems.Add("&Datei"); 12: MenuItem miNew = miFile.MenuItems.Add("&Neu"); 13: MenuItem miOpenIn = miFile.MenuItems.Add("Ö&ffnen in neuem Fenster"); 14: miOpenIn.Enabled = false; 15: 16: miFile.Popup += new EventHandler (this.EnableOpenIn); 17: miNew.Click += new EventHandler(this.HandleMenu); 18: miOpenIn.Click += new EventHandler(this.OpenIn); 19: miWindow.MdiList = true; 20: 21: this.IsMdiContainer = true; 22: this.Menu = mnuMain; 23: this.Size = new Size(800,600); 24: this.Text = "Listing 10.3"; 25: } 26: 27: private void EnableOpenIn(Object Sender, EventArgs e) { 28: if (this.ActiveMdiChild != null) { 29: if (((TextBox)ActiveMdiChild.Controls[0]).SelectedText != "") { 30: mnuMain.MenuItems[0].MenuItems[1].Enabled = true;

368

Die Besonderheiten von MDI-Formularen steuern

31: } else { 32: mnuMain.MenuItems[0].MenuItems[1].Enabled = false; 33: } 34: } 35: } 36: 37: private void OpenIn(Object Sender, EventArgs e) { 38: if (ActiveMdiChild != null) { 39: string strText = ((TextBox)ActiveMdiChild.Controls[0]).SelectedText; 40: 41: intCounter++; 42: Document2 doc = new Document2("Document " + intCounter.ToString()); 43: doc.MdiParent = this; 44: doc.Controls[0].Text = strText; 45: doc.Show(); 46: } 47: } 48: 49: private void HandleMenu(Object Sender, EventArgs e) { 50: intCounter++; 51: 52: Document2 doc = new Document2("Dokument " + intCounter.ToString()); 53: doc.MdiParent = this; 54: doc.Show(); 55: } 56: 57: public static void Main() { 58: Application.Run(new Listing104()); 59: } 60: } 61: }

Listing 10.4 beginnt mit einem normalen übergeordneten MDI-Formular. Sie haben ein DATEI-Menü, mit dem der Benutzer neue untergeordnete Dokumente anlegen kann. Sein Ereignishandler ist in Zeile 49 zu finden. Diese HandleMenu-Methode ist praktisch die gleiche wie in Listing 10.2, doch erzeugt sie diesmal die Instanz eines untergeordneten Dokuments Document2 statt nur Document. Sie werden diese neue Klasse gleich sehen; sie ist im Grunde sehr einfach. Wir haben außerdem in Zeile 13 ein neues Menüelement namens IN NEUEM FENSTER ÖFFNEN. Dieses Menüelement übernimmt jeden Text, den der Benutzer in einem untergeordneten Fenster ausgewählt hat, erzeugt ein neues untergeordnetes Dokument und legt nur den ausgewählten Text im neuen

369

MDI-Anwendungen erstellen

Dokument ab. (Sie merken schon, dass die neue untergeordnete Klasse über wenigstens eine TextBox-Steuerelement verfügt.) Ist jedoch kein untergeordnetes Dokument vorhanden, soll der Benutzer dieses Menüelement nicht benutzen können. Um diesen Aspekt zu steuern, weisen Sie dem Popup-Ereignis des DATEI-Menüs einen Delegaten zu (Zeile 16). Das Ereignis wird immer dann ausgelöst, wenn der Benutzer das Menü öffnet. Zeile 27 enthält den Ereignishandler für das Popup-Ereignis. Sie wollen das Menüelement ÖFFNEN IN nur dann »einschalten«, sofern a) ein untergeordnetes Dokument aktiv ist und b) dieses untergeordnete Dokument markierten Text enthält. Das erste if-Statement in Zeile 28 prüft, ob ein untergeordnetes Dokument aktiv ist. Das zweite ist ein wenig komplizierter. Denken Sie daran, dass Sie auf die Steuerelemente in einem untergeordneten Formular mit Hilfe der Controls-Eigenschaft zugreifen können. Zwar trifft dies zu, doch diese Eigenschaft liefert nur ein Control-Objekt, so dass Sie es in ein passendes Steuerelement konvertieren müssen. In diesem Fall erwarten Sie ja ein TextBox-Steuerelement. Das if-Statement in Zeile 29 holt das erste Steuerelement im aktiven untergeordneten Dokument, konvertiert es in den Typ TextBox und wertet dann die SelectedText-Eigenschaft daraufhin aus, ob ein Text markiert worden ist. Ist dies nicht der Fall, soll das Menüelement abgeschaltet werden, wie in Zeile 32 angegeben. Ist jedoch wirklich etwas Text markiert, dann soll das Menüelement ÖFFNEN IN aktiviert werden. Dies ist der erste Teil des Zugriffs auf die Steuerelemente im untergeordneten Dokument. Der nächste Schritt besteht im Bereitstellen der Funktionalität von ÖFFNEN IN. Diese wird von der OpenIn-Methode in Zeile 37 gehandhabt. Wiederum prüfen Sie in Zeile 38 zuerst, ob ein untergeordnetes Dokument aktiv ist. In der nächsten Zeile rufen Sie den markierten Text (SelectedText) aus dem ersten Steuerelement des untergeordneten Dokuments, wobei Sie wieder daran zu denken haben, das Objekt per Typumwandlung passend zu konvertieren. Dann erzeugen Sie ein neues untergeordnetes Dokument auf die gleiche Weise, wie wenn ein Benutzer das NEU-Menüelement anklicken würde: Sie inkrementieren den Zähler, erstellen ein neues Document2-Objekt, legen seine MdiParent-Eigenschaft auf das aktuelle Formular fest und rufen schließlich zwecks Anzeige die Show-Methode auf. In Zeile 44 ist ein gesonderter Arbeitsschritt zu sehen: Sie setzen die Text-Eigenschaft des ersten Steuerelements im neuen untergeordneten Dokument auf den Text, der aus dem letzten untergeordneten Dokument geholt wurde. Wir wollen zum Schluss noch einen Blick auf die neue Document2-Klasse in Listing 10.5 werfen.

370

Die Besonderheiten von MDI-Formularen steuern

Listing 10.5: Die Klasse Document2 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.Day10 { public class Document2 : Form { private TextBox tbText = new TextBox(); public Document2(String strName) { tbText.Dock = DockStyle.Fill; tbText.Multiline = true; tbText.HideSelection = false; this.Text = strName; this.Controls.Add(tbText); } } }

Listing 10.5 zeigt eine einfache Klasse, die lediglich ein TextBox-Steuerelement enthält. Die TextBox wird in Zeile 10 so eingestellt, dass sie das gesamte Formular ausfüllt, so dass der Benutzer umfangreiche Textmengen eingeben kann.

Abbildung 10.9: Nachdem Sie etwas Text markiert und auf das Menüelement ÖFFNEN IN geklickt haben, erscheint Ihr ausgewählter Text in dem neuen Dokumentfenster.

371

MDI-Anwendungen erstellen

Kompilieren Sie diese Anwendung und führen Sie sie aus. Prüfen Sie die Funktionsfähigkeit, indem Sie etwas Text markieren und auf das Menüelement ÖFFNEN IN klicken. Abbildung 10.9 zeigt, wie Ihre Anwendung aussehen sollte.

10.4 Zusammenfassung MDI-Anwendungen nutzen sinnvoll das Multitasking-Konzept. Wenn mehr als ein Dokument auf einmal in einer Anwendung geöffnet ist, könnte ein Benutzer theoretisch doppelt so viel Arbeit verrichten. Das Erstellen einer MDI-Anwendung erweist sich häufig als wirtschaftlicher, als den Benutzer zu zwingen, eine fragliche Anwendung zweimal zu starten, nur um ihn in zwei Dokumenten arbeiten lassen zu können. Um eine MDI-Anwendung erstellen zu können, braucht man eine Klasse für das übergeordnete Formular und eine für das untergeordnete Formular. Dabei kann es sich um beliebige Klassen handeln, solange sie vom Form-Objekt erben. Beliebige Windows Forms können entweder übergeordnete oder untergeordnete MDI-Formulare sein; hier gibt es keine Einschränkung. Die meisten MDI-Anwendungen verfügen über ein FENSTER-Menü, mit dem der Benutzer die untergeordneten Fenster in einer übersichtlicheren Weise anordnen kann. Ein Menü können Sie leicht wie folgt erstellen: Erzeugen Sie einfach die nötigen Menüelemente und rufen Sie die LayoutMdi-Methode mit dem passenden Wert der MdiLayout-Aufzählung auf. Sie können zudem die MdiList-Eigenschaft dieses Menüs auf true setzen, um automatisch die untergeordneten Dokumente als Menüelemente auflisten zu lassen, so dass der Benutzer damit leichter ein Dokument zur Arbeit auswählen kann. Menüs bilden in MDI-Anwendungen ein recht interessantes Thema. Sowohl übergeordnete als auch untergeordnete Dokumente können über verknüpfte Menüs verfügen, doch die Probleme beginnen, wenn die beiden miteinander verschmelzen müssen. Doch die Eigenschaften MergeType und MergeOrder lösen diese Probleme, weil Sie damit die Anwendung instruieren können, welche Menüs auf welche Weise angezeigt werden sollen. Um das aktuelle bzw. aktive untergeordnete Fenster in einer MDI-Anwendung zu entdecken, rufen Sie die ActiveMdiChild-Eigenschaft des übergeordneten Formulars auf. Das MdiChildActivate-Ereignis wird ausgelöst, wenn ein untergeordnetes Fenster aktiviert wird. Sie können auf die in den untergeordneten Dokumenten enthaltenen Steuerelemente zugreifen, indem Sie die Controls-Eigenschaft des untergeordneten Objekts verwenden; denken Sie jedenfalls daran, den zurückgelieferten Wert bei Bedarf zu konvertieren.

372

Fragen und Antworten

10.5 Fragen und Antworten F

Wenn ich eine bestimmte Anzahl von Fenstern geöffnet habe (etwa vier oder fünf), dann ordnen die Befehle zum Neben- und Untereinanderlegen die Fenster auf gleiche Weise an. Was ist der Grund dafür? A

Die Anwendung versucht, die Fenster so anzuordnen, dass der vorhandene Platz am wirtschaftlichsten ausgenutzt wird. Sie versucht jedes untergeordnete Fenster größtmöglich anzuzeigen. Je nach der Bildschirmgröße erzeugt das Nebeneinanderlegen eine zweite Fensterspalte, wenn mehrere Fenster geöffnet sind; doch ab einem bestimmten Punkt des Aufteilens der jeweiligen Höhe kann man außer der Titelzeile jedes untergeordneten Fensters nichts mehr sehen. Der Punkt, an dem eine zweite Spalte (bzw. eine Zeile beim Untereinanderlegen) erzeugt wird, kann sowohl für Neben- als auch Untereinanderlegen der gleiche sein. In bestimmten Situationen bleibt nur noch eine Möglichkeit übrig, um Fenster anzuordnen, und sowohl Neben- als auch Untereinanderlegen nutzen diese eine Möglichkeit.

F

Wie veranlasse ich meine untergeordneten Fenster dazu, in einer Ecke oder an einer Seite des übergeordneten Dokuments anzudocken? A

Leider ist das Andocken von untergeordneten Fenstern nicht so einfach, wie es aussieht. Die Dock-Eigenschaft wirkt sich auf Form-Objekte nicht so aus wie auf andere Steuerelemente, so dass die Verwendung eines DockStyle-Wertes nichts bewirkt und die in vielen Anwendungen übliche »Einrastfunktion« nicht verfügbar ist. Eine Methode besteht darin, einen Ereignishandler für das LocationChangedEreignis des untergeordneten Fensters zu erstellen. Wird dieses Ereignis ausgelöst, können Sie die Position des fraglichen untergeordneten Fensters auswerten, und falls es sich in einem bestimmten Bereich (sagen wir, 10 Pixel vom linken Rand des übergeordneten Fensters entfernt) befindet, können Sie die Position und Größe anpassen, um den Eindruck des Andockens und »Einrastens« zu vermitteln. Ein typischer Ereignishandler würde wie folgt aussehen: private void SnapIt(Object Sender, EventArgs e) { Form frmTemp = (Form)Sender; if (frmTemp.Location.X < 10 & frmTemp.Location.Y < 10) { frmTemp.Location = new Point(0,0); frmTemp.Size = new Size(100,550); } }

Beachten Sie, dass diese Methode das untergeordnete Fenster nicht direkt andockt, aber zumindest eine gute Alternative dazu bietet.

373

MDI-Anwendungen erstellen

F

Ich habe ein untergeordnetes Fenster vom Symbolleistentyp erstellt, doch ich kann es nicht über die Grenzen des übergeordneten Fensters hinaus bewegen. In Photoshop und Visual Studio geht das jedoch. Was ist los? A

In diesen anderen Anwendungen haben Sie es nicht wirklich mit untergeordneten MDI-Fenstern zu tun. Vielmehr handelt es sich bei diesen Symbolleisten um angepasste Dialogfeldklassen, die sich an jede beliebige Position bewegen lassen und daher nicht einmal an die Grenzen des übergeordneten Fensters gebunden sind. Sollten Sie also eine Methode der anderen vorziehen? Die Antwort hängt von der zu erstellenden Anwendung ab. Wenn Sie zudem die Arbeitsfläche des Benutzers nicht überladen wollen, wäre es eine gute Idee, statt benutzerdefinierten Dialogfeldern untergeordnete MDI-Fenster anzulegen.

10.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. Welche Eigenschaft müssen Sie im übergeordneten MDI-Formular einstellen, um es zu einer MDI-Anwendung zu machen? 2. Welche Eigenschaft müssen Sie im untergeordneten MDI-Dokument einstellen, um es zum Bestandteil einer MDI-Anwendung zu machen? 3. Über welche drei Werte verfügt die Aufzählung MdiLayout? 4. Wahr oder falsch? Sie müssen erst die Show-Methode aufrufen, bevor Sie ein untergeordnetes MDI-Formular anzeigen können, wenn es im Konstruktor seines übergeordneten Formulars erzeugt wird. 5. Der folgende Code veranlasst das TextBox-Steuerelement tbText nicht dazu, das gesamte Formular auszufüllen: TextBox tbText = new TextBox(); tbText.Dock = DockStyle.Fill;

Warum nicht?

374

Workshop

6. Wie findet man heraus, ob ein untergeordnetes MDI-Fenster aktiv ist? 7. Sie haben drei Menüelemente in einem untergeordneten Dokument erzeugt, aber sie werden im übergeordneten Dokument nicht richtig angezeigt. Nennen Sie drei Dinge, die man zur Behebung dieses Problems prüfen sollte. 8. Wahr oder falsch? Der MergeOrder-Wert muss sich schrittweise erhöhen lassen; Sie können keine Werte in der Reihenfolge überspringen.

Übung Erstellen Sie eine MDI-Version der gestrigen Anwendung für die Ausführung von SQLStatements. Erzeugen Sie ein benutzerdefiniertes Dialogfeld, das ein Textfeld anzeigt, in dem der Benutzer seine Abfrage eingeben kann.

375

Arbeiten mit der Windows-Ein-/ Ausgabe

1 1

Arbeiten mit der Windows-Ein-/Ausgabe

Das Arbeiten mit Ein- und Ausgabe (E/A) ist ein wichtiger Bestandteil des Umgangs mit jedem Betriebssystem. Dazu gehört mehr als nur das Lesen und Schreiben von Dateien. E/A umfasst auch Drucken, Netzwerkzugang, Überwachung von Änderungen im Dateisystem und so weiter. Die heutige Lektion konzentriert sich auf verschiedene Aspekte der E/A in .NET Windows Forms. Sie werden erkennen, dass .NET den einst komplizierten Vorgang einfach gemacht hat, so dass Sie in kürzester Zeit Dokumente speichern werden! Heute lernen Sie, 쐽

was Streams sind und wie man sie verwendet,

쐽

wie man Streams liest und in sie schreibt,

쐽

wie man eine Oberfläche im Explorer-Stil erstellt,

쐽

wie man Textdateien bearbeitet,

쐽

die am Drucken eines Dokuments beteiligten Arbeitsschritte.

11.1 Einführung in Streams Was ist eine Datei? Vom Standpunkt des Benutzer aus stellt eine Datei eine Information auf der Festplatte eines Computers dar. Sie hat einen Namen, einen Verzeichnispfad und eine Namenserweiterung; ihre Eigenschaften wie etwa Größe, Erstellungsdatum usw. lassen sich leicht ablesen. Wenn ein Benutzer eine Datei erstellt, geht er davon aus, dass sie nicht verschwinden, sondern auf die Festplatte geschrieben wird, es sei denn, eine Katastrophe träte ein. Für den Entwickler hingegen sieht eine Datei ein wenig anders aus. Man muss in Begriffen von Bits und Bytes denken, so dass eine Datei im Grunde eine Sammlung von Einsen und Nullen ist, die auf der Festplatte gespeichert wird. Damit eine bestimmte Ansammlung von Bits einen Sinn ergibt, müssen sie auf eine bestimmte Art und Weise angeordnet sein, und unterschiedliche Dateitypen weisen jeweils ihre gesonderten Schemas auf. Eine Datei ist stets mit einer Position oder Verzeichnisstruktur auf dem Computer verknüpft. Dieser Mechanismus eignet sich hervorragend für den normalen Gebrauch und ist perfekt, wenn es um vordefinierte Speichermechanismen geht. Wenn man weiß, welche Dateien man verwenden wird, erweist sich dieses Verfahren der sequentiellen Speicherung von Bits als ideal. Es hat jedoch auch seine Unzulänglichkeiten. Die herkömmliche Ein-/Ausgabe befasst sich nur mit der E/A von Dateien und kann keinen anderen Speichermechanismus handhaben. Man muss die richtige Bitsequenz und häufig sogar den Verzeichnispfad liefern, damit sie richtig funktioniert. Auf Grund der Natur eines Betriebssystems wie Win-

378

Einführung in Streams

dows und der Neigung der Benutzer, stets das Unerwartete zu tun, ist dieser Systemtyp anfällig für Fehler. Das .NET Framework führt erstmals den Begriff Stream (Strom) ein. Zwischen einem Stream und einer Datei gibt es einen Hauptunterschied: Ein Stream kann von überallher stammen und er muss nicht auf der Festplatte gespeichert werden wie eine Datei. Er kann aus dem Speicher kommen, aus einem Netzwerk, von der Sicherheitskopie auf einem Bandlaufwerk usw. Die Position ist willkürlich, genau wie die Datenquelle für ein DataSet. Diese Position wird als der Sicherungsspeicher eines Streams bezeichnet. Der wichtigste Aspekt an einem Stream, den man sich merken sollte, ist der, dass es sich lediglich um einige Daten handelt, die von einer Quelle unabhängig sind. Auf diese Weise muss sich ein Entwickler nicht mit den Schwierigkeiten beim Umgang mit einer bestimmten Datenquelle herumschlagen. Die Art und Weise, wie ein Stream genau funktioniert, mag Sie ein wenig verwirren. Er lädt nicht die gesamte Datenquelle in den Speicher und er lässt die Datenquelle auch nicht im bekannten Internetsinne »strömen« (wie etwa ein Streaming-Video). Stellen Sie sich einen Stream vielmehr als Ihren persönlichen Butler vor. Er ist der Vermittler zwischen Ihnen und den verknüpften Daten und umgekehrt. Somit kann Ihr Butler Daten zur Datenquelle bringen und von dort welche holen. Er kann Ihnen Elemente der Quelle entweder in der Reihenfolge bringen, wie er sie antrifft oder in jeder anderen Weise, die Sie wählen; Sie könnten ihm etwa befehlen, ein Mittelstück aus einer Quelle zu besorgen. Abbildung 11.1 illustriert dieses Verteilungssystem.

nDate e quell

Strom

nDate e l e u q l

Abbildung 11.1: Ein Stream fungiert als eine Art Butler, um Informationen von Ihnen an eine Datenquelle auszuliefern oder umgekehrt.

Man kann vier verschiedene Arten von Streams verwenden, je nach deren Quelltyp: FileStream, MemoryStream, NetworkStream und CryptoStream (Letzterer ist an kryptographische Daten, die der Sicherheit dienen, geknüpft). Darüber hinaus stellt das Objekt BufferedStream lediglich eine Verbindung zu einem anderen Stream her. Es stellt diesen Streams Pufferfunktionen zur Verfügung. Zudem lassen sich die Streams miteinander verknüpfen, falls einer für eine Aufgabe nicht ausreichen sollte. So können Sie z.B. ein FileStream-Objekt einsetzen, um Daten aus einer Datei zu lesen und dann ein NetworkStream-Objekt, um diese Daten über ein Netzwerk zu übertragen, ohne dabei mittendrin abbrechen zu müssen. Auch hier ist die ursprüngliche Datenquelle gleichgültig; ein Stream lässt sich mit fast allem verbinden.

379

Arbeiten mit der Windows-Ein-/Ausgabe

Diesem Puzzle der Streams fehlt noch ein Stückchen: Streamreader und -writer. Sie helfen Ihnen bei der Interaktion mit den Streaminhalten. Wie ihre Namen andeuten, lesen sie aus oder schreiben in einen Stream. Um auf die Butler-Analogie zurückzukommen: Es kann vorkommen, dass Ihr Butler nicht die gleiche Sprache wie Sie spricht. Daher benötigen Sie einen Übersetzer, der Ihre Befehle an den Butler weitergibt und Sie informiert, was der fremdsprachige Butler zu sagen hat. Stellen wir uns eine konkrete .NET-Situation vor. Angenommen, Sie haben eine XMLDatei. Um die Datei zu öffnen und auf deren Inhalt zuzugreifen, können Sie einen FileStream einsetzen. Als Nächstes benötigen Sie jedoch ein XmlReader-Objekt, das die Informationen aus dem Stream holen kann, wobei es Nullen und Einsen bei diesem Vorgang in XML-Inhalte übersetzt. Alternativ können Sie einen StringReader einsetzen, der den Stream lesen und eine umfangreiche Zeichenfolge liefern könnte. Offensichtlich ist der XmlReader in diesem Fall besser für die Aufgabe geeignet, denn damit können Sie spezifische XML-Funktionen anwenden, die der StringReader nicht anbietet. Abbildung 11.2 illustriert die Kette der Objekte, mit der Sie interagieren müssen, um mit Ein-/Ausgabe unter Windows umzugehen. Leser oder Schreiber

beliebiger Datenspeicher

Strom

Abbildung 11.2: Ihr Stream kann Daten aus einer Datenquelle liefern und ein Reader oder Writer kann Ihnen die Daten in verwendbarem Format liefern.

11.2 Dateien und Verzeichnisse Bevor Sie anfangen, Dateien zu lesen und zu schreiben, müssen Sie wissen, wie Sie mit diesen generischen Objekten umgehen. Mit Hilfe von vier .NET-Objekten können Sie Dateien und Ordner in einem Dateisystem manipulieren: File, FileInfo, Directory und DirectoryInfo. Die Objekte File und FileInfo ähneln einander; sie enthalten zu einem großen Teil die gleichen Mitglieder. Der Unterschied besteht darin, dass das File-Objekt rein statisch ist. Wie Sie wissen, brauchen Sie bei statischen Mitgliedern keine Instanz einer Klasse, um sie verwenden zu können. Sie können daher die File.Copy-Methode benutzen, um eine beliebige Datei von einem Standort zu einem anderen zu kopieren. Das FileInfo-Objekt betrifft nur die aktuelle Instanz einer Datei. Die Methode FileInfo.Copy kopiert die aktuelle Datei. Die gleichen Regeln gelten für die Objekte Directory und DirectoryInfo. Meist werden Sie die Info-Objekte verwenden, da Sie mit spezifischen Dateien und Verzeichnissen umgehen.

380

Dateien und Verzeichnisse

Wir wollen uns ein Beispiel ansehen. Listing 11.1 erzeugt eine Verzeichnisliste im Explorer-Stil, indem es ein Verzeichnis durchläuft und die Elemente einem TreeView-Steuerelement hinzufügt. Listing 11.1: Eine Verzeichnisliste im Explorer-Stil erstellen 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41: 42:

using using using using

System; System.Windows.Forms; System.Drawing; System.IO;

namespace TYWinforms.Day11 { public class Listing111 : Form { private TreeView tvFiles = new TreeView(); private Label lblInfo = new Label(); public Listing111() { tvFiles.Dock = DockStyle.Left; tvFiles.Width = 150; lblInfo.Size = new Size(100,100); lblInfo.Text = " Select a file or\ndirectory"; PopulateList("c: \\", tvFiles.Nodes.Add("c: \\")); this.Controls.Add(tvFiles); this.Controls.Add(lblInfo); } private void PopulateList(String strPath, TreeNode currNode) { DirectoryInfo dir = new DirectoryInfo(strPath); TreeNode nodeSubDir; foreach (DirectoryInfo d in dir.GetDirectories()) { nodeSubDir = currNode.Nodes.Add(d.Name); PopulateList(d.FullName, nodeSubDir); } foreach (FileInfo f in dir.GetFiles("*.*")) { currNode.Nodes.Add(f.Name); } } public static void Main() { Application.Run(new Listing111()); } } }

381

Arbeiten mit der Windows-Ein-/Ausgabe

Listing 11.1 beginnt normal: Ein Steuerelement ListView wird angelegt, mehrere Eigenschaften werden eingestellt und das Formular wird angezeigt. Doch die PopulateList-Methode ist etwas Neues. Die PopulateList-Methode wird als rekursive Methode bezeichnet, da sie immer wieder sich selbst aufruft. Sie beschafft Informationen über das im ersten Parameter angegebene Verzeichnis. Wird sie das erste Mal aufgerufen (wie in Zeile 18), ist das Verzeichnis C: bzw. das Stammverzeichnis. Zeile 26 legt ein temporäres Objekt an, das wir gleich verwenden. Das DirectoryInfo-Objekt in Zeile 25 enthält einige Informationen über das aktuelle Verzeichnis. Mit Hilfe der GetDirectories-Methode können Sie alle Unterverzeichnisse herausfinden und mit der GetFiles-Methode auch alle im Verzeichnis enthaltenen Dateien. In Zeile 28 iterieren Sie mit der foreachSchleife durch alle Unterverzeichnisse im aktuellen Verzeichnis. Zeile 29 fügt dem TreeView-Steuerelement einen neuen Knoten hinzu, wobei der Name jedes Unterverzeichnisses verwendet wird. Zeile 30 überspringen wir vorerst. Die FullName-Eigenschaft der Objekte DirectoryInfo und FileInfo liefert den Namen des Objektes einschließlich der kompletten Pfadangabe. Hier ein Beispiel: c:\inetpub\wwwroot\myfile.aspx

Die Name-Eigenschaft liefert hingegen nur den Namen ohne die Pfadangabe: myfile.aspx.

Zeile 33 ähnelt dem bereits Untersuchten. Zu jeder Datei im Verzeichnis fügen Sie der Strukturansicht einfach einen neuen Knoten mit dem jeweiligen Dateinamen hinzu. Nun ist das Dateisystem jedoch hierarchisch aufgebaut; man könnte Unterverzeichnisse bis zum Abwinken einrichten. Ohne Zeile 30 würde diese Methode nur die Unterverzeichnisse und Dateien des Stammverzeichnisses C:\ auflisten; sie geht nicht tiefer. Man braucht also eine Möglichkeit, immer tiefer durch die Unterverzeichnisse zu graben, bis man am Ende anlangt. Da man nicht wissen kann, wie tief die Verzeichnisstruktur auf der Festplatte eines Benutzers reicht, sollte man diese Unterverzeichnisse automatisch ermitteln können. Die PopulateList-Methode erledigt das für Sie. Enthält das aktuelle Verzeichnis keine Unterverzeichnisse, dann werden die Zeilen 28 bis 31 einfach nicht ausgeführt, und es geht weiter. Das Gleiche gilt für die Zeilen 33 bis 35. Es ist also sinnvoll, diese Methode auch für die nächste Ebene von Unterverzeichnissen einzusetzen. In Zeile 30 rufen Sie wieder die PopulateList-Methode auf, wobei Sie ihr die Pfadangabe des aktuellen Unterverzeichnisses und den Knoten im Hierarchiebaum übergeben. Wird die Methode diesmal ausgeführt, holt sie sich die Informationen über das Unterverzeich-

382

Dateien und Verzeichnisse

nis, fügt es unter dem aktuellen Knoten ein und durchläuft seine Unterverzeichnisse und Dateien wie sonst auch. Stößt der Vorgang auf ein weiteres Unterverzeichnis, wird dafür die PopulateList-Methode erneut aufgerufen und so weiter. Auf diese Weise können Sie alle Verzeichnisse und Dateien auf der Festplatte durchlaufen, ohne im Voraus wissen zu müssen, wie tief die Struktur reicht. Rekursion ist also für Ein- und Ausgabe von Dateien von hoher Bedeutung. Tabelle 11.1 erklärt den Ablauf ein bisschen detaillierter. Aktuelles Verzeichnis und aktueller Knoten

Übrige Unterverzeichnisse

Aktion

C:\

ASPNET, Windows

Durchlaufe das erste Unterverzeichnis in C:\

C:\ASPNET

Keine

Liste die Dateien in C:\ASPNET auf, falls sie verfügbar sind; gehe zurück zum übergeordneten Verzeichnis.

C:\

Windows

Durchlaufe das zweite Unterverzeichnis in C:\

C:\Windows

Wallpaper, System32

Durchlaufe das erste Unterverzeichnis in C:\Windows

C:\Windows\Wallpaper

Keine

Liste die Dateien in C:\Windows\Wallpaper auf, falls sie verfügbar sind; gehe zurück zum übergeordneten Verzeichnis.

C:\Windows

System32

Durchlaufe das zweite Unterverzeichnis in C:\Windows

C:\Windows\System32

Keine

Liste die Dateien in C:\Windows\System32 auf, falls sie verfügbar sind; gehe zurück zum übergeordneten Verzeichnis.

C:\Windows

Keine

Liste die Dateien in C:\Windows auf, falls sie verfügbar sind; gehe zurück zum übergeordneten Verzeichnis.

C:\

Keine

Liste die Dateien in C:\ auf, falls sie verfügbar sind; brich ab.

Tabelle 11.1: Der Ablauf der Rekursion

Abbildung 11.3 zeigt das Ergebnis dieser Anwendung. Beachten Sie, dass das Durchlaufen aller Verzeichnisse auf Ihrer Festplatte eine Weile dauern kann, so dass sich die Anwendung nicht sofort öffnet. Um diesen Vorgang zu beschleunigen, können Sie zur Laufzeit diese Baumstruktur erstellen lassen statt während der Initialisierung. Mit anderen Worten: Iterieren Sie durch ein Unterverzeichnis und seine Dateien nur dann, wenn der Benutzer

383

Arbeiten mit der Windows-Ein-/Ausgabe

diesen Knoten expandiert; so müssen Sie nur eine Ebene auf einmal bewältigen, und die Ausführung wird erheblich beschleunigt. Diese Aufgabe ist eine Übung für Sie.

Abbildung 11.3: Listing 11.1 erzeugt diese Explorer-ähnliche Anwendung.

Wenn Sie den Code in Listing 11.1 ausführen, könnten Sie eine Fehlermeldung erhalten, weil Sie nicht die Berechtigung haben, auf die Informationen aller Verzeichnisse und Dateien zuzugreifen. Sie können den Suchbereich auf ein bestimmtes Verzeichnis eingrenzen, indem Sie die GetDirectoriesMethode in Zeile 28 entsprechend ändern: .GetDirectories("windows*")

Diese Methode bringt die Anwendung dazu, nur solche Verzeichnisse aufzulisten, die das Wort windows im Namen aufweisen. Höchstwahrscheinlich lässt sich dadurch Ihr Berechtigungsproblem umgehen. An Tag 21 lernen Sie eine bessere Möglichkeit kennen. Wir wollen diese Anwendung erweitern, um den Umgang mit Datei- und Verzeichnisobjekten besser in den Griff zu bekommen. Fügen Sie in den Konstruktor folgenden Code ein: tvFiles.AfterSelect += new TreeViewEventHandler(this.DisplayInfo);

Wählt nun ein Benutzer einen Knoten in der Strukturansicht aus, können Sie ihm im Bezeichnungsfeld gemäß Zeile 9 von Listing 11.1 zusätzliche Informationen anzeigen. Listing 11.2 zeigt die DisplayInfo-Methode. Listing 11.2: Dem Benutzer Informationen anzeigen 1: 2: 3: 4: 5: 6:

384

private void DisplayInfo(Object Sender, TreeViewEventArgs e) { TreeNode tempNode = e.Node; String strFullName = tempNode.Text; while (tempNode.Parent != null) { strFullName = tempNode.Parent.Text + "\\" + strFullName;

Dateien und Verzeichnisse

7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21:

tempNode = tempNode.Parent; } if (File.Exists(strFullName)) { FileInfo obj = new FileInfo(strFullName); lblInfo.Text = "Name: " + obj.Name; lblInfo.Text += "\nGröße: " + obj.Length; lblInfo.Text += "\nZugriff: " + obj.LastAccessTime.ToString(); } else { DirectoryInfo obj = new DirectoryInfo(strFullName); lblInfo.Text = "Name: " + obj.Name; lblInfo.Text += "\nAttribute: " + obj.Attributes.ToString(); lblInfo.Text += "\nZugriff: " + obj.LastAccessTime.ToString(); } }

Das TreeViewNodeEventArgs-Objekt liefert dasjenige TreeNode-Objekt, das angeklickt wurde. In Zeile 2 speichern Sie dieses Objekt in einer Variablen zur späteren Verwendung. Dann holen Sie die Beschriftung in Zeile 3. Als Nächstes müssen Sie den vollen Pfadnamen desjenigen Knotens suchen, der angeklickt wurde, so dass Sie die Datei oder das Verzeichnis korrekt ermitteln können, um die entsprechenden Informationen hierzu anzuzeigen. Um den Pfadnamen zu suchen, verwenden Sie eine while-Schleife, die die ParentEigenschaft des aktuellen Knotens prüft. Gibt es keine übergeordneten Knoten (das wäre im Stammverzeichnis der Fall), wird die Parent-Eigenschaft den Wert null liefern und Sie wissen, dass Sie den vollen Pfadnamen haben. In der Schleife hängen Sie einfach den Namen jedes übergeordneten Knotens in die Zeichenfolge ein und bewegen sich eine Stufe höher. Der nächste Codeabschnitt bestimmt das zu behandelnde Objekt, sei es nun eine Datei oder ein Verzeichnis. Die File.Exists-Methode bestimmt, ob der angegebene Pfad auf eine Datei zeigt. Ist dies der Fall, zeigen Sie diverse Informationen über die Datei im Bezeichnungsfeld an, wie in den Zeilen 11 bis 14 zu sehen. Existiert die Datei jedoch nicht, wissen Sie, dass es sich statt dessen um ein Verzeichnis handelt, so dass Sie entsprechend andere Informationen anzeigen (Zeilen 16 bis 19). Werfen Sie nun einen weiteren Blick auf die Applikation, wie sie in Abbildung 11.4 zu sehen ist. Tabelle 11.2 führt die Mitglieder des FileInfo-Objekts auf.

385

Arbeiten mit der Windows-Ein-/Ausgabe

Abbildung 11.4: In Ihrem Explorer können Sie auch Rückmeldungen anbieten. Eigenschaft

Beschreibung

Attributes

Liefert die Dateiattribute. Kann einen der Werte der FileAttributes-Aufzählung annehmen: Archive, Compressed, Device, Directory, Encrypted, Hidden, Normal, NonContentIndexed, Offline, ReadOnly, ReparsePoint, SparseFile, System, Temporary.

CreationTime

Gibt Erstellungsdatum und –zeit einer Datei an.

Directory

Gibt ein DirectoryInfo-Objekt an, das das übergeordnete Verzeichnis dieser Datei darstellt.

DirectoryName

Enthält eine Zeichenfolge, die den vollständigen Pfad des übergeordneten Verzeichnisses angibt.

Exists

Gibt an, ob die Datei gültig ist.

Extension

Legt die Dateierweiterung fest.

FullName

Gibt den Dateinamen inklusive Pfadangabe an.

LastAccessTime

Gibt Datum und Zeit des letzten Dateizugriffs an.

LastWriteTime

Gibt Datum und Zeit des letzten Schreibzugriffs an.

Length

Gibt die Dateigröße an.

Name

Gibt den Dateinamen exklusive Pfadangabe an.

Methode

Beschreibung

AppendText

Erzeugt einen StreamWriter, mit dem man Text an die Datei anhängen kann.

Tabelle 11.2: FileInfo-Eigenschaften

386

Dateien und Verzeichnisse

Eigenschaft

Beschreibung

CopyTo

Kopiert die Datei an einen neuen Speicherplatz.

Create

Legt die Datei an.

CreateText

Legt die Datei und einen StreamWriter an, der in die Datei schreiben kann.

Delete

Löscht die Datei.

MoveTo

Verschiebt die Datei an einen neuen Speicherort.

Open

Öffnet die Datei mit diversen Berechtigungen.

OpenRead

Erzeugt für diese Datei ein schreibgeschütztes FileStream-Objekt.

OpenText

Erzeugt für diese Datei ein FileStream-Objekt mit Lese-/Schreibzugriff.

Tabelle 11.2: FileInfo-Eigenschaften (Forts.)

Tabelle 11.3 führt die verschiedenen Mitglieder des DirectoryInfo-Objekts auf. Ihnen fällt sicher auf, dass es einige Eigenschaften mit dem FileInfo-Objekt gemeinsam hat. Eigenschaft

Beschreibung

Attributes

Liefert die Verzeichnisattribute. Kann einen der Werte der FileAttributesAufzählung annehmen: Archive, Compressed, Device, Directory, Encrypted, Hidden, Normal, NonContentIndexed, Offline, ReadOnly, ReparsePoint, SparseFile, System, Temporary.

CreationTime

Gibt Erstellungszeit und -datum für das Verzeichnis an.

Exists

Gibt an, ob dieses Verzeichnis gültig ist.

Extension

Gibt die Namenserweiterung des Verzeichnisses an.

FullName

Gibt den Verzeichnisnamen inklusive Pfadangabe an.

LastAccessTime

Gibt Datum und Zeit des letzten Verzeichniszugriffs an.

LastWriteTime

Gibt Datum und Zeit des letzten Schreibzugriffs auf das Verzeichnis an.

Name

Gibt den Verzeichnisnamen exklusive Pfadangabe an.

Parent

Liefert ein DirectoryInfo-Objekt, das das übergeordnete Verzeichnisses dieses Verzeichnisses darstellt.

Root

Liefert ein DirectoryInfo-Objekt, das die Wurzel dieses Verzeichnisses darstellt.

Tabelle 11.3: Die Mitglieder von DirectoryInfo

387

Arbeiten mit der Windows-Ein-/Ausgabe

Eigenschaft

Beschreibung

Methode

Beschreibung

Create

Erstellt das Verzeichnis.

CreateSubDirectory

Erstellt das Verzeichnis und liefert ein DirectoryInfo-Objekt, das das neue Verzeichnis darstellt.

Delete

Löscht das Verzeichnis.

GetDirectories

Holt ein Array von DirectoryInfo-Objekten, die alle Unterverzeichnisse des aktuellen Verzeichnisses darstellen.

GetFiles

Holt ein Array von FileInfo-Objekten, die alle Dateien des aktuellen Verzeichnisses darstellen.

GetFileSystemInfos

Holt ein Array von FileSystemInfo-Objekten, die alle Dateien und Verzeichnisse darstellen.

MoveTo

Verschiebt die Datei an einen neuen Speicherplatz.

Tabelle 11.3: Die Mitglieder von DirectoryInfo (Forts.)

Dateien lesen und schreiben Gleichgültig, ob die Datei, die Sie verarbeiten wollen, nun binär ist oder aus reinem Text besteht, so bleibt doch die Vorgehensweise beim Lesen und Schreiben die gleiche: Man hängt ein Streamobjekt des erforderlichen Typs an und hängt diesem wiederum einen Reader oder Writer zwecks Dateizugriff an. Darüber hinaus haben alle Reader und Writer die gleichen allgemeinen Mitglieder – wenn Sie wissen, wie Sie eines verwenden, können Sie alle verwenden. Wir wollen uns ein Beispiel für das Schreiben einer Textdatei ansehen. Listing 11.3 zeigt eine einfache Anwendung, in die der Benutzer einen Dateinamen zwecks Erstellung eingeben kann. Diese Textdatei wird mit dem Text "Hello World!" darin erstellt. Listing 11.3: Eine Datei erzeugen 1: 2: 3: 4: 5: 6: 7:

388

using using using using

System; System.Windows.Forms; System.Drawing; System.IO;

namespace TYWinforms.Day11 { public class Listing112 : Form {

Dateien und Verzeichnisse

8: private Button btCreate = new Button(); 9: private TextBox tbFileName = new TextBox(); 10: 11: public Listing112() { 12: tbFileName.Location = new Point(25,100); 13: tbFileName.Width = 150; 14: 15: btCreate.Text = "Erstellen!"; 16: btCreate.Location = new Point(200,100); 17: btCreate.Click += new EventHandler(this.CreateFile); 18: 19: this.Text = "Listing 11.2"; 20: this.Controls.Add(btCreate); 21: this.Controls.Add(tbFileName); 22: } 23: 24: public void CreateFile(Object Sender, EventArgs e) { 25: String strFilename = tbFileName.Text; 26: 27: if (!File.Exists(strFilename)) { 28: FileStream objFile = new FileStream(strFilename, FileMode.CreateNew); 29: StreamWriter objWriter = new StreamWriter(objFile); 30: 31: objWriter.WriteLine("Hello World!"); 32: 33: objWriter.Close(); 34: objFile.Close(); 35: 36: MessageBox.Show("Fertig!"); 37: } 38: } 39: 40: public static void Main() { 41: Application.Run(new Listing112()); 42: } 43: } 44: }

Wir wollen den Konstruktor in Listing 11.3 überspringen; das einzige Interessante daran ist die Zuweisung des Delegaten in Zeile 17. Alle Aktionen beginnen in der CreateFile-Methode ab Zeile 24. Dieser Code setzt voraus, dass der Benutzer etwas Text in die TextBox eingegeben hat. In Zeile 27 prüfen Sie, ob die angegebene Datei bereits existiert. Ist das der Fall, sollten Sie sie in Ruhe lassen. Gibt es sie noch nicht, dürfen Sie fortfahren.

389

Arbeiten mit der Windows-Ein-/Ausgabe

Zeile 28 legt ein FileStream-Objekt an, um mit der Datei zu interagieren. Der Konstruktor dafür übernimmt einige Parameter. Der erste ist natürlich der Pfad zu der fraglichen Datei. Der zweite ist optional und spezifiziert den Modus, mit dem die Datei geöffnet wird. Er kann einen der Werte der FileMode-Aufzählung annehmen: 왘

Append: Öffnet die Datei, falls sie existiert, und bewegt sich bis zum Ende der Datei. Ist sie jedoch nicht vorhanden, wird eine neue Datei angelegt.

왘

Create: Legt eine neue Datei an. Ist sie bereits vorhanden, wird sie überschrieben.

왘

CreateNew: Legt eine neue Datei an. Ist sie bereits vorhanden, wird eine

Fehlermeldung ausgegeben. 왘

Open: Öffnet eine vorhandene Datei.

왘

OpenOrCreate: Öffnet die Datei, falls sie vorhanden ist. Falls nicht, wird eine

neue Datei angelegt. 왘

Truncate: Öffnet eine vorhandene Datei und löscht jeden vorhandenen

Inhalt. Im Code legen Sie FileMode.CreateNew so fest, dass eine neue Datei unter Verwendung des in der TextBox angegebenen Pfadnamens angelegt wird. Nun da Sie für Ihre Datei einen Stream haben, müssen Sie einen Writer erstellen, der Daten in sie schreibt. Da wir mit Informationen in reinem Text umgehen, erstellen wir in Zeile 29 einen StreamWriter. Der Konstruktor dieses Objekts übernimmt nur einen Parameter, nämlich den Stream, dem der Writer zuzuordnen ist. Die WriteLine-Methode in Zeile 31 schreibt den angegebenen Text in den Stream (und daher in die Datei) und hängt ein Zeilenabschlusszeichen an das Ende der Zeichenfolge an. Die Write-Methode hingegen hängt kein Zeichen für den Zeilenabschluss an. Schließlich müssen Sie daran denken, die Close-Methoden sowohl für den Writer als auch den Stream aufzurufen, damit die Anwendung weiß, dass Sie damit fertig sind, und sie daher wertvolle Systemressourcen freigeben kann. In Zeile 36 wird ein Meldungsfeld angezeigt, um dem Benutzer mitzuteilen, dass die Aufgabe erledigt ist. Kompilieren Sie nun die Anwendung und führen Sie sie aus. Tragen Sie einen gültigen Pfadnamen ein (z.B. C:\temp\blubb.txt) und klicken Sie auf die Schaltfläche ERSTELLEN. Wenn Sie in das angegebene Verzeichnis wechseln, sehen Sie eine neue Textdatei, die die Wörter "Hello World" enthält.

390

Dateien und Verzeichnisse

Lassen Sie uns für einen Moment zurückgehen und uns den Konstruktor für das Streamobjekt ansehen. Dieser flexible Konstruktor kann alle möglichen Parameter übernehmen. So sind z.B. alle folgenden Zeilen gültig: new FileStream(strFilename, new FileStream(strFilename, new FileStream(strFilename, new FileStream(strFilename, FileShare.None,1024,true);

FileMode.CreateNew); FileMode.Create, FileAccess.Read); FileMode.Create, FileAccess.Read, FileShare.None); FileMode.Create, FileAccess.Read,

Den ersten Konstruktor kennen Sie bereits. Der zweite erlaubt Ihnen die Funktionen festzulegen, die der Stream an der Datei ausführen kann. Dabei können Sie die Werte der Aufzählung FileAccess nutzen, die Read, ReadWrite und Write lauten. Der dritte Konstruktor fügt dieser Liste einen weiteren Aufzählungswert aus FileShare hinzu. Dieser Wert bestimmt, wie andere Streamobjekte zur gleichen Zeit wie Sie auf diese Datei zugreifen können. Die Werte können None, Read, ReadWrite oder Write sein. Ein FileShare.None-Wert bedeutet, dass anderen Streams der Zugriff auf diese Datei verwehrt wird, während Sie mit ihr arbeiten. Der letzte Konstruktor fügt zwei weitere Parameter hinzu. Der erste zeigt die Puffergröße in Byte an, die für die Datei zu verwenden ist. Das Setzen eines Pufferspeichers kann die Performanz verbessern. Der zweite Parameter gibt an, ob die Arbeitsschritte asynchron ausgeführt werden sollen; dazu mehr im Unterkapitel »Asynchrone Ein-/Ausgabe«. Die Erstellung des Streamobjekts ist der komplizierteste Teil des Listings 11.3. Doch die Verwendung des Writers ist einfach, denn man kann nur zwischen zwei Methoden wählen: Write oder WriteLine. Wir wollen diesem Listing einen Reader hinzufügen. Zu diesem Zweck modifizieren wir den if-Block in Zeile 27 des Listings 11.3 so, dass er ein else-Statement umfasst: } else { FileStream objFile = new FileStream(strFilename, FileMode.Open, FileAccess.Read); StreamReader objReader = new StreamReader(objFile);

String strContents = objReader.ReadToEnd(); objReader.Close(); objFile.Close(); MessageBox.Show(strContents); }

391

Arbeiten mit der Windows-Ein-/Ausgabe

In diesem Fall ist bekannt, dass die Datei existiert. Sie erzeugen wie zuvor ein FileStreamObjekt und benutzen die gleiche Pfadangabe. Statt eines StreamWriters erzeugen Sie jedoch diesmal einen StreamReader. Die Syntax ist identisch. Als Nächstes rufen Sie die Methode ReadToEnd des Readers auf, um den gesamten Dateiinhalt zurückzugeben. Dann schließen Sie Reader und Stream und zeigen den Inhalt der Datei in einem Meldungsfeld an. Führen Sie nun die Anwendung erneut aus, geben Sie den zuvor benutzten Dateinamen an und klicken Sie auf die Schaltfläche ERSTELLEN. Statt einer »Erledigt!«-Meldung erscheint nun ein Meldungsfeld mit dem entsprechenden Dateiinhalt. Bearbeiten Sie diese Datei manuell und versuchen Sie es erneut. Im Meldungsfeld erscheint nun der neue Inhalt. Abbildung 11.5 zeigt ein Beispiel für ein mögliches Ergebnis.

Abbildung 11.5: Bei Verwendung von Streams können Sie Textdateien leicht lesen und schreiben.

Das StreamReader-Objekt verfügt über eine größere Anzahl Methoden für das Lesen von Streams, als der StreamWriter für das Schreiben von Streams. Ihnen ist bereits die Methode ReadToEnd begegnet, die den Gesamtinhalt einer Datei liefert. ReadLine liefert jeweils nur eine Zeile dieser Datei, ReadBlock liest eine festgelegte Menge von Zeichen, die an einem bestimmten Punkt beginnt, und legt die zurückgegebenen Daten in einem Array ab. Der Ausdruck ReadBlock(buffer, 0, 100) etwa liest vom ersten bis zum 100. Zeichen und legt diese Menge im char-Array buffer() ab. Erreichen Sie das Dateiende vor dem 100. Zeichen, liefert die Methode einfach nur das, was verfügbar ist. Die einfache Read-Methode liest aus dem Stream nur jeweils ein Zeichen. Ein Zeiger wird zum nächsten Zeichen bewegt, sobald Sie diese Methode aufrufen, so dass das nächste Zeichen beim nächsten Read-Aufruf geliefert wird. Read kann sich ebenfalls wie die ReadBlockMethode verhalten, wenn Sie ihr ein char-Array sowie Anfangs- und Endwerte übergeben. Die Peek-Methode ähnelt wiederum Read: Sie holt das nächste Zeichen aus dem Stream, verschiebt aber den Zeiger nicht. Diese Methode wird am häufigsten dazu benutzt, um festzustellen, ob der fragliche Stream noch weiteren Inhalt aufweist. Ist das nicht der Fall, liefert Peek den Wert –1.

392

Dateien und Verzeichnisse

Es stehen Ihnen zahlreiche Typen von Readern und Writern zur Verfügung. Bislang haben Sie nur StreamReader und StreamWriter in Aktion gesehen, die Text lesen/schreiben können. In gleicher Weise können StringReader und StringWriter Zeichenfolgen lesen/ schreiben. HttpWriter kann Ausgaben an einen Web-Browser schreiben. In ASP.NET verwenden Sie HtmlTextWriter, um HTML auch in Browsern wiederzugeben. BinaryReader und BinaryWriter lesen und schreiben Binärdaten. Schlagen Sie in der Dokumentation zum .NET Framework nach, um mehr Informationen über diese Reader und Writer zu finden. Da Sie aber bereits StreamReader und StreamWriter kennen, wissen Sie, wie die meisten funktionieren.

Binärdaten lesen und schreiben Die zu lesenden Dateien kommen nicht immer im Textformat daher; vielmehr enthalten sie häufig Binärdaten. Diese können Sie nicht ohne die Hilfe eines Computers lesen. Beispielswiese verwenden Datenbanken häufig das Binärformat, um Platz zu sparen und ihre Inhalte vor neugierigen Blicken zu schützen. Doch keine Sorge: .NET ist vollständig in der Lage, selbst Binärdaten zu lesen und zu schreiben. Und Sie wissen bereits, wie das geht. Wir wollen eine Beispielanwendung erstellen, die Binärdaten lesen und schreiben kann. Sie ist in Listing 11.4 zu sehen. Listing 11.4: Im Binärformat arbeiten 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20:

Imports Imports Imports Imports

System System.Windows.Forms System.Drawing System.IO

Namespace TYWinForms.Day11 Class Listing114 : Inherits Form private btWriteIt As New Button() private btReadIt As New Button() private nudHigh As New NumericUpDown() private nudLo As New NumericUpDown() private dtpDate As New DateTimePicker() private lblHigh As New Label() private lblLo As New Label() Public Sub New() lblLo.Text = "Tiefe Temp" lblLo.Location = new Point(10,10) nudLo.Location = new Point(110,10)

393

Arbeiten mit der Windows-Ein-/Ausgabe

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: 51: 52: 53: 54: 55: 56: 57: 58: 59: 60: 61: 62: 63: 64: 65:

394

nudLo.Minimum = -100 nudLo.Maximum = 130 lblHigh.Text = "Hohe Temp" lblHigh.Location = new Point(10,40) nudHigh.Location = new Point(110,40) nudHigh.Minimum = -100 nudHigh.Maximum = 130 dtpDate.Location = new Point (10,80) btWriteIt.Text = "Schreiben!" btWriteIt.Location = new Point(30,200) AddHandler btWriteIt.Click, new EventHandler(AddressOf Me.WriteIt) btReadIt.Text = "Lesen!" btReadIt.Location = new Point(120,200) AddHandler btReadIt.Click, new EventHandler(AddressOf Me.ReadIt) Me.Controls.Add(lblLo) Me.Controls.Add(nudLo) Me.Controls.Add(lblHigh) Me.Controls.Add(nudHigh) Me.Controls.Add(dtpDate) Me.Controls.Add(btWriteIt) Me.Controls.Add(btReadIt) End Sub private sub WriteIt(Sender As Object, e As EventArgs) Dim objStream As New FileStream("c: \winforms\day11\records.dat", FileMode.Create) Dim objWriter As New BinaryWriter(objStream) objWriter.Write(CType(nudLo.Value, Short)) objWriter.Write(CType(nudHigh.Value, Short)) objWriter.Write(dtpDate.Value.ToString("d")) objWriter.Close() objStream.Close() end sub private sub ReadIt(Sender As Object, e As EventArgs) Dim strTemp As String Dim lo, hi as Short if not File.Exists("c:\winforms\day11\records.dat") then

Dateien und Verzeichnisse

66: 67: 68: 69: 70: 71: 72: 73: 74: 75: 76: 77: 78: 79: 80: 81: 82: 83: 84: 85: 86: 87:

MessageBox.Show("Die Datei existiert nicht!") Return End If Dim objStream = New FileStream("c:\winforms\day11\records.dat", FileMode.Open, FileAccess.Read) Dim objReader As New BinaryReader(objStream) lo = objReader.ReadInt16() hi = objReader.ReadInt16() strTemp = objReader.ReadString() MessageBox.Show("Höchst- und Tiefsttemperaturen am " & strTemp & " waren " & hi.ToString() & " und " & lo.ToString() ) objReader.Close() objStream.Close() end sub Public Shared Sub Main() Application.Run(new Listing114()) End Sub End Class End Namespace

Dieses Programm holt die Höchst- und Tiefsttemperaturen eines Tages ein und schreibt diese Werte zusammen mit dem Datum in eine Datei. Neben den Schaltflächen für das Schreiben und Lesen einer Datei deklarieren wir weitere Steuerelemente für die Eingabe von Temperaturen und des Datums (Zeilen 9 bis 15). Die Steuerelemente werden initialisiert und im Konstruktor unserem Formular hinzugefügt (Zeilen 18 bis 46). Die WriteIt- und ReadIt-Methoden in den Zeilen 49 bzw. 61 bilden die Ereignishandler für unsere zwei Schaltflächen, die eine neue Binärdatei erzeugen und aus derselben Datei lesen. Mit der WriteIt-Methode beginnt das Anlegen eines FileStream-Objekts in Zeile 50 – nichts Neues für Sie. Auch Zeile 51 ist ähnlich, doch Sie erzeugen statt eines StreamWriters einen BinaryWriter. In den Zeilen 53 bis 55 schreiben Sie im Binärformat die Werte Ihrer Steuerelemente in Ihre Datei. Wir verwenden CType, um die Temperaturen in einen Short-Datentyp zu konvertieren, der weniger Platz beansprucht. Dann benutzen wir einen der DateTime-Formatierungscodes (vgl. Tag 8), um unser Datum in eine Zeichenfolge mit kurzem Datumsmuster (mm/dd/yyyy) umzuwandeln. Die BinaryWriter.Write-Methode wird für mehrere Datentypen überladen, so dass die Aufrufe in den Zeilen 53

395

Arbeiten mit der Windows-Ein-/Ausgabe

und 54 diejenige Version der Methode aufrufen, die einen Short-Datentyp übernimmt, wohingegen der Aufruf in Zeile 55 die String-Version von Write aufruft. In den Zeilen 57 und 58 schließen Sie Writer- und Streamobjekte. Um ein Zwischenergebnis zu erhalten, wollen wir einmal diese Anwendung ausführen und auf die Schaltfläche SCHREIBEN! klicken. Gehen Sie nach der Programmausführung ins Verzeichnis c:\winforms\day11, wo Sie eine neue Datei namens records.dat vorfinden sollten. Öffnen Sie die Datei mit dem Windows-Editor, um folgende Ausgabe vorzufinden: ??????????????

Der Ausgabevorgang weist durchaus keinen Fehler auf. Der Editor kann nur reinen Text verarbeiten und wenn er auf diese Ausgabe im Binärformat stößt, die Sie erstellt haben, weiß er sich nicht anders als mit der Darstellung von Fragezeichen zu helfen. Um Ihnen zu beweisen, dass dies kein Trick ist, kehren Sie zu Listing 11.4 zurück. In Zeile 65 prüfen Sie in der Methode ReadIt, ob diese Datei existiert (sie sollte), doch ist dies nicht der Fall, hört die Subroutine (in Zeile 67) mit der Verarbeitung auf. In Zeile 70 erzeugen Sie ein weiteres FileStream-Objekt für die Datei records.dat und in Zeile 71 einen BinaryReader. Da wir wissen, dass wir gerade zwei Shorts und einen nachfolgenden String geschrieben haben, um die Daten auszugeben, werden wir in den Zeilen 73 bis 75 zwei Shorts und einen String lesen, um die Daten wieder einzulesen. Doch beim Lesen von Binärdaten müssen wir eine andere Methode aufrufen. Da ein Short in VB .NET ein 16-Bit-Integer ist, verwenden wir die Methode ReadInt16 für das Short-Lesen und die Methode ReadString für das String-Lesen. Den sich daraus ergebenden Text zeigen wir in Zeile 77 an und schließen dann (Zeilen 80/81) den Reader und den Stream. Wenn Sie diese Anwendung ausführen und auf die Schaltfläche LESEN! klicken, erscheint ein Meldungsfenster mit etwa folgendem Text: Höchst- und Tiefsttemperaturen am 28.8.2002 waren 44 und 22.

Ihr Binärreader hat also erfolgreich das Binärformat in reinen Text übersetzt. Wenn Sie mit Binärdateien umgehen, ist es von höchster Bedeutung zu wissen, wie deren Inhalt jeweils aufgebaut ist, damit Sie sie richtig auslesen können. Sonst könnten die Ergebnisse unvorsehbar sein.

Serialisierung .NET stellt auch eine Methode bereit, um Objekte zu serialisieren. Serialisierung ist der Vorgang, bei dem der Zustand einer Objektinstanz auf ein Speichermedium übertragen wird. Wenn Sie also etwas serialisieren, dann wandeln Sie es in ein Format um, das sich leicht auf Festplatte speichern oder über das Internet übertragen lässt. Wird ein Objekt serialisiert, speichert man nicht nur

396

Dateien und Verzeichnisse

die public- und private-Mitglieder des Objekts, sondern auch die Metadaten der Klasse selbst. Auf diese Weise kann ein anderes Programm, eventuell auf einem anderen Rechner, diese Daten bei der Deserialisierung zurücklesen und eine exakte Kopie des Originalobjekts erzeugen. Doch die Probleme werden Ihnen auch diesmal in .NET von der CLR abgenommen und daher lässt sich Serialisierung leicht implementieren. Das folgende Beispiel übernimmt die gleichen Daten, die in Listing 11.4 geschrieben und gelesen wurden, doch diesmal wandeln wir diese Daten in eine Klasse um und überlassen der Serialisierung von .NET das Schreiben und Lesen. Listing 11.5: Serialisierung von Binärdaten 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 Imports Imports Imports Imports Imports

System System.Windows.Forms System.Drawing System.IO System.Runtime.Serialization System.Runtime.Serialization.Formatters.Binary

Namespace TYWinForms.Day11 <Serializable()> Class TempRec public loTemp as Short public hiTemp as Short public dateTemp as DateTime End Class Class Listing115 : Inherits Form private btWriteIt As New Button() private btReadIt As New Button() private nudHigh As New NumericUpDown() private nudLo As New NumericUpDown() private dtpDate As New DateTimePicker() private lblHigh As New Label() private lblLo As New Label() Public Sub New() lblLo.Text = "Tiefe Temp" lblLo.Location = new Point(10,10) nudLo.Location = new Point(110,10) nudLo.Minimum = -100 nudLo.Maximum = 130 lblHigh.Text = "Hohe Temp"

397

Arbeiten mit der Windows-Ein-/Ausgabe

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: 66: 67: 68: 69: 70: 71: 72: 73: 74: 75: 76:

398

lblHigh.Location = new Point(10,40) nudHigh.Location = new Point(110,40) nudHigh.Minimum = -100 nudHigh.Maximum = 130 dtpDate.Location = new Point (10,80) btWriteIt.Text = "Schreiben!" btWriteIt.Location = new Point(30,200) AddHandler btWriteIt.Click, new EventHandler(AddressOf Me.WriteIt) btReadIt.Text = "Lesen!" btReadIt.Location = new Point(120,200) AddHandler btReadIt.Click, new EventHandler(AddressOf Me.ReadIt) Me.Controls.Add(lblLo) Me.Controls.Add(nudLo) Me.Controls.Add(lblHigh) Me.Controls.Add(nudHigh) Me.Controls.Add(dtpDate) Me.Controls.Add(btWriteIt) Me.Controls.Add(btReadIt) End Sub private sub WriteIt(Sender As Object, e As EventArgs) Dim objStream As New FileStream("c:\winforms\day11\records.dat", FileMode.Create) Dim objFormatter As New BinaryFormatter() Dim objTempREc As New TempRec() objTempRec.loTemp = nudLo.Value objTempRec.hiTemp = nudHigh.Value objTempRec.dateTemp = dtpDate.Value objFormatter.Serialize(objStream,objTempRec) objStream.Close() end sub private sub ReadIt(Sender As Object, e As EventArgs) if not File.Exists("c:\winforms\day11\records.dat") then MessageBox.Show("Diese Datei existiert nicht!") Return End If

Dateien und Verzeichnisse

77: 78: 79: 80: 81: 82: 83:

84: 85: 86: 87: 88: 89: 90: 91: 92:

Dim objStream = New FileStream("c:\winforms\day11\records.dat", FileMode.Open, FileAccess.Read) Dim objFormatter As New BinaryFormatter() Dim objTempREc As New TempRec() objTempRec = objFormatter.Deserialize(objStream) MessageBox.Show("Höchst- und Tiefsttemperaturen am " & objTempRec.dateTemp.ToString("d") & " waren " & objTempRec.hiTemp. ToString() & " und " & objTempRec.loTemp.ToString() ) objStream.Close() end sub Public Shared Sub Main() Application.Run(new Listing115()) End Sub End Class End Namespace

In den Zeilen 5 und 6 importieren wir die Bibliotheken, die wir für die Implementierung der Serialisierung benötigen. In Zeile 10 erzeugen wir eine neue Klasse namens TempRec und geben ihr das Attribut Serializable. Dieses Attribut bringt .NET dazu, unserer Klasse automatisch die Serialisierungsfunktionalität bereitzustellen. In C# würde das Attribut wie folgt aussehen: [Serializable] class TempRec

Wir halten die Klasse sehr einfach, so dass sie nur drei öffentliche Felder enthält, die unsere Daten aufnehmen sollen. In Zeile 59 deklarieren wir in unserer WriteIt-Methode ein Objekt vom Typ BinaryFormatter, wo wir zuvor BinaryWriter verwendet hatten. In Zeile 60 deklarieren wir ein Objekt unseres TempRec-Typs und initialisieren es in den Zeilen 62 und 63 mit Werten aus unseren Steuerelementen. In Zeile 66 rufen wir die Serialize-Methode unseres BinaryFormatter-Objekts auf und übergeben ihr als Parameter unser FileStream-Objekt und unser TempRec-Objekt. Das BinaryFormatter-Objekt weiß, wie es den Zustand unseres Objekts im Stream speichern soll. Das beweisen wir uns selbst in unserer ReadIt-Methode, in der wir in den Zeilen 78 und 79 wieder ein BinaryFormatter-Objekt und ein TempRec-Objekt deklarieren. In Zeile 81 lesen wir unser Objekt aus der Datei zurück, wobei wir die Deserialize-Methode des BinaryFormatter-Objekts verwenden. In Zeile 83 geben wir die Ergebnisse aus.

399

Arbeiten mit der Windows-Ein-/Ausgabe

Worin besteht also der Sinn der Übung? Sie soll zeigen, dass in .NET nicht nur Daten übertragbar sind, sondern auch Objekte und Klassen. Nun können Sie die Datei records.dat an jeden Adressaten schicken: Sie werden nicht nur die gespeicherten Temperaturdaten erhalten, sondern auch die Klasse, die die Daten enthält. An Tag 15 erfahren Sie etwas über XML-Serialisierung: Statt Objekte in Binärdaten umzuwandeln, werden sie in XML transformiert. Mehr über Serialisierung finden Sie in der .NET Framework Dokumentation.

Das Steuerelement RichTextBox Nun gibt es ein Wiedersehen mit dem Steuerelement RichTextBox (vgl. Tag 6). Damit kann der Benutzer Text wie in einem Textverarbeitungsprogramm eingeben. Sie haben aber noch nicht seine Fähigkeit gesehen, Dateien zu lesen und zu schreiben. Listing 11.6 ist eine vereinfachte Form von Listing 6.9, die das Steuerelement RichTextBox verwendet. Listing 11.6: Wieder mal das Steuerelement RichTextBox 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23:

400

Imports System Imports System.Windows.Forms Imports System.Drawing Namespace TYWinForms.Day11 Public Class Listing116 : Inherits Form private rtbText as New RichTextBox public sub New() rtbText.Dock = DockStyle.Fill rtbText.ScrollBars = RichTextBoxScrollBars.Both Me.Text = "Listing 11.6" Me.Font = New Font("Times New Roman", 10) Me.Controls.Add(rtbText) end sub public shared sub Main() Application.Run(new Listing116) end sub End Class End Namespace

Dateien und Verzeichnisse

Mittlerweile dürfte Ihnen der Code in Listing 11.6 vertraut sein, so dass wir diesmal die Analyse überspringen können. Die zwei Methoden, die Ihnen noch nicht begegnet sind, heißen LoadFile und SaveFile. Die Methode LoadFile übernimmt den Inhalt entweder einer Datei oder eines Stroms und legt ihn in einem RichTextBox-Steuerelement ab, damit ihn der Benutzer bearbeiten kann. So können Sie etwa folgenden Code in den Konstruktor von Listing 11.6 einfügen (der Pfad muss auf eine existente Datei Ihres Computers verweisen): rtbText.LoadFile("c:\temp\happy.text", RichTextBoxStreamType.PlainText)

Der erste Parameter ist die zuvor erstellte Datei (entweder eine Pfadangabe oder ein Stream), und der zweite teilt dem RichTextBox-Steuerelement mit, welchen Typ von Datei es erwarten soll. Die möglichen Werte der RichTextBoxStreamType-Aufzählung sind PlainText, RichNoOleObjs (ein RTF-Stream mit Leerzeichen anstelle von OLE-Objekten), RichText, TextTextOleObjs (ein Stream aus einfachem Text mit einer Textdarstellung von OLE-Objekten) und UnicodePlainText. (OLE-Objekte besprechen wir an Tag 14.) Abbildung 11.6 zeigt die neue Ausgabe der Anwendung, der die LoadFile-Methode hinzugefügt wurde.

Abbildung 11.6: Die LoadFile-Methode kann jede textbasierte Datei in ein RichTextBox-Steuerelement laden.

Die SaveFile-Methode übernimmt exakt die gleichen Parameter und ermöglicht Ihnen das Schreiben oder Erzeugen einer Datei. Jetzt wissen Sie, dass das Steuerelement RichTextBox über E/A-Fähigkeiten verfügt.

401

Arbeiten mit der Windows-Ein-/Ausgabe

11.3 Das Objekt FileSystemWatcher Falls Sie Ihren Computer hinsichtlich Änderungen an Dateien oder Verzeichnissen (Ordnern) überwachen müssen, dann ist FileSystemWatcher das Objekt Ihrer Wahl. Es steht sozusagen Wache und beobachtet alles, was in Ihrem System vor sich geht. Passiert etwas, dann löst das Objekt ein Ereignis aus, dem Sie einen Delegaten zuweisen können, damit die notwendigen Aktionen erfolgen. Angenommen, Sie haben eine Anwendung entwickelt, die eine Verzeichnisliste anlegt (vgl. Listing 11.1). Fügt ein Benutzer neue Dateien hinzu oder löscht Ordner, dann wird die Strukturansicht (TreeView) nicht aktualisiert, um die Änderungen widerzuspiegeln. Mit dem FileSystemWatcher-Objekt können Sie jedoch das TreeView-Steuerelement benachrichtigen, dass solche Änderungen vorgenommen wurden, und je nach Bedarf Knoten hinzufügen oder entfernen. Um einen FileSystemWatcher einzurichten, müssen Sie die zu überwachenden Dateien und Ordner sowie die zu verfolgenden Änderungen angeben und dann das Objekt aktivieren. Das folgende Codestück erledigt alle drei Aufgaben: FileSystemWatcher objWatcher = new FileSystemWatcher(); //geben Sie die zu überwachenden Dateien und Verzeichnisse an objWatcher.Path = "c:\"; objWatcher.Filter = "*.txt "; objWatcher.IncludeSubdirectories =true; //geben Sie die zu überwachenden Änderungen an objWatcher.NotifyFilter = NotifyFilters.LastWrite; //schalten Sie den Beobachter ein objWatcher.EnableRaisingEvents = true;

Die ersten drei Eigenschaften sind praktisch selbsterklärend. Path ist das zu beobachtende Verzeichnis, Filter der zu beobachtende Dateityp in diesem Verzeichnis (also alle Dateien mit der Erweiterung *.txt) und IncludeSubDirectories gibt an, ob auch Unterverzeichnisse überwacht werden sollen. Die nächste Eigenschaft, NotifyFilter, übernimmt Werte aus der NotifyFilter-Aufzählung. Diese lassen sich mit dem Operator | (OR in VB .NET) kombinieren. Dies können folgende Werte sein: 쐽

Attributes: Zeigt an, dass sich eine Änderung an den Datei- oder Verzeichnisattributen ereignet hat.

쐽

CreationTime: Zeigt an, dass die Erstellungszeit einer Datei oder eines Ordners geän-

dert wurde (das jeweilige Objekt wurde also erstellt).

402

Das Objekt FileSystemWatcher

쐽

DirectoryName: Zeigt, dass sich der Ordnername geändert hat.

쐽

FileName: Zeigt, dass sich der Dateiname geändert hat.

쐽

LastAccess: Zeigt an, dass auf eine Datei oder einen Ordner zugegriffen wurde.

쐽

LastWrite: Zeigt an, dass in eine Datei geschrieben wurde.

쐽

Security: Zeigt an, dass man die Sicherheitseigenschaften einer Datei oder eines Ordners geändert hat.

쐽

Size: Gibt an, dass sich die Größe einer Datei oder eines Ordners geändert hat.

쐽

Zum Schluss setzen Sie einfach EnableRaisingEvents auf true, um den Beobachter zu aktivieren. Der FileSystemWatcher verfügt über vier Ereignisse: Changed, Created, Deleted und Renamed. Diesen können Sie jeweils einen Delegaten zuweisen, der eine Art der Bearbeitung darstellt. Wir wollen ein einfaches Beispiel erstellen. Listing 11.7 erzeugt eine Anwendung, die auf Ihrem Windows-Desktop erscheinen soll. Sobald sich etwas in Ihrem Dateisystem ändert, löst diese Anwendung einen Alarm aus.

Listing 11.7: Ihre Festplatte überwachen 1: using System; 2: using System.Windows.Forms; 3: using System.Drawing; 4: using System.IO; 5: 6: namespace TYWinforms.Day11 { 7: public class Listing117 : Form { 8: FileSystemWatcher objWatcher = new FileSystemWatcher(); 9: 10: public Listing117() { 11: objWatcher.Path = "c:\\temp"; 12: objWatcher.Filter = "*.*"; 13: objWatcher.IncludeSubdirectories = true; 14: objWatcher.NotifyFilter = NotifyFilters.CreationTime | NotifyFilters.LastWrite | NotifyFilters.Size; 15: objWatcher.EnableRaisingEvents = true; 16: 17: objWatcher.Changed += new FileSystemEventHandler(this.RaiseAlert); 18: objWatcher.Created += new FileSystemEventHandler(this.RaiseAlert); 19: objWatcher.Deleted += new FileSystemEventHandler(this.RaiseAlert); 20: 21: this.Text = "Listing 11.7"; 22: } 23: 24: private void RaiseAlert(Object Sender, FileSystemEventArgs e) {

403

Arbeiten mit der Windows-Ein-/Ausgabe

25: MessageBox.Show("Ich sehe dich!! Du " + e.ChangeType.ToString() + " " + e.Name); 26: } 27: 28: public static void Main() { 29: Application.Run(new Listing117()); 30: } 31: } 32: }

Die Zeilen 11 bis 15 richten den FileSystemWatcher ein. In diesem Fall überwacht er die Eigenschaften LastWrite, CreationTime und Size auf Veränderungen. In den Zeilen 17 bis 19 richten Sie die passenden Ereignisse ein, die ausgelöst werden sollen, wenn sich eine der erwähnten Eigenschaften ändert. Beachten Sie, dass diese Ereignisse jeweils einen Delegaten vom Typ FileSystemWatcherEventHandler verwenden, so dass Sie im Ereignishandler einen Ereignisparameter des Typs FileSystemEventArgs verwenden. Zeile 24 enthält diesen Ereignishandler. Er zeigt dem Benutzer eine Meldung an, wenn eine Änderung entdeckt wurde, wobei er eine Reihe von Eigenschaften des Objekts FileSystemEventArgs nutzt. ChangeType gibt die Art der erfolgten Änderung an. Folgende Werte der Aufzählung WatcherChangeTypes sind gültig: All (welcher alle Änderungsarten umfasst), Changed, Created, Deleted und Renamed. Die Name-Eigenschaft gibt den Verzeichnis- bzw. Dateinamen an, der geändert wurde (alternativ könnten Sie auch FullName verwenden, um den kompletten Verzeichnispfad zu liefern). Die MessageBox-Methode in Zeile 25 liefert eine generische Meldung an den Benutzer. Kompilieren Sie diese Anwendung, führen Sie sie aus und ändern Sie die Datei happy.txt (bzw. die entsprechende von Ihnen erstellte Datei). Die Anwendung sollte Sie dann alarmieren, wie etwa in Abbildung 11.7 zu sehen. Wenn Sie diese Datei bearbeiten, erhalten Sie von der Anwendung zwei Meldungen, die beide Changed lauten, da Sie ja zwei Eigenschaften der Datei änderten: Size und LastWrite. Denken Sie daran, Ihre NotifyFilter-Typen mit den Ereignissen, die ausgelöst werden, zu korrelieren. So nützt es Ihnen etwa nichts, wenn Sie die NotifyFilter-Eigenschaft auf NotifyFilters.FileName setzen, wenn Sie nicht das Renamed-Ereignis überwachen.

404

Asynchrone Ein-/Ausgabe

Abbildung 11.7: Ertappt!

11.4 Asynchrone Ein-/Ausgabe Standardmäßig waren alle E/A-Operationen, die Sie bislang vorgenommen haben, synchron. Das bedeutet, dass Ihre Anwendung nichts anderes tun kann, bis die fragliche E/A-Operation beendet wurde. Sie können also dem Benutzer keine Meldung anzeigen, während eine Datei gelesen oder geschrieben wird. Bis jetzt war das synchrone Verfahren kein Problem. Alle Arbeitsschritte wurden relativ rasch erledigt, so dass Sie sich nicht den Kopf darüber zerbrechen mussten, dass die Anwendung darauf wartet, mit anderen Arbeitsschritten fortzufahren, während die jeweilige E/A-Operation zu Ende geführt wird. In manchen Fällen kann man jedoch nicht darauf warten, bis die Ein-/Ausgabe fertig ist. Das trifft zum Beispiel zu, wenn man den Inhalt einer sehr umfangreichen Datei einliest oder darauf wartet, dass ein sehr langsames Netzwerk einen Stream bereitstellt. Diese Abläufe können mitunter sehr lange dauern. Bei synchronen Abläufen bleibt Ihnen keine andere Wahl, als den Benutzer Ihrer Anwendung warten zu lassen, bis die jeweiligen Vorgänge abgeschlossen sind. Um diesen Konflikten entgegentreten zu können, gibt Ihnen .NET die Möglichkeit zu asynchronen Operationen. Damit erfolgen Ihre E/A-Abläufe abgetrennt vom Rest der Anwendungsausführung, so dass Ihre Anwendung nicht auf den Abschluss langwieriger Vorgänge warten muss. Stellen Sie sich vor, dass alle Arbeitsschritte, die in Ihrer Anwendung ablaufen müssen (Initialisierung, Ereignisverarbeitung, Erstellen von Steuerelementen usw.) sich in einer Warteschlange anstellen, um ausgeführt zu werden. Bei asynchroner Arbeitsweise treten die wichtigsten Prozesse aus der Warteschlange heraus, erledigen die ihnen zugeteilten Aufgaben und reihen sich dann wieder ein.

405

Arbeiten mit der Windows-Ein-/Ausgabe

Asynchrone Operationen sind ein komplexes Thema, das gewöhnlich erfahrenen Benutzern vorbehalten bleibt, so dass wir nicht im Detail darauf eingehen. Das Erstellen einer »asynchronen« Anwendung erfordert häufig eine radikale Abkehr von den Entwurfsmustern, die Sie gewöhnt sind, und wird in der Realität auch nicht sehr häufig eingesetzt. Momentan genügt es zu wissen, dass Streams zusätzlich zu ihren normalen Lese-/Schreibmethoden auch über asynchrone Versionen dieser Methoden verfügen.

11.5 Drucken unter .NET Das letzte E/A-Thema für heute ist das Drucken. Um etwas drucken zu können, muss man durch ein paar mitunter seltsame Schleifen springen. Doch der grundlegende Funktionsumfang besteht aus dem PrintDocument-Objekt und dem PrintPage-Ereignis. Anders als sein Name suggeriert, ist PrintDocument keineswegs ein zu druckendes Dokument. Vielmehr ist es so etwas wie der Verkehrspolizist, der steuert, wie ein Dokument gedruckt wird. Es existiert, um den Vorgang anzustoßen und für einen reibungslosen Ablauf zu sorgen. Sobald etwas zu drucken ist, löst das PrintDocument das PrintPage-Ereignis aus und überlässt es Ihnen, dieses Ereignis abzufangen und das Dokument tatsächlich zu drucken. Bevor Sie dies lernen, schauen wir uns die Grundlagen an. Angenommen, Sie wollen dem Benutzer gestatten, den Inhalt der RichTextBox in Listing 11.6 zu drucken. (In den folgenden Beispielen verwenden wir C#-Code, so dass Sie gegebenenfalls von VB .NET in C# bzw. umgekehrt konvertieren müssen, damit die angegebenen Codefragmente funktionieren.) Zuerst sorgen Sie dafür, dass die nötigen Namensräume importiert werden: using System.Drawing.Printing;

Dann fügen Sie ein Menüelement hinzu, so dass der Benutzer das Dokument drucken kann: MainMenu mnuMain = new MainMenu(); MenuItem miFile = new MenuItem("Datei "); MenuItem miPrint = new MenuItem("Drucken "); miPrint.Click += new EventHandler(this.PrintClicked); mnuMain.MenuItems.Add(miFile); miFile.MenuItems.Add(miPrint);

Im Ereignishandler PrintClicked können Sie das Dialogfeld PrintDialog anzeigen, wenn der Benutzer seine Druckeinstellungen festlegen können soll, bevor er tatsächlich druckt. (Informationen zum Konfigurieren der Druck- und Seiteneinstellungen finden Sie an Tag 7.) Im Moment überspringen wir diesen Schritt und drucken einfach das Dokument. Der Ereignishandler sollte wie im folgenden Codestück aussehen:

406

Drucken unter .NET

private void PrintClicked(Object Sender,EventArgs e){ PrintDocument pd = new PrintDocument(); pd.PrintPage += new PrintPageEventHandler(this.pd_PrintPage); pd.Print(); }

Beachten Sie diese drei Codezeilen: das Anlegen eines PrintDocuments, die Zuweisung des Delegaten zum PrintPage-Ereignis und den Aufruf des Print-Befehls. Sie müssen noch nicht einmal angeben, was zu drucken ist. Sobald Sie eine pd_PrintPage-Methode erstellt haben, können Sie diese Anwendung kompilieren und ausführen. Ihr Drucker wird reagieren, wenn Sie auf das DRUCKEN-Menü klicken. Doch momentan wird nichts außer einer leeren Seite ausgegeben – es gibt nichts zu drucken. Für jede zu druckende Seite wird das PrintPage-Ereignis ausgelöst, so dass Sie das Dokument letztendlich in diesem Ereignishandler drucken. Wir schauen uns einmal den Ereignishandler in Listing 11.8 an. Listing 11.8: Der PrintPage-Ereignishandler 1: private void pd_PrintPage(Object Sender, PrintPageEventArgs e) { 2: StringReader objReader = new StringReader(rtbText.Text); 3: 4: Font fntPrint = this.Font; 5: int count = 0; 6: float yPos = 0; 7: float lpp = e.MarginBounds.Height / fntPrint.GetHeight(e.Graphics); 8: float fltTopMargin = e.MarginBounds.Top; 9: float fltLeftMargin = e.MarginBounds.Left; 10: String strLine = null; 11: 12: while (count < lpp && ((strLine = objReader.ReadLine()) != null)) { 13: yPos = fltTopMargin + (count * fntPrint.GetHeight(e.Graphics)); 14: 15: e.Graphics.DrawString(strLine, fntPrint, Brushes.Black, fltLeftMargin, yPos, new StringFormat()); 16: 17: count++; 18: } 19: 20: if (strLine != null) { 21: e.HasMorePages = true; 22: } else { 23: e.HasMorePages = false; 24: } 25: }

407

Arbeiten mit der Windows-Ein-/Ausgabe

Beachten Sie, dass dieser Ereignishandler ein PrintPageEventArgs-Objekt erfordert. Es enthält die für das Drucken notwendigen Eigenschaften. Zeile 2 holt den Text aus der früher erstellten RichTextBox. Sie müssen die zu druckende Information in einen Stream bringen oder in einen Reader, weil dies die einzigen Dinge sind, die .NET drucken kann. Darauf folgt einiges an Initialisierung. Sie müssen einige Daten über die zu bedruckende Seite kennen, bevor es losgehen kann. Sie müssen wissen, wo der Druckvorgang beginnen kann, wo die Ränder liegen, wie viel auf eine einzelne Seite passt, wie hoch die Druckqualität sein soll usw. Die Druckfunktionen von .NET sind alle im Namensraum System.Drawing abgelegt. Doch im Gegensatz zum Malen (Drawing) müssen Sie beim Drucken stets in der ersten Zeile anfangen (selbst wenn es nichts zu drucken gibt) und dann zeilenweise weitermachen. Wenn Sie mit der Arbeitsweise eines Druckers vertraut sind, wird Ihnen dieser Ablauf einleuchten. Der Druckkopf bewegt sich horizontal über eine Seite, druckt Zeile für Zeile und kehrt dann an den Anfang zurück, um die nächste Zeile zu drucken, ähnlich wie eine Schreibmaschine. Deshalb müssen Sie den Druckvorgang in der gleichen Weise angehen. Zeile 4 ermittelt die Schriftart, mit der zu drucken ist; in diesem Fall verwenden Sie die gleiche Schriftart, die die RichTextBox verwendet, so dass das gedruckte Dokument genauso aussehen wird wie das Dokument am Bildschirm. Zeile 5 initialisiert eine Variable, die Sie verwenden, um sich per Schleife durch die Zeilen des Dokuments zu bewegen (gleich mehr dazu). Zeile 6 verrät uns, wo Sie zu drucken anfangen wollen: die y-Koordinate. Dieser Wert ist anfangs null und berücksichtigt nicht die Höhe der Ränder (gleich mehr zu den Rändern). Mit dem Ereignishandler in Listing 11.8 lässt sich nur eine Seite bedrucken. Ist Ihr Dokument länger, dann wird der Ereignishandler erneut ausgeführt und holt das Dokument noch einmal. Der Rest folgt automatisch und Ihre Anwendung tritt in eine endlose Druck-Schleife ein. Daher empfiehlt es sich, den Code in Zeile 2 außerhalb der PrintPage-Ereignishandlermethode unterzubringen. Zeile 7 bestimmt die Anzahl der Zeilen pro Seite. Diese Zahl wird bestimmt, indem man die Seitenhöhe durch die Höhe der verwendeten Schrift dividiert. Die Angabe der Seitenhöhe wird vom PrintPageEventArgs-Objekt geliefert. Denken Sie daran, die Höhe der Ränder in Ihrer Berechnung zu berücksichtigen, was der Grund dafür ist, dass Zeile 7 die Höhe der MarginBounds-Eigenschaft bestimmt. Das Font-Objekt verfügt über eine GetHeight-Methode, welche die Höhe der aktuell verwendeten Schrift bestimmt. Um den Parameter für GetHeight brauchen Sie sich noch nicht zu kümmern.

408

Drucken unter .NET

Die Zeilen 8 und 9 bestimmen jeweils die linken und oberen Ränder. Zeile 10 schließlich initialisiert eine Variable, die Sie gleich verwenden werden. Denken Sie daran, dass das Drucken zeilenweise erfolgt. Daher müssen Sie eine Schleife einrichten, die durch die Zeilen im von Ihnen eingerichteten Reader iteriert. Dies tut die while-Schleife (Zeile 12). Wenn sie das Seitenende erreicht (welches durch die Angabe der Zeilen pro Seite definiert ist) oder wenn es keinen Inhalt mehr zu drucken gibt, endet die Schleife. Beachten Sie die Shortcut-Syntax in Zeile 12; Sie können direkt im whileStatement einer Variablen einen Wert zuweisen. Sie verwenden ReadLine im Reader, um die aktuell zu druckende Zeile zu liefern. Die Zeile 13 bestimmt, wo genau die aktuelle Zeile auf der Seite gedruckt werden soll. Sie addieren die Randbreite und rechnen dann aus, wie viele Zeilen Sie bereits gedruckt haben, indem Sie Ihren Zeilenzuwachs mit der Schrifthöhe multiplizieren. Zum Schluss sind Sie endlich bereit, die Seite zu drucken (Zeile 15). .NET behandelt die zu druckende Seite wie eine Leinwand. Um eine Zeile zu drucken, rufen Sie die Methode DrawString des Graphics-Objekts auf, das mit Ihrem Drucker verknüpft ist. (Diese Begriffe ergeben ab Tag 13 etwas mehr Sinn). DrawString übernimmt sechs Parameter in der folgenden Reihenfolge: 쐽

String: Die auf der Seite zu zeichnende Zeichenfolge.

쐽

Font: Die Schriftart für das Drucken der Zeichenfolge.

쐽

Brush: Ein Objekt, das dem Drucker mitteilt, wie die Zeichenfolge zu drucken ist (in welcher Farbe, ob ausgefüllt oder mit Verlauf usw.) Mehr zu diesem Objekt erfahren Sie an Tag 13.

쐽

X: Die x-Koordinate für den Druckbeginn.

쐽

Y: Die y-Koordinate für den Druckbeginn.

쐽

StringFormat: Ein Objekt, das die zu druckende Zeichenfolge formatiert (vertikale

oder horizontale Ausrichtung bzw. Hoch- oder Querformat etc.). Sie kennen bereits die meisten dieser Parameter, so etwa String, X und Y. Für Brush und StringFormat können Sie generische Werte benutzen, wie in Zeile 15 gezeigt. In Zeile 17 inkrementieren Sie den Zähler, der Ihnen verrät, welche Zeile gerade gedruckt wird. Tabelle 11.4 führt Sie durch die komplette while-Schleife in den Zeilen 12 bis 18.

409

Arbeiten mit der Windows-Ein-/Ausgabe

Ausgabedatei, Zeilennummer

x- und y-Koordinaten der Zeile

Zeileninhalte (aus der weiter vorn in dieser Lektion erzeugten Datei happy.txt)

1

0, oberer Rand

Hallo Welt!

2

0, oberer Rand + Höhe von Zeile 1 Hier ist noch mehr

3

0, oberer Rand + Höhe von Zeile 1 Text, den ich hier eingefügt habe + Höhe von Zeile 2

4

0, oberer Rand + Höhe der Zeilen 1, 2, 3

um die Applikation

5

0, oberer Rand + Höhe der Zeilen 1, 2, 3, 4

in Listing 11.3 zu testen.

6

0, oberer Rand + Höhe der Zeilen 1, 2, 3, 4, 5

Null

Tabelle 11.4: Der Druckvorgang

Wir wollen uns den Rest des Codes in Listing 11.8 ansehen: 20: 21: 22: 23: 24:

if (strLine != null){ e.HasMorePages = true; } else { e.HasMorePages = false; }

Das Objekt PrintPageEventArgs hat eine HasMorePages-Eigenschaft, die angibt, ob es noch mehr Seiten zu drucken gibt. Ist dies der Fall, wird ein weiteres PrintPage-Ereignis ausgelöst und der gesamte Druckvorgang beginnt von neuem. Leider weiß die Anwendung selbst nicht, ob es mehr Seiten zu drucken gibt; das müssen Sie selbst ausrechnen. Daher bestimmen Sie in Zeile 20, ob die letzte Zeichenfolge, die aus der RichTextBox gelesen wurde, null ist. Ist das der Fall, heißt das, dass es keine Zeilen mehr zu drucken gibt und man fertig ist. An diesem Punkt setzen Sie HasMorePages auf false. Wenn Sie aber mehr Text auf einer weiteren Seite zu drucken haben, dann lösen Sie wieder PrintPage aus. In diesem Fall setzen Sie HasMorePages auf true (Zeile 21). Beachten Sie, dass dieser Codeabschnitt nach der while-Schleife folgt, so dass die aktuelle Seite bereits vollständig gedruckt worden ist (gemäß dem Zeilen/Seite-Wert bzw. dann, wenn der Inhalt der RichTextBox komplett gedruckt ist). Dieser Ablauf ist recht kompliziert, daher wollen wir ihn zusammenfassen: 1. Erstellen Sie eine Möglichkeit, wie der Benutzer das Dokument drucken kann (also das Menüelement).

410

Zusammenfassung

2. Erzeugen Sie das PrintDocument-Objekt, weisen Sie dem PrintPage-Ereignis einen Ereignishandler zu und rufen Sie PrintDocument.Print auf. 3. Bestimmen Sie im PrintPage-Ereignishandler die Eigenschaften der Seite, darunter die Zeilen/Seite, die Randbreite und die zu verwendende Schriftart. Erstellen Sie ein Stream- oder Readerobjekt, das den zu druckenden Inhalt enthält. 4. Durchlaufen Sie in einer Schleife die Zeilen des Streams oder Readers, bis Sie den Zeilen/Seite-Wert oder das Ende des Readers erreicht haben. Legen Sie die y-Koordinate für den Druckbeginn in jeder Zeile fest. Drucken Sie die Zeile, indem Sie Graphics.DrawString im PrintPageEventArgs-Objekt aufrufen und ihm die notwendigen Parameter übergeben. 5. Bestimmen Sie, ob Sie noch mehr Inhalt zu drucken haben, und legen Sie HasMorePages entsprechend fest. Wenn Sie dem Benutzer erlaubt haben, die Seiteneinstellungen zu ändern, können Sie die geänderten Werte dem PrintDocument zuweisen, wie im folgenden Beispiel: PageSettings objSettings = new PageSettings(); PrinterSettings objPrinter = new PrinterSettings(); //fügen Sie hier Code ein, um die Einstellungen anzupassen //(möglichweise mit Standarddialogfeldern) PrintDocument pd = new PrintDocument(); pd.DefaultPageSettings = objSettings; pd.PrinterSettings = objPrinter;

Sobald das PrintPage-Ereignis ausgelöst wird, enthält das PrintPageEventArgs-Objekt die neuen Einstellungen (wie etwa Randänderungen usw.). Sie können einen Druckauftrag auch löschen, indem Sie die Cancel-Eigenschaft des PrintPageEventArgs-Objekts auf true setzen.

11.6 Zusammenfassung Sie haben nun von Streams und ihrer Rolle bei E/A erfahren. Jedes Mal, wenn Sie es mit E/A unter .NET zu tun haben, gehen Sie mit Streams um, die quellenunabhängige Informationsspeicher darstellen, denen Sie Writer und Reader zuweisen können, um deren Inhalte zu bearbeiten. Obwohl es zahlreiche verschiedene Arten von Streams, Readern und Writern gibt, ist ihre Arbeitsweise doch stets ähnlich. Um eine Datei zu öffnen, erstellen Sie für sie einfach einen Stream mit den erforderlichen FileMode-, FileAccess- und FileShare-Aufzählungswerten. Die Anwendung kann alle

Funktionen handhaben, um festzustellen, ob die Datei existiert, ob sie überschrieben oder

411

Arbeiten mit der Windows-Ein-/Ausgabe

erstellt werden soll usw. Als Nächstes weisen Sie einen Reader oder Writer des passenden Typs zu (StreamReader und StreamWriter für die meisten Textdateien) und rufen eine der folgenden E/A-Methoden auf: Write, WriteLine, ReadLine, Read, ReadBlock, ReadToEnd usw. Das RichTextBox-Objekt verfügt über eingebaute E/A-Funktionen. Sie müssen lediglich die LoadFile- und SaveFile-Methoden aufrufen, um ein vorhandenes Dokument bearbeiten zu können. Das FileSystemWatcher-Objekt erweist sich als nützlich, wenn es darum geht, die vor sich gehenden Änderungen in Ihrem Dateisystem zu überwachen. Sie können sich jedes Mal, wenn eine Datei erstellt, geändert, umbenannt oder sonst wie verändert wird, benachrichtigen lassen und dann entsprechend darauf reagieren. Dieses Objekt sollte man nicht für Sicherheitszwecke missbrauchen; dafür gibt es viel besser geeignete Objekte. Zum Schluss haben Sie das Drucken von Inhalten erlernt. Drucken ist keineswegs ein intuitiv verständlicher Prozess. Sie erstellen ein PrintDocument-Objekt und rufen eine Print-Methode auf, die wiederum Ereignisse auslöst, in welche Sie eine Schleife einflechten müssen, die durch den zu druckenden Inhalt führt. Schließlich »zeichnen« Sie den Inhalt auf das Papier. Nachdem Sie das gelernt haben, können Sie den gleichen Code zum Glück fast überall einsetzen, denn die Drucklogik ändert sich recht selten.

11.7 Fragen und Antworten F

Kann ich Streams, Writer und Reader oder auch eine RichTextBox dazu verwenden, Word-Dokumente zu bearbeiten? A

Nicht ganz. Word-Dokumente sind kein reiner Text, sondern verwenden vielmehr ein Binärformat, das exklusiv von Microsoft entwickelt wurde. Dieses Format erlaubt Microsoft nicht nur, eigene Funktionen in Word-Dokumente einzubauen, sondern stellt auch sicher, dass nur Benutzer, die Word (oder die Lizenz dafür) besitzen, Word-Dokumente bearbeiten können. Sie können binäre Reader und Writer dazu einsetzen, Word-Dokumente zu bearbeiten. Doch alle Dateien weisen ein spezifisch geordnetes Format auf. Wenn Sie also nicht ganz genau wissen, wie ein Word-Dokument intern aufgebaut ist, dürfte Ihre Mühe umsonst sein. Microsoft gibt die Informationen über das binäre Dateiformat an Unternehmen weiter, die Word lizenzieren möchten. Wenn Sie zu einer solchen Firma gehören, dann viel Erfolg!

F

Ich habe von »isolierter Speicherung« in .NET gehört. Was versteht man darunter? A

412

Isolierte Speicherung ist ein interessantes Konzept. Damit ist gemeint, dass jeder Benutzer Ihrer Anwendung über sein eigenes dediziertes Repository (Speichersystem) für solche Dokumente verfügt, die während der Anwendungsausführung

Workshop

bearbeitet werden. Dieses Repository ist sicher und vom Betriebssystem beschützt, so dass sich vertrauliche Daten an diesem Speicherplatz ablegen lassen. Sie können zudem Kontingente für die dort speicherbare Datenmenge einrichten. Isolierte Speicherung wird nur selten in Desktop-Anwendungen eingesetzt. Sie ist gebräuchlicher in Internet-Applikationen, bei denen viele Benutzer auf einen Rechner zugreifen.

11.8 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. Worin besteht der Unterschied zwischen den Read- und Peek-Methoden? 2. Was ist eine rekursive Funktion und wann erweist sie sich als hilfreich? 3. Worin besteht der Unterschied zwischen synchroner und asynchroner Arbeitsweise? 4. Zu welchem Namensraum gehört die Druckfunktionalität? 5. Welche sind die vier Ereignisse des FileSystemWatcher-Objekts? 6. Welche sind die Werte der FileMode-Aufzählung ?

Übung Modifizieren Sie Listing 11.1 so, dass die TreeView-Knoten jedes Mal dynamisch erstellt werden, wenn ein Benutzer einen Knoten expandiert, anstatt alle während der Initialisierungsphase der Anwendung erstellen zu lassen. Fügen Sie außerdem eine benutzerdefinierte Druckfunktion hinzu, um die sichtbaren Inhalte des TreeView-Steuerelements drucken zu können. (Tipp: Sie müssen die Inhalte der Strukturansicht erst in einer passenden Variablen sammeln, um sie drucken zu können.)

413

Formulare Internetfähig machen

2 1

Formulare Internet-fähig machen

Das Internet ist mittlerweile ein zentraler Aspekt der Computerverwendung. Daher wird es nur den Tatsachen gerecht, wenn Sie das Internet entsprechend in Ihren Anwendungen berücksichtigen. Dank .NET ist die Integration von Internetfunktionen ein Kinderspiel. Heute werfen Sie einen Blick auf verschiedene Internetprotokolle und darauf, wie man sie unter .NET einsetzt. Sie werden erkennen, dass Sie damit verschiedene Aufgaben leicht erledigen können, von einfachen Webanfragen bis zum Zugriff auf sichere Webserver. In kürzester Zeit werden Sie webfähige Anwendungen auf die Beine stellen können. Heute lernen Sie, 쐽

was Internet- und austauschbare Protokolle sind,

쐽

wie das WebRequest-Objekt die Arbeit erleichtert,

쐽

was ASP.NET ist,

쐽

auf welche Weise .NET mit dem Internet Explorer integriert ist,

쐽

wie man auf sichere Websites zugreift.

12.1 Internetprotokolle Wenn Sie schon einmal das Internet benutzt haben, dann haben Sie wohl auch bereits von den verschiedenen Protokollen gehört, darunter IP, FTP, HTTP, UDP und TCP. Sie werden alle eingesetzt, damit das Internet funktioniert. Das bekannteste Protokoll ist das Hypertext Transfer Protocol (HTTP). Es wird am häufigsten in Browsern wie dem Internet Explorer oder dem Netscape Communicator eingesetzt. Man benutzt es, um Hypertext Markup Language- (HTML-) Seiten zur Anzeige auf den Browser zu holen. Ohne HTTP wäre das Internet wahrscheinlich nicht das, was Sie heute kennen. Das File Transfer Protocol (FTP) ist ebenfalls recht gebräuchlich. FTP wird hauptsächlich für die Dateiübertragung zwischen Computern eingesetzt. Es wurde so entworfen, dass es für die Übertragung großer Dateien effizienter ist als HTTP. Es gab einmal eine Zeit, zu der man alle Tricks dieser Protokolle kennen musste, um einer Anwendung Internetfähigkeiten hinzuzufügen. Jedes unterscheidet sich von den anderen, so dass sich das Problem vergrößert, wenn man mehrere zusammen einsetzen will. .NET vereinfacht diese Aufgabe für den Entwickler. Wir wollen uns zunächst noch ansehen, wie das Internet arbeitet. Ein Großteil der Internetanwendungen fußt auf dem Client/Server-Modell (auch unter der Bezeichnung Request/Response- bzw. Anforderung/Antwort-Modell bekannt). In diesem

416

Internetprotokolle

Paradigma dient ein Rechner, der so genannte Server, als Informationsspeicher und andere Rechner dienen als Verbraucher dieser Informationen und werden als Clients bezeichnet. Der Client schickt eine Anforderung (Request; via HTTP) an den Server und dieser antwortet (Response), indem er die angeforderten Daten zurück an den Client schickt (wiederum via HTTP; vgl. Abbildung 12.1). Konkret ausgedrückt: (1.) Sie besuchen eine Website, wo Sie als Client auftreten, (2.) Ihr Browser schickt eine HTTP-Anforderung an den Server und (3.) diese Website schickt die angeforderte Seite. Das Gesamtkonzept ist einfach, aber effizient in seiner Arbeitsweise. Beachten Sie, dass sowohl der Client als auch der Server beliebige Rechner sein können. SERVER BROWSER Anforderung Verarbeitung der Anforderung

Antwort

Abbildung 12.1: Im Client/Server-Modell speichert ein Computer (Server) Informationen und ein anderer (Client) ruft sie ab.

Wenn Millionen von Clients und Servern mit dem Internet verbunden sind, kann sich die Suche nach einem bestimmten Server recht schwierig gestalten. Daher wurde das System der Universal Resource Identifier (URI; manchmal wird auch URL verwendet, siehe den Hinweis unten) entwickelt; dieses System bildet den Schlüssel zu den Internetfunktionen in .NET. Sie haben sicher schon einmal URIs wie den folgenden gesehen: http://www.clpayne.com/default.asp?blah=bloh

Ein Uniform Resource Locator (URL), mit dem viele Menschen vertrauter sind, ist eine Form des URI, die bei Netzwerkprotokollen arbeitet, um bestimmte Adressen zu finden. Der URI besteht aus vier Teilen. Der erste, nämlich http://, gibt das Protokoll an, das verwendet werden soll, wenn Ressourcen vom Server angefordert werden. Dieser Teil wird auch Schemabezeichner (Schema Identifier) genannt. (Sie brauchen sich diesen Begriff nicht zu merken.) Der nächste Teil, www.clpayne.com, ist der Name des Servers (im Web). Das kann ein benutzerfreundlicher Name wie der hier gezeigte sein (dank des Domain Naming Systems oder DNS) oder einfach eine IP-Adresse wie etwa 127.0.0.1. Dieser Servername ist im Wesentlichen die Adresse des Servers, ähnlich wie Ihre Hausadresse. Der Unterschied: Dieser Servername soll im gesamten Internet nur ein einziges Mal (unique) vorkommen, also eindeutig sein (leider kommen Konflikte dennoch vor).

417

Formulare Internet-fähig machen

Der folgende Teil, nämlich /default.asp, ist der Pfadbezeichner (Path Identifier), der dem Server verrät, was genau der Client nun eigentlich anfordert. In diesem Fall ist es eine Active Server Page namens default.asp. Vielfach handelt es sich auch um eine HTMLSeite wie etwa index.html. Der vierte Teil ist eine optionale Abfragezeichenfolge. Diese Zeichenfolge, nämlich ?blah=bloh, wird dem Ende des Pfadbezeichners durch ein Fragezeichen angehängt und

gibt alle zusätzlichen Parameter an, die der Server für die Verarbeitung der Anfrage benötigen könnte. Wie Sie wahrscheinlich erwartet haben, sind alle Teile durch Klassen im .NET Framework repräsentiert.

Austauschbare Protokolle Die wichtigsten Internetklassen für Windows Forms-Anwendungen unter .NET sind WebRequest und WebResponse. WebRequest schickt Anforderungen mit einem URI an einen Server und WebResponse sendet Informationen zurück an den anfragenden Client. Das Interessante an diesen Klassen (und anderen .NET-Internetklassen) ist, dass sie mit jedem Protokoll zusammenarbeiten, so dass Sie Ihre Anwendung nicht ändern oder neuen Code schreiben müssen, nur um ein anderes oder neues Protokoll verwenden zu können. WebRequest und WebResponse dienen als eine Art Verkehrspolizisten, ähnlich der SqlDataAdapter-Klasse von Tag 9. Bitte erinnern Sie sich, dass SqlDataAdapter verschiedene SqlCommand-Objekte erzeugte, je nachdem, welche Art von SQL-Abfrage ausgeführt wurde. Wenn Sie WebRequest verwenden, um eine Information vom Server anzufordern, registriert

das Objekt automatisch das Protokoll, das Sie verwenden wollen, und erzeugt das notwendige Helferobjekt, um die Anforderung zu verarbeiten (so etwa ein HttpWebRequest-Objekt für HTTP-Anforderungen). Weil diese Helferobjekte dynamisch von einem Verkehrsobjekt abgeschaltet werden können, sind sie als austauschbare Protokolle (Pluggable Protocols, wörtlich: »einsteckbare Protokolle«) bekannt. .NET steckt bei Bedarf die jeweils nötige Klasse ein. Auf diese Weise können Sie eine Anwendung vom BrowserTyp allein mit WebRequest aufbauen. Sie brauchen sich auch nicht darum zu kümmern, welche Adressart der Benutzer in Ihren Browser eingibt, denn WebRequest passt sich dem dynamisch an. Dies ist die Grundlage für Internetanwendungen unter .NET: Einfachheit und Leichtigkeit für den Entwickler, während für den Benutzer die Leistungsfähigkeit beibehalten wird.

418

Clients und Server

12.2 Clients und Server Wie bereits besprochen, dient ein Server als Repository für Informationen und ein Client als Benutzer dieser Information. Weil ein Großteil des Internets aus Servern und Clients besteht, werden Sie meist diese beiden Anwendungstypen entwickeln. In den nächsten Abschnitten betrachten wir, wie man Clients erstellt, die mit Servern zusammenspielen; Serveranwendungen sind häufig ASP.NET vorbehalten. Für einige der folgenden Beispiele brauchen Sie einen Webserver, der Ihre Anforderungen empfangen kann. In manchen Fällen ist ein öffentlich zugänglicher Server wie www.clpayne.com oder www.microsoft.com ausreichend, doch manchmal brauchen Sie einen, mit dem Sie experimentieren können. Es ist wahrscheinlich, dass auf Ihrem Computer bereits ein Webserver läuft, nämlich Internet Information Server (IIS) von Microsoft. Um dies herauszufinden, geben Sie in der Adresszeile des Browsers einfach http://localhost ein. Erscheint eine Fehlerseite, läuft noch kein Server, so dass Sie IIS zunächst installieren müssen. Sollte eine Begrüßungsseite erscheinen oder gar eine Webseite, dann sind Sie schon startbereit. Um den IIS einzurichten, benötigen Sie Ihre Windows-Installations-CD. IIS ist eine optionale Komponente, die Sie über die SYSTEMSTEUERUNG und die Seite SOFTWARE/HINZUFÜGEN/ENTFERNEN installieren können. Klicken Sie auf die Schaltfläche HINZUFÜGEN/ENTFERNEN, wählen Sie die Optionen für den IIS, klicken Sie auf WEITER und folgen Sie dann den Anweisungen, um mit dem IIS-Einsatz anfangen zu können.

Anforderungen mit WebRequest senden Das Senden einer Anforderung ist nicht schwer. In der einfachsten Form braucht man nur ein paar neue Zeilen Code, um diese Funktion zu verwenden. Wir beginnen mit Listing 12.1. Listing 12.1: Ihre erste Internet-Applikation 1: 2: 3: 4: 5: 6: 7:

using using using using using

System; System.Windows.Forms; System.Drawing; System.Net; System.IO;

namespace TYWinforms.Day12 {

419

Formulare Internet-fähig machen

8: public class Listing121 : Form { 9: private RichTextBox rtbWeb = new RichTextBox(); 10: 11: public Listing121() { 12: CallServer(); 13: 14: rtbWeb.Multiline = true; 15: rtbWeb.Dock = DockStyle.Fill; 16: 17: this.Text = "Listing 12.1"; 18: this.Size = new Size(800,600); 19: this.Controls.Add(rtbWeb); 20: } 21: 22: private void CallServer() { 23: WebRequest objRequest = WebRequest.Create("http:// www.clpayne.com"); 24: WebResponse objResponse = objRequest.GetResponse(); 25: 26: StreamReader objReader = new StreamReader(objResponse.GetResponseStream()); 27: 28: rtbWeb.Text = objReader.ReadToEnd(); 29: 30: objReader.Close(); 31: objResponse.Close(); 32: } 33: 34: public static void Main() { 35: Application.Run(new Listing121()); 36: } 37: } 38: }

Die ersten 20 Zeilen sind im Grunde Standard. In Zeile 4 achten Sie bitte auf die Verwendung des zusätzlichen Namensraums System.Net, der alle nötigen Internetklassen enthält. Die eigentliche Internetanforderung erfolgt in dem Aufruf der angepassten CallServer-Methode. Der erste Schritt zur Erstellung einer Internetverbindung ist die Erzeugung eines WebRequest-Objekts, wie in Zeile 23 gezeigt. Die einfachste Möglichkeit dazu besteht im Aufruf einer statischen Create-Methode, wobei man den URI der Internetressource übergibt, auf die man zugreifen möchte. (Dieser Wert ist auch über die RequestUri-Eigenschaft der WebRequest-Klasse verfügbar – ändern Sie einfach die URI-Zeichenfolge in die gewünschte Adresse und sorgen Sie

420

Clients und Server

dafür, dass Sie eine Verbindung zum Internet haben.) Beachten Sie, dass Sie noch keine Verbindung hergestellt, sondern nur die Vorbereitungen dafür getroffen haben. In Zeile 24 stellen Sie die Verbindung her. Mit dem eben erstellten WebRequestObjekt rufen Sie GetResponse auf und speichern das Ergebnis in einem WebResponse-Objekt. Als Nächstes holen Sie die Antwort des Servers aus dem WebResponse-Objekt, indem Sie GetResponseStream aufrufen, welcher ein Streamobjekt liefert. Zeile 26 ordnet diesem Stream einen Reader zu, so dass Sie auf die Inhalte zugreifen können. In Zeile 28 lesen Sie den Inhalt des Streams mit Hilfe des Readers und legen den Inhalt im Steuerelement RichTextBox ab. Vergessen Sie nicht, sowohl den Reader als auch das WebRequest-Objekt zu schließen. Abbildung 12.2 zeigt die Anwendung, nachdem sie die Webanforderung verarbeitet hat.

Abbildung 12.2: Nach der Ausführung einer Webanforderung erhalten Sie diese Ergebnisse.

Was haben wir vorliegen? Abbildung 12.2 zeigt den Inhalt, der von der Website www.clpayne.com geholt wurde. Das ist keine bunte Webseite, sondern vielmehr ihr HTML-Code. Sie sehen den HTML-Inhalt, weil jede Anwendung dies sieht, wenn sie eine Anforderung an einen Server abschickt. Der eigentliche Darstellungsteil ist eine separate Funktion.

421

Formulare Internet-fähig machen

Lassen Sie uns die beteiligten Schritte rekapitulieren: 1. Erstellen Sie ein WebRequest-Objekt mit WebRequest.Create. 2. Rufen Sie GetResponse auf, um die Verbindung zu öffnen. 3. Rufen Sie GetResponseStream auf, um den Inhalt zu holen, wobei Sie bei Bedarf einen Reader anhängen. 4. Schließen Sie die Webobjekte (und gegebenenfalls den Reader). Web-basierte Interaktionen stützen sich ebenso wie E/A-Operationen auf Streams. Sie eignen sich aus mehreren Gründen hervorragend fürs Web. Bei Verwendung eines Streams brauchen Sie nicht die gesamte Ressource herunterzuladen, bevor Sie etwas damit tun können. Sie können den Stream lesen, während er noch hereinkommt (ähnlich wie das Betrachten eines Streaming-Videos, bevor es ganz heruntergeladen ist). Bedenken Sie auch, dass Streams auf jegliche Art von Datenquelle zugreifen können, von HTML bis XML. Das erleichtert das Abrufen von Webinhalten erheblich. Mit Hilfe von WebRequest können Sie dem Webserver auch Nachrichten in Form eines Streams schicken. Dieses Posting ist ein Vorgang, bei dem der Client zusätzliche eigene Informationen schicken kann, die sich normalerweise nicht in der Anforderungsnachricht befinden. Diese Information kann auch Postings von Formularen umfassen. Wenn Sie ein Online-Formular ausfüllen und auf die Schaltfläche OK klicken, schicken Sie eigentlich eine Webanforderung an den Server, so dass dieser Ihre Daten verarbeiten kann. (Dementsprechend wird der zuvor benutzte Vorgang des Abholens als Get-Anforderung (GetRequest) bezeichnet.) Um diese Anwendung zu testen, wollen wir zunächst eine Webseite erstellen, die Formular-Postings akzeptiert. Listing 12.2 zeigt eine Beispielseite. Listing 12.2: formpost.aspx 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15:

422

<%@ Page Language="CS" %> <script runat="server"> public void Page_Load(Object if (Request.Form.Count == lblMessage.Text = "You } else { lblMessage.Text = "You } }

Sender, EventArgs e) { 0) { didn’t post anything!"; posted: " + Request.Form.ToString();

Clients und Server

Speichern Sie diese Datei unter dem Namen formpost.aspx in Ihrem StammWebverzeichnis (üblicherweise c:\inetpub\wwwroot, wenn Sie die Standardeinstellungen des IIS übernommen haben). Die Datei ist eine einfache ASP.NETSeite, doch wie Sie sehen, ähnelt sie einer Windows Forms-Datei. Damit die Seite formpost.aspx funktioniert, müssen Sie das ASP.NET-Modul installiert haben. Das Modul ist eine optionale Komponente des .NET Frameworks. Wir wollen Listing 12.2 kurz analysieren. In ASP.NET haben Sie es mit zwei Arten von Code zu tun: mit Server- und mit HTML-Code. Der HTML-Abschnitt obigen Listings ist in den Zeilen 13 bis 15 zu finden. Der Servercode sieht wie Code aus VB .NET oder C# aus und ist in den <script>-Tags enthalten, wie es die Zeilen 3 bis 11 zeigen. Dieser Code wird kompiliert und funktioniert fast genau wie Windows Forms-Anwendungen. ASP.NET-Seiten können eine Methode namens Page_Load aufweisen, die beim Aufruf der Seite durch den Browser ausgeführt wird, ähnlich wie ein Konstruktor für ein Windows Forms-Programm, wenn die Anwendung startet. Die Page_Load-Methode übernimmt die gleiche Parameterliste wie viele Windows Forms-Ereignisse, weil sie ein Ereignishandler für das Page_Load-Ereignis in ASP.NET ist, das beim Laden der Seite ausgelöst wird. ASP.NET verfügt über das Request-Objekt, das ähnlich wie das bekannte WebRequestObjekt funktioniert. Die Form-Eigenschaft ist eine Auflistung aller Werte, die dem Server gepostet wurden; hätten Sie ein Formular online ausgefüllt, fänden sich Ihre Informationen hier wieder. Wurde nichts gesendet, ist die Auflistung leer (die Count-Eigenschaft ist 0), und Sie können eine Meldung (also die »schlechte Nachricht«) im Label-Steuerelement auf Zeile 14 anzeigen. Das Label-Steuerelement entspricht einem Windows FormsLabel, so dass dieser Code vertraut aussehen dürfte. Befindet sich jedoch etwas im Posting des Formulars, zeigen Sie eine »gute Nachricht« an, die aus »You posted: « und dem gesendeten Wert besteht (Zeile 8). Request.Form.ToString schreibt lediglich alles Gesendete in Klartext. Testen Sie die Seite, indem Sie in Ihrem Browser auf die Adresse http://localhost/formpost.aspx gehen. Sie sollten die Meldung »You didn't post anything!« erhalten, da Sie ja noch keine Daten gesendet haben. Wir kommen gleich dazu. Dieser Abschnitt hat einen kurzen Überblick über ASP.NET geboten, doch wie Sie sehen können, ist dieses Thema nicht sonderlich kompliziert, sobald Sie einmal Windows Forms kennen gelernt haben. Wir wollen nun die Windows Forms-Anwendung erstellen, die dieses Formular postet. Listing 12.3 zeigt den entsprechenden Code.

423

Formulare Internet-fähig machen

Listing 12.3: Daten an Ihre ASP.NET-Seite senden 1: using System; 2: using System.Windows.Forms; 3: using System.Drawing; 4: using System.Net; 5: using System.IO; 6: 7: namespace TYWinforms.Day12 { 8: public class Listing123 : Form { 9: private RichTextBox rtbWeb = new RichTextBox(); 10: private WebRequest objRequest; 11: public Listing123() { 12: rtbWeb.Dock = DockStyle.Fill; 13: 14: objRequest = WebRequest.Create("http://localhost/formpost.aspx"); 15: 16: PostData(); 17: GetData(); 18: 19: this.Text = "Listing 12.3"; 20: this.Controls.Add(rtbWeb); 21: } 22: 23: private void PostData() { 24: objRequest.Method = "POST"; 25: objRequest.ContentLength = 23; 26: objRequest.ContentType = "application/x-www-form-urlencoded"; 27: 28: StreamWriter objWriter = new StreamWriter (objRequest.GetRequestStream()); 29: objWriter.Write("Hi this is a form post!"); 30: objWriter.Close(); 31: } 32: 33: private void GetData() { 34: WebResponse objResponse = objRequest.GetResponse(); 35: StreamReader objReader = new StreamReader (objResponse.GetResponseStream()); 36: 37: rtbWeb.Text = objReader.ReadToEnd(); 38: 39: objReader.Close(); 40: objResponse.Close(); 41: } 42:

424

Clients und Server

43: 44: 45: 46: 47:

public static void Main() { Application.Run(new Listing123()); } } }

Die Anwendung in Listing 12.3 sendet einige Daten an die Datei formpost.aspx (Listing 12.2) und zeigt die Ergebnisse in einem in Zeile 9 deklarierten RichTextBox-Steuerelement an. Der Konstruktor ist recht einfach; er ruft eine PostData-Methode auf, um die Daten an den Server zu senden, und GetData, um die Antwort zu empfangen. Beachten Sie die Erstellung des WebRequest-Objekts in Zeile 14; es zeigt auf die eben erzeugte Datei formpost.aspx. Wir wollen einen Blick auf PostData in Zeile 23 werfen. Um dem Server Daten zu senden, müssen Sie ihm erst dieses Vorhaben mitteilen, indem Sie die Method-Eigenschaft des WebRequest-Objekts in Zeile 24 auf POST setzen. Nachdem der Server diese Information erhalten hat, weiß er, dass er auf Daten vom Client warten soll. In Zeile 25 legen Sie die Länge des zu sendenden Inhalts fest; in diesem Fall ist es die Länge einer Zeichenfolge. Die Längenangabe ist optional, im Allgemeinen empfiehlt es sich aber, diesen Wert bereitzustellen. In Zeile 26 setzen Sie die ContentType-Eigenschaft des WebRequest-Objekts, was sehr wichtig ist. Der Standardwert lautet auf "text/html", so dass reiner Text, als HTML formatiert, übertragen wird. Gepostete Daten jedoch werden nicht als reiner Text, sondern in einem speziell verschlüsselten Format übertragen. In Zeile 26 wird dieses Format als application/x-www-form-urlencoded festgelegt. Legen Sie dieses Format nicht fest, wird der Server die gesendeten Daten nicht erkennen und sie ignorieren. Nach dem Präparieren des Servers ist es Zeit für den Datenversand. Da alle E/AOperationen in .NET über Streams erfolgt, bilden Postings keine Ausnahme. In Zeile 28 rufen Sie daher die GetRequestStream-Funktion auf, um einen schreibbaren Stream zurückzugeben, der an den Server gesendet wird, und hüllen ihn dann in einen Writer ein. In Zeile 29 rufen Sie die Write-Methode auf (wie für jedes Writer-Objekt), um Ihre Daten schließlich an den Server zu schicken. Beachten Sie, dass die ContentLength-Eigenschaft in Zeile 25 der Länge des Zeichenfolge in Zeile 29 entspricht. Statt die Anzahl der Zeichen manuell zu zählen, können Sie folgenden Code benutzen: objRequest.ContentLength = "Hi, this is a form post!".Length;

Alternativ können Sie die zu sendenden Daten in einer Zeichenfolgenvariablen speichern und ihre Length-Eigenschaft aufrufen.

425

Formulare Internet-fähig machen

Abschließend müssen Sie genau wie beim Lesen von Anforderungsinformationen Ihren Writer schließen (siehe Zeile 30). Die GetData-Methode in den Zeilen 33 bis 41 ist praktisch identisch mit der CallServerMethode aus Listing 12.1. Sie rufen GetResponse auf, um ein WebResponse-Objekt zu erzeugen, rufen dann die Methode GetResponseStream auf und erstellen einen Reader; zum Schluss rufen Sie ReadToEnd auf. Sowohl der Reader als auch das WebResponse-Objekt werden dann beendet (in den Zeilen 39 und 40). Der einzige Unterschied zwischen diesen Methoden und dem früheren CallServer besteht darin, dass Sie hier gerade Daten an den Server gesendet haben, so dass Sie eine entsprechend zugeschnittene Antwort erwarten. Wenn Sie diese Anwendung kompilieren und ausführen, erhalten Sie Ergebnisse, die den in Abbildung 12.3 gezeigten ähneln.

Abbildung 12.3: Nach dem Posten an den Server erhalten Sie diese Ergebnisse.

In diesem Bild können Sie erkennen, dass der zurückgelieferte Inhalt aus HTML besteht. Das erwartete Ergebnis wird geliefert: You posted: Hi+this+is+a+form+post!

Weil die ASP.NET-Seite gepostete Formulardaten erhalten hat, zeigt sie die »gute Nachricht« mit den gesendeten Daten an. Beachten Sie jedoch das Pluszeichen zwischen jedem Wort. Da die gesendeten Daten in einem Spezialformat geschickt wurden, besteht einer der bei Postings notwendigen Formatierungstricks im Ersetzen von Leer- durch Pluszeichen. Das WebRequest-Objekt ist recht vielseitig, denn es erlaubt Ihnen, Inhalte von jedem Server zu holen bzw. an beliebige Server zu schicken. Vor der Einführung von .NET gestaltete sich das Holen und Posten von Daten weitaus schwieriger als nur das Lesen oder Schreiben eines Streams. Tabelle 12.1 zeigt die Eigenschaften und einige Methoden des WebRequest-Objekts.

426

Clients und Server

Eigenschaft

Beschreibung

ConnectionGroup- Diese Eigenschaft wird zum Gruppieren von Verbindungen (Connection Name Pools) benutzt. Diese werden zur Leistungssteigerung eingesetzt, wenn mehrere

Verbindungen nötig sind. ContentLength

Die Länge der übermittelten Daten.

ContentType

Typ und Format der übermittelten Daten.

Credentials

Anmeldeinformationen, die für den Zugang zu Webressourcen benutzt werden. (Mehr dazu im Abschnitt über Sicherheit.)

Headers

Die Auflistung von HTTP-Headern, die mit jeder Anforderung geschickt werden.

Method

Die Protokollmethode für diese Anforderung.

PreAuthenticate

Gibt an, ob dem Server Authentifizierungsinformationen gesendet werden sollen, bevor man dazu aufgefordert wird.

Proxy

Der für den Webzugang zu verwendende Proxy.

RequestUri

Der mit der Anforderung verknüpfte URI der Internetressource.

Timeout

Der Zeitraum, den die Anforderung auf eine Serverantwort maximal warten darf.

Methode

Beschreibung

GetRequestStream Liefert einen Stream, der sich für Datenlieferungen an den Server nutzen lässt. GetResponse

Liefert einen Stream, der die Serverantwort enthält.

Tabelle 12.1: Die Mitglieder von WebRequest

Anfragen mit WebResponse verarbeiten Die WebResponse-Klasse verarbeitet die Serverantwort. Diese einfache Klasse umfasst nicht viele Mitglieder. Tabelle 12.2 zeigt die Eigenschaften und Methoden von WebResponse. Eigenschaft

Beschreibung

ContentLength

Die Länge der übermittelten Daten.

ContentType

Typ und Format der übermittelten Daten.

Tabelle 12.2: Mitglieder von WebResponse

427

Formulare Internet-fähig machen

Eigenschaft

Beschreibung

Headers

Die Auflistung von HTTP-Headern, die mit einer Anforderung geschickt werden.

ResponseUri

Der URI der antwortenden Ressource.

Methode

Beschreibung

Close

Schließt den Antwortstream, so dass mithin auch die Verbindung zum Server beendet wird.

GetResponseStream

Liefert einen Stream, der die Antwort des Servers enthält.

Tabelle 12.2: Mitglieder von WebResponse (Forts.)

Protokollspezifische Klassen Bislang haben Sie gelernt, die Helferklassen WebRequest und WebResponse zu erstellen, wenn es um Web-Interaktionen geht. In den meisten Fällen genügen diese beiden Klassen. Die Helferklassen können aber auch zusätzliche Funktionen bereitstellen. Angenommen, Sie müssen einmal den Typ der Anwendung angeben, die auf den Server zugreift – wie zum Beispiel ein Internet Explorer-kompatibler Browser. Diese Informationen bezeichnet man als Benutzer-Agent (user-agent). Mit dem WebRequest-Objekt lässt sich der Typ nicht direkt bereitstellen, doch seine Helferklasse HttpWebRequest, die bei der HTTP-Verarbeitung hilft, kann dies: ((HttpWebRequest)objRequest).UserAgent = "Internet Explorer";

Um auf die HttpWebRequest-spezifischen Eigenschaften zuzugreifen, müssen Sie die WebRequest-Variable passend konvertieren, wie im obigen oder im folgenden Codefragment gezeigt: HttpWebRequest objHttpRequest = (HttpWebRequest)objRequest;

Tabelle 12.3 zeigt die Mitglieder von HttpWebRequest, zusätzlich zu denen in Tabelle 12.1. Eigenschaft

Beschreibung

Accept

Entspricht dem Accept-HTTP-Header.

Address

Gibt den URI des Servers an, der tatsächlich auf die Anforderung antwortet (kann sich von Uri unterscheiden).

Tabelle 12.3: Die Mitglieder von HttpWebRequest (ergänzend zu Tabelle 12.1)

428

Clients und Server

Eigenschaft

Beschreibung

AllowAutoRedirect

Gibt an, ob die Anforderung vom Server veranlasste Umleitungen zulassen soll.

AllowWriteStreamBuffering

Gibt an, ob der Antwortstream gepuffert werden soll (verbessert oftmals die Leistung).

ClientCertificates

Liefert Clientsicherheitszertifikate.

Connection

Entspricht dem Connection-HTTP-Header.

ContinueDelegate

Kennzeichnet einen Delegaten, der auf eine HTTP-100-Meldung antworten kann.

CookieContainer

Kennzeichnet die Cookies, die der Anforderung zugeordnet sind.

Expect

Entspricht dem Expect-HTTP-Header.

HaveResponse

Gibt an, ob vom Server eine Nachricht empfangen wurde.

IfModifiedSince

Entspricht dem If-Modified-Since-HTTP-Header.

KeepAlive

Gibt an, ob das Anforderungsobjekt eine dauerhafte Verbindung zum Server aufrechterhalten soll.

MaximumAutomaticRedirections

Legt die maximale Anzahl von Umleitungen fest, die das Anforderungsobjekt zulässt.

MediaType

Gibt den Medientyp der Anforderung an.

Pipelined

Gibt an, ob Anforderungen an den Server durch eine Pipeline erfolgen sollen (funktioniert nur, wenn KeepAlive auf true gesetzt wurde).

ProtocolVersion

Legt die zu verwendende HTTP-Version fest.

Referer

Entspricht dem Referer-HTTP-Header.

SendChunked

Gibt an, ob dem Server Daten in Segmenten geschickt werden sollen.

ServicePoint

Legt den Dienstpunkt fest, der für den Server zu verwenden ist.

TransferEncoding

Entspricht dem Transfer-encoding-HTTP-Header.

UserAgent

Entspricht dem User-agent-HTTP-Header.

Tabelle 12.3: Die Mitglieder von HttpWebRequest (ergänzend zu Tabelle 12.1) (Forts.)

Um mehr Informationen über die verschiedenen HTTP-Header zu erhalten, suchen Sie bitte die Website des WWW-Consortiums auf (www.w3c.org).

429

Formulare Internet-fähig machen

12.3 Arbeiten mit dem Internet Explorer Unter dem .NET Framework können Sie Ihre Windows Forms-Anwendungen mit dem Internet Explorer zusammenarbeiten lassen. Dies erspart Ihnen eine Menge der Zeit, die Sie früher mit dem Umschreiben Ihrer Desktop-Anwendungen für den Einsatz im Internet verwendet haben. Wenn Sie also zum Beispiel eine nützliche Windows Forms-Anwendung erstellt haben, dann kann jedermann sie mit Hilfe des Internet Explorers über das Internet erreichen (vorausgesetzt, man hat die korrekten Berechtigungen und zudem das .NET Framework installiert). Wir wollen die am 5. Tag erstellte Taschenrechner-Anwendung wiederverwenden. Verschieben Sie diese Anwendung in das Web-Stammverzeichnis Ihres Computers (c:\inetpub\wwwroot), öffnen Sie Ihren Browser und tippen Sie Folgendes in die Adresszeile ein: http://localhost/Anwendungsname.exe

(Ersetzen Sie Anwendungsname.exe durch den tatsächlichen Dateinamen der Anwendung.) Ihr Browser wird die Anwendung aufrufen, die nun genau wie eine normale Windows Forms-Anwendung läuft. Abbildung 12.4 zeigt das Ergebnis.

Windows Forms-Steuerelemente in den Internet Explorer einbetten Sie können in den Internet Explorer auch Windows Forms-Steuerelemente einbetten, wenn Sie das HTML-Tag