User Interfaces (Teil 2)

Veröffentlicht: 23. Mai 2002 | Aktualisiert: 20. Jun 2004

Von Bernd Marquardt

Die Bedienoberfläche ist das Aushängeschild einer Anwendung. Bei der Programmierung kommt es deshalb auf einfache und flexible Gestaltungsmöglichkeiten an. Die Windows Forms des .NET Framework bieten dem Programmierer genau diese Unterstützung. Der zweiteilige Artikel zeigt, wie Sie schnell ein Fenster mit Menü, Toolbar, Statuszeile und Dialogen ausstatten.

Auf dieser Seite

 Einen Toolbar hinzufügen
 Eine Statuszeile hinzufügen
 Einen modalen Dialog hinzufügen
 ...und noch ein nicht modaler Dialog
 Fazit

Einen Toolbar hinzufügen

In Erweiterung unseres Beispiels werden wir unserem kleinen Programm nun einen Toolbar spendieren. Wechseln Sie in den Form-Designer mit einem Klick auf den Reiter Form1.cs [Entwurf]. Öffnen Sie die Toolbox, klicken Sie mit der linken Maustaste im Bereich Windows Forms auf das Control Toolbar und ziehen dieses dann mit der Maus auf Ihre Form. Dieser Toolbar ist im Moment noch leer und enthält keine Schaltflächen.

Damit unser Toolbar auch Bilder auf den Schaltflächen anzeigen kann, müssen wir zunächst ein Imagelist-Control erzeugen und mit unserem Toolbar verbinden.

Ziehen Sie aus der Toolbox mit der linken Maustaste das Steuerelement Imagelist auf die Haupt-Form. Da die Imagelist kein Steuerelement mit einer sichtbaren Benutzerschnittstelle, sondern nur ein Container für mehrere Bilder ist, erscheint sie nicht sichtbar auf unserem Fenster. Statt dessen werden solche Steuerelemente im unteren Teil des Designer-Fensters aufgelistet.

Nun fügen wir unserem Imagelist-Control zwei Bilder (Images) hinzu, die dann später auf den Schaltflächen des Toolbar zu sehen sein sollen. Markieren Sie im unteren Fenster des Form-Designers das Objekt imagelist1. Im Property-Fenster klicken Sie nun auf die Schaltfläche rechts neben dem Eintrag (Collection) (Auflistung) des Property Images. Der Image Collection Editor" (Image-Auflistungs-Editor) zum Einfügen von Bildern erscheint in einem Dialogfenster. Mit der Schaltfläche Add (Hinzufügen) können nun Bilder als Dateien über den bekannten Datei-öffnen-Dialog ausgewählt und in die Liste aufgenommen werden. Im unteren Bild wurden bereits zwei Bitmaps in die Collection aufgenommen. In rechten Teil des Dialogs (Properties) werden verschiedene Eigenschaften der geladenen Images angezeigt.

Sie können weitere Bilder der Collection hinzufügen. Schließen Sie zum Schluss den Image-Auflistungs-Editor mit einem Klick auf die Schaltfläche OK. Die Imagelist enthält nun die ausgewählten Bitmaps in der vorgegebenen Reihenfolge.

Jetzt kann das Imagelist-Steuerelement unserem Toolbar als Ressource für die Bilddaten auf den Schaltflächen dienen. Markieren Sie im Form-Designer den Toolbar in der Hauptform. Im Eigenschaftsfenster wählen Sie bei der Eigenschaft Imagelist des Toolbars im Kombinationsfeld das Objekt imageList1 aus. Dort gibt es momentan auch nur die eine Bilderliste. Jetzt sind zwar die Bilder mit dem Toolbar verbunden, aber uns fehlen immer noch die Schaltflächen.

Klicken Sie darum im Eigenschaftsfenster rechts neben Buttons auf den Eintrag Collection (Auflistung). Daraufhin öffnet sich der Dialog "ToolbarButton Collection Editor". Hier werden die Schaltflächen für den Toolbar definiert. In der folgenden Abbildung sind bereits drei Schaltflächen über den Befehl Add erzeugt worden. Im rechten Fenster des Dialogs (Properties) können Sie die Eigenschaften der einzelnen Schaltflächen setzen.

Für unser Beispiel wollen wir drei ToolBarButton-Objekte unserem Toolbar zufügen. Gehen Sie dazu wie folgt vor:

Klicken Sie dreimal auf die Schaltfläche Add (Hinzufügen). Markieren Sie anschließend im Fenster Member mit der Maus das Objekt toolBarbutton1 und setzen Sie im rechten Fenster die Eigenschaft Style durch Auswahl im Kombinationsfeld auf Separator. Dadurch hat die erste Schaltfläche im Toolbar etwas Abstand vom linken Fensterrand.

Markieren Sie nun das Objekt toolBarButton2. Weisen Sie im rechten Fenster dem Property ImageIndex ein Bild aus der Imagelist zu und geben Sie bei der Eigenschaft Text den Text Öffnen ein. Setzen Sie die Eigenschaft Name auf toolOpen. Wenn Sie möchten, können Sie auch noch einen ToolTipText definieren, der immer dann angezeigt wird, wenn Sie mit der Maus über der Schaltfläche stehen bleiben.

Abschließend markieren Sie das Objekt toolBarButton3. Weisen Sie dem ImageIndex ein anderes Bild aus der Imagelist zu, geben als Property Text das Wort Beenden ein und setzen Sie die Eigenschaft Name auf toolExit.

Nun schließen Sie den Dialog durch Anklicken der Schaltfläche OK im ToolBarButton-Collection-Editor. Übersetzen und starten Sie das Programm. Unser Toolbar ist zwar im Hauptfenster sichtbar, aber ein Anklicken der Schaltflächen bewirkt gar nichts. Außerdem haben die beiden Schaltflächen eine unterschiedliche Größe.

Die Größe der Schaltflächen kann sehr einfach angepasst werden: Gehen Sie in den Form-Designer von Form1 und klicken Sie mit der linken Maustaste auf den Toolbar. Im Property-Fenster stellen Sie nun die Eigenschaft ButtonSize auf den Wert 60; 36. Die Schaltflächen haben nun (schon im Design-Modus) eine einheitliche Grösse.

Leider ist es nicht möglich, für die einzelnen Schaltflächen im Toolbar auch einzelne Methoden für den jeweiligen abzuarbeitenden Code zu implementieren. Der Toolbar liefert nur ein Event für alle Schaltflächen des Toolbars, nämlich das ButtonClick-Ereignis. Führen Sie im Form-Designer einen Doppelklick auf den Toolbar, nicht auf eine Toolbar-Schaltfläche, aus. Die IDE wechselt in die Code-Ansicht und zeigt Ihnen die leere Methode für das ButtonClick-Ereignis:

private void toolBar1_ButtonClick(object sender, System.Windows.Forms.ToolBarButtonClickEventArgs e) { }

Dieses Mal ist der Übergabeparameter e sehr wichtig. Dieser Parameter ist vom Typ ToolBarButtonClickEventArgs und enthält die Eigenschaft Button, die Auskunft dar-über gibt, welche Schaltfläche vom Anwender angeklickt worden ist. Eine Möglichkeit besteht nun darin, in einer einfachen if-Abfrage zu prüfen, welche Schaltfläche angeklickt wurde und dann den entsprechenden Menühandler aufzurufen:

private void toolBar1_ButtonClick(object sender, System.Windows.Forms.ToolBarButtonClickEventArgs e) { if(e.Button == toolOpen) // Menübefehl Öffnen { // Haben wir noch nicht implementiert } else if(e.Button == toolExit) // Menübefehl Beenden { menuItem8_Click(sender, e); } }

Diese Implementation ist jedoch nicht so schön, da man mit jedem neuen Toolbar-Button die ButtonClick-Methode erweitern muss. Eine andere Variante speichert in der Tag-Eigenschaft einer Toolbar-Schaltfläche das MenuItem-Objekt, das zu dieser Schaltfläche gehört. Dies kann im Konstruktor der Form-Klasse nach InitializeComponent()geschehen. Für die Beenden-Schaltfläche sieht das dann so aus:

toolExit.Tag = menuItem8;

Wichtig: Tippen Sie den Text menuItem8 nicht einfach in die Eigenschaft Tag ein. Sonst erhalten Sie eine InvalidCastException, da das Programm nicht einen String in ein Objekt wandeln kann. Der Weg über die Funktion InitializeComponent() ist der richtige.

Der Aufruf in der ButtonClick-Methode ist dann etwas komplizierter, muss aber nie mehr geändert werden. Ersetzen Sie den alten Code durch folgenden Befehl:

private void toolBar1_ButtonClick(object sender, System.Windows.Forms.ToolBarButtonClickEventArgs e) { ((MenuItem) e.Button.Tag).PerformClick(); }

Übersetzen und testen Sie das Programm.

 

Eine Statuszeile hinzufügen

Erweitern wir unser Beispiel jetzt um eine einfache Statuszeile. Fügen Sie, wie weiter oben schon beschrieben, im Design-Modus aus der Toolbox das Control Statusbar zur Form Form1 hinzu. Markieren Sie anschließend mit der linken Maustaste diese Statuszeile und setzen Sie im Eigenschaftsfenster-Fenster die Eigenschaft ShowPanels auf den Wert True. Klicken Sie danach im Property Panels auf den Button rechts neben den Eintrag (Collection) (Auflistung).

Wie schon bei anderen Steuerelementen, öffnet sich auch hier ein Editor zur Bearbeitung einer Auflistung, diesmal für die Abschnittsobjekte der Statuszeile. Durch Klicken auf die Schaltfläche Add (Hinzufügen) fügen Sie ein StatusBarPanel-Objekt zu dieser Collection hinzu. Ordnen Sie dem Property Icon ein Bild zu und setzen Sie das Property Text zunächst einmal auf Information.

Übersetzen und testen Sie das Programm.

In einer Applikation kann der Text in der Statuszeile je nach der durchgeführten Aktion gesetzt werden. So kann das Programm beispielsweise die Position des Mauszeigers im Fenster in der Statuszeile ausgeben.

Dazu überschreiben wir die Methode MouseMove. Im Form-Designer mit der Form Form1 klicken Sie im Eigenschaftsfenster auf den Blitz. Nun wird die Darstellung in diesem Fenster umgeschaltet und Sie sehen alle Events (Ereignisse) und überschreibbaren Methoden. Suchen Sie im Property-Fenster in der linken Spalte MouseMove und machen Sie dann darauf einen Doppelklick.

Die Visual-Studio-IDE schaltet um in die Code-Ansicht und zeigt Ihnen die Methode Form1_MouseMove. Sie können bei Bedarf auch einen anderen Namen für die Methode wählen. Tragen Sie den folgenden Code in die Methode ein:

private void Form1_MouseMove(object sender, System.Windows.Forms.MouseEventArgs e){ string strOut; strOut = "X: " + e.X.ToString() + " Y: " + e.Y.ToString(); statusBarPanel1.Text = strOut; }

Übersetzen und starten Sie das Programm. Bewegen Sie den Mauszeiger über das Fenster und beobachten Sie die Statuszeile.

 

Einen modalen Dialog hinzufügen

Um unser Beispiel abzurunden, werden wir dem Programm nun noch eine neue Form-Klasse als Dialog hinzufügen und sie über einen Menüpunkt aufrufen.

Klicken sie im Solution Explorer (Projektmappen-Explorer) mit der rechten Maustaste auf den Eintrag myWinApp in der Baumansicht. Im Kontextmenü klicken Sie mit der linken Maustaste auf den Menüeintrag Add (Hinzufügen). In dem nun erscheinenden Untermenü wählen Sie den Menübefehl Add Windows Form … (Windows Form hinzufügen) aus. In der folgenden Abbildung können Sie den Befehlsaufruf in Visual Studio .NET noch einmal nachvollziehen.

Daraufhin öffnet sich ein Dialog, in dem Sie den Typ des neuen Fensters und den Dateinamen für die neue Klasse eingeben können. Hier wollen wir eine neue Windows Form hinzufügen. Den vorgegebenen Dateinamen Form2.cs übernehmen wir unverändert. Somit heißt die neue Klasse ebenfalls Form2.

Drücken Sie also auf die Schaltfläche OK, und der Wizard fügt Ihrem Projekt die neue Klasse hinzu. Diese wird automatisch im Solution Explorer angezeigt und markiert. Gleichzeitig öffnet sich der Form-Designer mit der neuen (noch leeren) Form zur Bearbeitung.

Folgende Steuerelemente (siehe nächste Abbildung) sollen im Dialog platziert werden (Ansicht im Form-Designer von Visual Studio):

Alle benutzten Steuerelemente finden Sie in der Toolbox unter der Rubrik Windows Forms. Ziehen Sie die benötigten Steuerelemente einfach mit Drag & Drop an die gewünschte Position auf der Form. Für die beiden Text-Labels setzen Sie das Text-Property auf &Name: bzw. &Passwort:.

Bei den zwei Eingabefeldern entfernen Sie den Text aus dem Text-Property. Bei den beiden Schaltflächen stellen Sie im Text-Property die Texte OK und Abbrechen ein. Die Eigenschaft Name setzen Sie für die Schaltflächen entsprechend auf buttonOK and buttonCancel. Die Logik für die Schaltflächen fügen wir später hinzu. Bei der Listbox stellen Sie die Größe so ein, dass das Steuerelement den Rest des Fensters ausfüllt.

Um den Dialog von einem bestimmten Menüpunkt aus aufzurufen, müssen wir zunächst wieder einen Eventhandler implementieren. Wechseln Sie bitte in die Form-Designer-Ansicht Form1.cs [Design], selektieren Sie im Menü der Form1 das Popup-Menü Ansicht und führen Sie dort mit der linken Maustaste auf den Menüpunkt Modal Dialog einen Doppelklick aus.

Nun wird die Methode zur Verarbeitung des Click-Events für diesen Menübefehl im Sourcecode der Klasse Form1 hinterlegt und der entsprechende Event wird in Initialize-Component() angelegt. Der Code-Editor springt nun automatisch in die neue Methode. Dort ergänzen Sie die dargestellten Zeilen zum Aufruf der Form2 als modalen Dialog:

private void menuItem9_Click(object sender, System.EventArgs e) { Form2 myDlg = new Form2(); myDlg.ShowDialog(); }

Die mit in die Methode übergebenen EventArgs werden hier nicht weiter benötigt. Wir können unser Programm nun übersetzen, starten und den Aufruf des Dialogs überprü-fen. Hier sehen wir, dass der Dialog in der unteren rechten Ecke einen Marker für die Veränderung seiner Größe hat. Was passiert nun, wenn wir die Größe des Dialogs ändern? In der nächsten Abbildung sehen Sie das (eher enttäuschende) Resultat:

Außerdem fällt auf, dass der Eingabecursor nicht in der Editbox Name steht. Das wollen wir beheben.

Beginnen wir mit der Tab-Order, die die Reihenfolge festlegt, mit der die Steuerelemente auf der Form angesprungen werden, wenn die Tab-Taste gedrückt wird. Wechseln Sie ggf. in die Design-Ansicht der Form2 und rufen Sie dann den Befehl View | Tab Order (Ansicht | Tablulator-Reihenfolge) der Visual-Studio-IDE auf. Nun wird die Form2 mit der aktuellen Reihenfolge der Tabs dargestellt (siehe folgende Abbildung). Die Reihenfolge der Tabs kann bei Ihnen etwas anders sein, da sie von der Reihenfolge abhängig ist, wie Sie die Steuerelemente auf der Form erzeugt haben.

Nun kann man die korrekte Reihenfolge der Tabs sehr leicht festlegen: Klicken Sie einfach mit der linken Maustaste die gewünschte Reihenfolge im Dialog durch. Also zuerst auf das Text-Label Name, dann auf die Editbox rechts daneben. Danach auf das Text-Label Passwort und auf die dazugehörige Editbox.

Schießlich klicken Sie auf die Listbox, dann auf die OK- und zum Schluss auf die Abbrechen-Schaltfläche. Nun rufen Sie wieder den Menüpunkt View | Tab Order in der IDE auf. Die Zahlen verschwinden und nach der nächsten Übersetzung ist diese neue Tab-Order aktiv.

Im nächsten Schritt wollen wir den Dialog so erweitern, dass man die Größe beliebig ändern kann. Die Größe der einzelnen Steuerelemente soll sinnvoll an die jeweilige Dialoggröße angepasst werden. Hier hilft uns das Anchor-Property der Steuerelemente weiter. Folgende Eigenschaften müssen eingestellt werden:

OK- und Abbrechen-Schaltfläche	Anchor-Property auf "Top, Right"
Beide Eingabefelder	Anchor-Property auf "Top, Left, Right"
Listenfeld	Anchor-Property auf "Top, Bottom, Left, Right"

:
:
:

Übersetzen und starten Sie nun unser Programm, rufen Sie den Dialog auf und verändern Sie nun noch einmal seine Größe. Sie sehen, dass sich die Steuerelemente entsprechend anpassen. Das Anchor-Property sorgt für diesen Effekt.

Werfen wir kurz einen Blick auf die Einstellungen für die beiden Schaltflächen. Das Anchor-Property wurde auf Top, Right gesetzt. Das bedeutet, dass dieses Steuerelement seinen festen Abstand zum oberen und rechten Fensterrand behält. Wird nun das Fenster vergrößert, so wandern die Schaltflächen OK und Abbrechen einfach in konstantem Abstand zum rechten Fenterrand mit. Die anderen Anchor-Einstellungen können Sie entsprechend interpretieren. Da bei den Eingabefeldern das Anchor-Property auf Top, Left, Right gesetzt wurde, werden diese Felder beim Verbreitern des Dialogs ebenfalls vergrö-ßert.

Allerdings haben wir mit unserer Lösung noch ein kleines Problem: Verkleinern Sie den Dialog einmal bis auf wenige hundert Pixel Größe. Das Ergebnis (siehe Abbildung) ist nicht sehr schön.

Einzelne Steuerelemente überlagern sich einfach und machen die Eingabe von Werten unmöglich. Für das Fenster Form2 gibt es allerdings eine Eigenschaft, mit der wir das Problem in den Griff bekommen. Selektieren Sie im Form-Designer die Form Form2, indem Sie auf die Titelzeile der Form klicken. Im Property-Fenster suchen Sie nun die Eigenschaft MinimumSize und setzen diese auf 250, 250. Diesee Eigenschaft gibt nun an, dass Form2 nicht kleiner als 250 mal 250 Pixel werden darf. Bei Bedarf können Sie auch die Eigenschaft MaximumSize einer Form setzen. Übersetzen Sie das Programm und testen Sie jetzt nochmal den Dialog.

Was hier fasziniert, ist, dass der in der Größe änderbare Dialog komplett ohne Programmieraufwand erzeugt werden konnte. Mit dem Anchor-Property können die meisten Dialoge, die in der Größe modifizierbar sein sollen, sehr leicht und ohne großen Aufwand entsprechend erstellt werden.

Wir sind aber mit unserem modalen Dialog noch nicht fertig. Wenn Sie beim Testen einmal zufällig auf die Abbrechen-Schaltfläche geklickt haben, werden Sie bemerkt haben, dass der Dialog nicht verschwindet bzw. beendet wird. Auch hier helfen uns zwei Eigenschaften der Form-Klasse weiter: AcceptButton und CancelButton.

Öffnen Sie in der Design-Ansicht der Form Form2 im Property-Fenster das Kombinationsfeld der Eigenschaft AcceptButton und wählen Sie das Objekt buttonOK aus. Zur Erinnerung: Das ist der Name unserer OK-Schaltfläche. Für die Eigenschaft CancelButton wählen Sie entsprechend das Objekt buttonCancel aus. Nach dem Übersetzen können Sie den Dialog aufrufen und mit der Schaltfläche Abbrechen beenden.

Allerdings müssen wir nun noch der aufrufenden Funktion (unsere Methode menuI-tem9_Click in Form1) irgendwie mitteilen, welche Schaltfläche zum Beenden des Dialogs angeklickt wurde: OK oder Abbrechen. Hierzu benutzen wir die Eigenschaft DialogResult der Schaltflächen.

Selektieren Sie nun die OK-Schaltfläche und wählen Sie im Property-Fenster für die Eigenschaft DialogResult im Kombinationsfeld den Eintrag OK aus. Für die Schaltfläche Abbrechen stellen Sie die Eigenschaft auf Cancel ein.

Was haben wir nun davon? Auch die Form-Klasse enthält die Eigenschaft DialogResult. Wird nun im Dialog die OK- oder Abbrechen-Schaltfläche angeklickt, so wird der entsprechende DialogResult-Wert an die Form weitergegeben. Diesen Wert kann man nun benutzen, um nach dem Aufruf von myDlg.ShowDialog() in der Klasse Form1 festzustellen, ob die Dialog-Eingabedaten jetzt verarbeitet werden müssen (OK) oder nicht (Abbrechen). Gehen Sie nun in die Code-Ansicht der Klasse Form1 und suchen Sie die Methode menuItem9_Click, in der wir den Dialog aufgerufen haben. Fügen Sie dort den Code nach dem folgenden Listing ein:

private void menuItem9_Click(object sender, System.EventArgs e) { Form2 myDlg = new Form2(); myDlg.ShowDialog(); if(myDlg.DialogResult == DialogResult.OK) { MessageBox.Show("OK wurde angeklickt."); } Else { MessageBox.Show("Es wurde nicht OK angeklickt."); } }

Beachten Sie bitte, dass wir bei der if-Abfrage der Eigenschaft DialogResult der Form die Aufzählung DialogResult aus der .NET-Klassenbibliothek benutzen und nicht mit konstanten Zahlenwerten arbeiten. Dadurch ist der Code unabhängig von Änderungen in der Klassenbibliothek und Migrationen auf andere Plattformen.

Die letzte Frage, die sich noch stellt, ist: Wie bekomme ich meine Eingaben aus dem Dialog heraus? Hierzu kann man eigene Eigenschaften in der Dialog-Klasse Form2 implementieren. Ich möchte das hier für die beiden Eingabefelder zeigen.

Schalten Sie dazu zunächst in den Class View (Klassenansicht)(das ist das Tab neben Solution Explorer (Projektmappen-Explorer)). Dort sehen Sie in der Baumansicht die Applikation myWinApp und darunter die beiden Form-Klassen Form1 und Form2, die wir erzeugt haben. Wenn Sie nun (wie unten in der Abbildung) den Baum für die Klasse Form2 öffnen, dann können Sie die Methoden und Felder der Klasse sehen. Ein Doppelklick auf eine Methode im Class View öffnet des Code-Fenster mit der ausgewählten Methode. Ein Doppelklick auf ein Feld (z.B. buttonOK) zeigt den Code mit der Deklaration dieses Feldes.

Klicken Sie nun mit der rechten Maustaste im Class View auf Form2. Im Kontextmenü wählen Sie nun Add (Hinzufügen) aus und im danach erscheinenden Menü den Befehl Add Property... (Eigenschaft hinzufügen …). Auf dem Bildschirm wird der Dialog für die Definition eines Properties (Property Wizard) sichtbar:

Für das erste Property unserer Form2-Klasse wählen Sie als Property type (Eigenschaftstyp) string aus. Als Property name (Eigenschaftsname) tragen Sie den Text Username ein. Klicken Sie auf die Schaltfläche Finish (Fertigstellen). In der Form2-Klasse wird nun vom Wizard das Konstrukt für ein get/set-Property angelegt. Das Code-Fenster wird automatisch angezeigt. Implementieren Sie dann folgenden Code:

public string Username { Get { return textBox1.Text; } Set { textBox1.Text = value; } }

Beim set-Property müssen Sie wissen, dass der Wert, der übergeben wird, immer in der Variablen value steht. Das zweite Property, welches wir implementieren wollen, ist ein reines get-Property und soll das Passwort zurückgeben. Wieder rufen wir über den Class View den Befehl Add property... (siehe oben) auf und tragen folgende Angaben im Eigenschafts-Wizard ein:

Property access	public (unverändert)
Property type	string
Property name	Passwort
Accessors	get

:
:
:
:

Vergessen Sie nicht, auf die Optionsschaltfläche get in der Rubrik Accessoren zu klicken, da für das Property Passwort ein Setzen eher unüblich ist. Implementieren Sie dann den folgenden Code:

public string Passwort { Get { return textBox2.Text; } }

Nun müssen wir noch beim Aufruf des Dialogs in der Klasse Form1 einige Änderungen durchführen. Gehen Sie auf die Code-Ansicht der Klasse Form1 und ändern Sie die Methode menuItem9_Click wie unten dargestellt:

private void menuItem9_Click(object sender, System.EventArgs e) { Form2 myDlg = new Form2(); myDlg.Username = "NoName"; myDlg.ShowDialog(); if(myDlg.DialogResult == DialogResult.OK) { string strOut = "Username: " + myDlg.Username; strOut += " Password: " + myDlg.Passwort; MessageBox.Show(strOut); } Else { MessageBox.Show("Fehler: Keine gültige Eingabe gemacht."); } }

Wenn Sie nun das Programm übersetzen und testen, können Sie je nach Dialog-Beendigung die eingegebenen Daten oder die Fehlermeldung sehen. Außerdem wird das Eingabefeld Name im Dialog mit dem Wert NoName vorbesetzt.

 

...und noch ein nicht modaler Dialog

Zum Abschluss wollen wir einen nicht modalen Dialog erzeugen. Selektieren Sie wieder im Menü der Form1 das Popup-Menü Ansicht und anschließend den Menübefehl "Non-Modal Dialog". Klicken Sie auf diesen Menüpunkt doppelt. Es werden wieder eine leere Methode und der Eventhandler im Sourcecode erzeugt. In dieser Methode ergänzen Sie den Code zum Aufruf der Form2 als nicht modalen Dialog:

private void menuItem10_Click(object sender, System.EventArgs e){ Form2 mydlg = new Form2(); mydlg.Show(); }

Übersetzen und starten Sie jetzt das Programm wieder und wählen Sie den Menübefehl NonModal Dialog im Popup-Menü Ansicht aus. Die Form2 öffnet sich jetzt als nicht modaler Dialog und es ist möglich, in das aufrufende Programm zurückzukehren, ohne den Dialog wieder schließen zu müssen. Auch die Schaltflächen OK und Abbrechen funktionieren nicht, wie gewohnt. Des weiteren ist es jetzt möglich, mehrere Instanzen des Dialogs zu öffnen.

Beenden Sie nun die Anwendung. Alle geöffneten nicht modalen Dialoge werden ebenfalls geschlossen.

 

Fazit

In wenigen Schritten haben wir mit Hilfe der Windows Forms den Rahmen für eine neue Anwendung erzeugt. Dazu gehören Hauptfenster, Menüleiste, Toolbar, Statusbar und Dialoge. Auch die Grundzüge für die Implementation der Bedienlogik hat der Artikel aufgezeigt.Es zeigt sich, dass die Windows-Forms-Klassen im .NET Framework eine hervorragende Plattform für das Programmieren von Rich-Client-User-Interfaces darstellen.

Leider konnte hier nur ein kleiner Teilbereich von Windows Forms betrachtet werden. Dennoch sollte dieser erste Einblick für Sie ein Anreiz sein, sich eingehender mit diesem Bereich von .NET zu beschäftigen.