Entwickeln benutzerdefinierter Windows-Steuerelemente mit Visual Basic .NET

 

Duncan Mackenzie
Microsoft Developer Network

Mai 2002

Zusammenfassung: Eine Übersicht über zugehörige Beispielartikel, die die grundlegenden Konzepte der Entwicklung von Microsoft Windows-Steuerelementen anhand von Diskussionen und Codeausschnitten veranschaulichen. (7 gedruckte Seiten)

Laden Sie WinFormControls.exeherunter.

Diese Übersicht ist die erste in einer Fünf-Artikel-Reihe über die Entwicklung von Steuerelementen in Microsoft® .NET:

• Entwickeln von benutzerdefinierten Windows-Steuerelementen mit Visual Basic .NET (Übersicht)
• Hinzufügen der Validierung regulärer Ausdrücke
• Kombinieren mehrerer Steuerelemente zu einem Steuerelement
• Erweitern des TreeView-Steuerelements
• Zeichnen eigener Steuerelemente mit GDI+

Inhalte

Einführung
Warum eigene Steuerelemente entwickeln?
Wie die Vererbung die Steuerungsentwicklung geändert hat
Ressourcen
Beispiele
Zusammenfassung

Einführung

Eines der größten Verkaufsargumente von Microsoft® Visual Basic® war schon immer die Unterstützung von Komponenten, die es Drittanbietern ermöglicht, visuelle Steuerelemente (und schließlich nicht visuelle Komponenten) zu entwickeln, die dem Visual Basic-Entwickler neue Funktionen bereitstellten. Dieser Aspekt der Visual Basic-Entwicklung führte zur Verfügbarkeit einer großen Anzahl von Steuerelementen – sowohl Shareware/Freeware als auch von Entwicklungsshops von Drittanbietern. Schließlich könnten neue visuelle und nicht-visuelle Komponenten sogar direkt in Visual Basic entwickelt werden, was die Entwicklung einer noch größeren Anzahl von Steuerelementen ermöglicht, von denen viele von Programmierern (und Programmierteams) für ihren eigenen Gebrauch erstellt wurden.

Hinweis Wenn Sie oder Ihr Team derzeit Microsoft ActiveX-Steuerelemente® verwenden, muss der Wechsel zu Microsoft .NET nicht ein Upgrade oder ein erneutes Schreiben bedeuten. Mithilfe der integrierten Entwicklungsumgebung von Microsoft Visual Studio® .NET (IDE) (im Menü Extras wählen Sie Toolbox anpassen) oder mit dem .NET Framework Hilfsprogramm ActiveX Control Importer (Aximp.exe) können ActiveX-Steuerelemente in .NET-Anwendungen verwendet werden. Wenn ein bestimmtes Steuerelement in .NET nicht funktioniert, muss es möglicherweise vom Autor der Komponente aktualisiert werden. Wenn Sie mit Steuerelementen arbeiten, die von einem Drittanbieter erworben wurden, überprüfen Sie die Website des Anbieters auf ein Update des Steuerelements oder einer .NET-Version.

In der Welt der .NET-Entwicklung ist die Notwendigkeit benutzerdefinierter Ui-Komponenten weiterhin vorhanden, aber die Mechanismen zum Erstellen dieser Komponenten haben sich geändert. In diesem Artikel wird erläutert, warum Sie Microsoft Windows-Steuerelemente® erstellen möchten, wie sich die Steuerungsentwicklung von Visual Basic 5.0 und Version 6.0 geändert hat, und ich werde vier Beispiele (jeweils in einem eigenen Artikel behandelt) der Steuerungsentwicklung vorstellen.

Warum eigene Steuerelemente entwickeln?

Wenn Sie den Texttyp einschränken möchten, der in ein Textfeld auf einem Windows-Formular eingegeben werden kann, können Sie in den Code Ihres Formulars wechseln und eine Prozedur erstellen, um das KeyPress-Ereignis im Textfeld zu behandeln. In diesem Fall würden Sie dann den gedrückten Schlüssel überprüfen und entscheiden, ob er zulässig sein soll:

Private Sub TextBox1_KeyPress(ByVal sender As Object, _
        ByVal e As System.Windows.Forms.KeyPressEventArgs) _
        Handles TextBox1.KeyPress
    If Not Char.IsDigit(e.KeyChar) Then
        e.Handled = True
    Else
        e.Handled = False
    End If
End Sub

Hinweis Das Drücken der Auffangtaste stellt nicht sicher, dass nur Ziffern eingegeben werden, da der Benutzer einen Wert einfügen könnte oder das TextBox-Element mit ungültigen Daten beginnen könnte. Andere Ereignisse, z. B . TextChanged, decken mehr Möglichkeiten ab, aber ich persönlich bevorzuge es, die Überprüfung durchzuführen, wenn der Benutzer das Eingabesteuerelement mit dem Validierungs- oder Leave-Ereignis verlässt. Wenn Sie das Steuerelement nur beim Verlassen des Steuerelements überprüfen, wird das sofortige Feedback entfernt, das Sie erhalten würden, indem Sie ungültige Tastenanschläge blockieren. Es ermöglicht dem Benutzer jedoch, Text einzufügen, der "leicht ungültig" ist, z. B. "342 2343 2342", in ein Feld, das keine Leerzeichen zulässt, und ihn dann vor dem Verlassen des Steuerelements zu beheben.

Das Hinzufügen von Code zum Ereignis eines Steuerelements ist nicht besonders schwierig, aber was geschieht, wenn Sie beginnen, schwieriger zu programmieren, z. B. das Überprüfen einer Postanschrift oder der VIN#eines Fahrzeugs? Sie werden diesen Code wahrscheinlich für mehrere Formulare verwenden möchten, vielleicht sogar in mehreren Projekten, und Sie möchten Ihre Arbeit möglicherweise mit anderen Entwicklern in Ihrem Team teilen. Das Verteilen der Codeausschnitte aus Ihrem Formular zusammen mit Anweisungen zur Benennung und Einrichtung von Steuerelementen wird zu einem echten Problem. Die Entwicklung eines eigenen Steuerelements ist eine Möglichkeit, all diese Verteilungsprobleme zu umgehen, da es die Benutzeroberfläche und den zugehörigen Code in eine einzelne Komponente integriert, die Sie relativ einfach verteilen können. Das Aktualisieren der Funktionalität dieses Steuerelements kann jetzt mit einer Neuverteilung der Assembly Ihrer Komponente erfolgen, anstatt neue Codeausschnitte zu senden und Entwickler aufzufordern, den neuen Code über den alten code einzufügen!

Wie die Vererbung die Steuerungsentwicklung geändert hat

Die Steuerungsentwicklung in .NET unterscheidet sich stark von der in Visual Basic 6.0, und ein großer Teil dieses Unterschieds ist auf die Verfügbarkeit der Vererbung in .NET zurückzuführen. Bei Verwendung von Visual Basic 6.0 waren Sie im Wesentlichen darauf beschränkt, Eigenes Zeichnen und/oder eine Kombination anderer Steuerelemente zu verwenden, um die gewünschte Funktionalität zu erstellen. Wenn Sie das benutzerdefinierte Textfeld erstellen möchten, das weiter oben in diesem Artikel beschrieben wurde, erstellen Sie ein neues ActiveX-Steuerelement, das ein Textfeld enthält.

Hinweis Dieser Prozess wird häufig als Containment und Delegierung bezeichnet und wird auch in Nicht-Steuerungsklassen in Visual Basic 6.0 verwendet, wenn Sie die Vererbung simulieren möchten.

Ihr neues Steuerelement verfügt nicht über eine der erwarteten Eigenschaften eines TextBox-Steuerelements (z. B. eine Text-Eigenschaft ), es sei denn, Sie haben sie selbst hinzugefügt, und Sie müssen sogar Code hinzufügen, um sicherzustellen, dass das TextBox den gesamten Bereich des Benutzersteuerelements in Anspruch nimmt und die Größenänderung verarbeitet. Sie könnten Ihr Ziel sicherlich erreichen, und mit Hilfe des Assistenten für die ActiveX-Steuerungsschnittstelle (ein Visual Basic 6.0-Add-In, siehe Abbildung 1) war es nicht so schwierig für eine Aufgabe, aber um dasselbe Ergebnis in .NET zu erzielen, folgen Sie einem völlig anderen Prozess.

Abbildung 1. Visual Basic 6.0 enthält ein Add-In, um die Steuerelemententwicklung durch automatisches Hinzufügen und Zuordnen von Steuerelementeigenschaften zu vereinfachen.

Die Vererbung ermöglicht es Ihnen, Duplizierungen beim Erstellen eines eigenen Steuerelements zu vermeiden, indem Sie auf der Funktionalität jedes anderen .NET-Steuerelements aufbauen können. Um Ihr eigenes TextBox-Steuerelement zu erstellen, erstellen Sie ein Steuerelement, das vom vorhandenen TextBox-Steuerelement erbt, anstatt von UserControl. Das Basissteuerelement, von dem Sie geerbt haben, bietet Ihnen alle Funktionen, sodass Sie nur die Aspekte des Steuerelements codieren müssen, die sich von der Basis unterscheiden. Wenn Sie sich dies in der Praxis ansehen, sehen Sie sich hier den Code an, der zum Erstellen Ihres eigenen TextBox-Steuerelements erforderlich ist, das die Eingabe nur numerischer Daten zulässt.

Hinweis Wenn Sie diesen Code selbst ausprobieren möchten, erstellen Sie einfach ein neues Visual Basic .NET-Projekt mithilfe der Windows-Anwendungsvorlage, damit Sie über ein leeres Formular zum Ausprobieren Des neuen Steuerelements verfügen, und fügen Sie ihrem Projekt dann eine neue Klasse ( numericTextBox) hinzu. Ersetzen Sie den Code in der neuen Klassendatei durch den code, der als nächstes aufgeführt ist, und erstellen Sie dann Ihr Projekt. Nachdem sie erstellt wurde, können Sie es Ihrer Toolbox hinzufügen. Klicken Sie im Menü Extras auf Toolbox anpassen , und navigieren Sie zu dem .exe, der beim Erstellen Ihres Projekts erstellt wurde:

Public Class NumericTextBox
    Inherits System.Windows.Forms.TextBox
    Protected Overrides Sub OnKeyPress(ByVal e As _
           System.Windows.Forms.KeyPressEventArgs)
        If Not Char.IsDigit(e.KeyChar) Then
            e.Handled = True
        Else
            e.Handled = False
        End If
    End Sub
End Class

Ja, das ist wirklich der gesamte Code, den Sie benötigen, und wenn Sie wirklich wählerisch sind, könnte er durch die Magie der booleschen Logik sogar in weniger Zeilen codiert werden:

Public Class NumericTextBox
    Inherits System.Windows.Forms.TextBox
    Protected Overrides Sub OnKeyPress(ByVal e As _
         System.Windows.Forms.KeyPressEventArgs)
        e.Handled = Not Char.IsDigit(e.KeyChar)
    End Sub
End Class

Ohne etwas anderes zu tun, wird dieses Steuerelement ordnungsgemäß angezeigt, stellt dieselben Ereignisse wie ein TextBox-Element bereit und verfügt über alle Eigenschaften und Methoden eines TextBox-Steuerelements. Sie können sogar Datenbindungen an dieses Steuerelement ohne zusätzliche Programmierung vornehmen, da diese Funktionalität auch vom Basissteuerelement bereitgestellt wird.

Hinweis Dieses Steuerelement ist sehr restriktiv und erlaubt nur die Eingabe der Ziffern 0-9, was bedeutet, dass numerische Daten, die Kommas, Dezimalstellen oder sogar ein negatives Vorzeichen enthalten, ungültig wären. Ich werde einen Blick auf eine funktionalere Methode zum Überprüfen von Eingaben im ersten Beispielartikel werfen. (Weitere Informationen zu den vier Beispielen finden Sie weiter unten in diesem Artikel im Abschnitt Beispiele.)

Dasselbe Steuerelement, das mit Visual Basic 6.0 erstellt wurde, hätte fast die gleiche Menge an aussagekräftigem Code, verfügt aber auch über eine große Menge an Hilfsprogrammcode, um die Größenänderung des Steuerelements und das Verfügbarmachen selektiver Eigenschaften zu verarbeiten. Obwohl die Reduzierung der Menge an Code, die Sie eingeben müssen, ein großartiges Feature ist, ist dies nur ein Vorteil des Erstellens von Steuerelementen mithilfe der Vererbung. Ein leistungsfähigerer Vorteil der Vererbung ist, dass Ihr neu erstelltes Steuerelement mit jedem Code funktioniert, der den Basissteuerelementtyp erwartet hat. Dadurch können Sie Ihr neues NumericTextBox-Steuerelement an jede Routine übergeben, die ein TextBox-Steuerelement erwartet. Wenn Sie ein vorhandenes Steuerelement erweitern, erhalten Sie nicht nur die UserControl-Klasse , sondern profitieren nicht nur von der Funktionalität des Basissteuerelements, sondern auch von der Vertrautheit, die Entwickler mit den Eigenschaften, Methoden und Ereignissen des Basissteuerelements haben. Wer mit dem StandardtextBox arbeiten kann ohne Lernkurve mit der neuen NumericTextBox programmieren. Die Fähigkeit, von einer vorhandenen Klasse (in diesem Fall ein Steuerelement) zu erben, ist einer der leistungsstärkeren Unterschiede zwischen Visual Basic 6.0 und .NET, aber es ist nur einer von vielen. Wenn Sie die Beispiele später in dieser Reihe durchsehen, werden Sie sehen, dass Windows Forms Steuerelemente viele leistungsstarke Features enthalten und im Vergleich zu früheren Versionen von Visual Basic mit relativ wenig Aufwand erstellt werden können.

Ressourcen

Um Ihnen zu helfen, ihre eigenen Windows Forms-Steuerelemente zu erstellen, habe ich eine Liste mit Ressourcen erstellt, die einige der gängigeren Konzepte, Techniken und Probleme abdeckt.

• Vererbung aus einer Basisklasse in Microsoft .NET
• Steuerelementerstellung für Windows Forms (Visual Studio .NET-Dokumentation)
• Entwickeln von Windows Forms-Steuerelementen (.NET Framework Dokumentation)
• Entwickeln überzeugender Benutzersteuerelemente, die auf Formulare im .NET Framework abzielen (MSDN Magazine, April 2002)
• .NET-Beispiele: Windows Forms: Steuerelementerstellung (aus den .NET-Schnellstarts)
• Debuggen Windows Forms Steuerelemente, die mit Visual Basic .NET oder Visual C# erstellt wurden

Zusätzlich zu den oben aufgeführten Ressourcen habe ich mehrere Beispiele geschrieben, um einige der gängigeren Konzepte der Steuerungsentwicklung zu veranschaulichen. Ich möchte Steuerelemente in eine kleine Gruppe von Kategorien klassifizieren, basierend auf der gewünschten Funktionalität:

1. Erweiterte Steuerelemente (nebensächig)
   Nehmen Sie kleine Änderungen am Verhalten eines vorhandenen Steuerelements vor, z. B. das gerade beschriebene NumericTextBox-Steuerelement und das TextBox für reguläre Ausdrücke , die im Abschnitt Beispiele beschrieben werden, und fügen Sie nur einige neue Eigenschaften, Methoden oder Ereignisse hinzu, falls vorhanden. Steuerelemente in dieser Kategorie erben normalerweise von einem vorhandenen Steuerelement (z . B. System.Windows.Forms.TextBox).
2. Erweiterte Steuerelemente (Haupt)
   Auf einem vorhandenen Steuerelement aufbauen, aber eine große Menge neuer Funktionen und in der Regel mehrere neue Eigenschaften, Methoden und/oder Ereignisse hinzufügen. Das datengebundene aktivierte ListBox-Element und die datengebundene Gruppierung TreeView (ausführliche Informationen im Abschnitt Beispiele) sind Beispiele für diese Steuerelementkategorie. Wie bei den erweiterten Steuerelementen erben Steuerelemente in dieser Kategorie normalerweise von einem vorhandenen Steuerelement (z . B. System.Windows.Forms.TreeView).
3. Zusammengesetzte Steuerelemente
   Ein Steuerelement, das mehrere andere Steuerelemente kombiniert, z. B. ein TextBox-Steuerelement mit einem zugeordneten Up/Down-Steuerelement , und das Hinzufügen eigener Eigenschaften, Methoden und Ereignisse umfasst. Das Optionsfeld für datengebundene Umfrage (im folgenden Abschnitt Beispiele beschrieben) ist ein Beispiel für diesen Steuerelementtyp. Steuerelemente in dieser Kategorie sollten von System.Windows.Forms.UserControl erben, und Sie sollten mit der UserControl-Vorlage in Visual Studio .NET beginnen, um schnell zu beginnen.
4. Vollständig benutzerdefiniert
   Steuerelemente, bei denen Sie gezwungen sind, von Grund auf neu zu beginnen, oder ein beliebiges Steuerelement, in dem Sie Ihre eigene Zeichnung behandeln. Das datengebundene Miniaturansichtssteuerelement (im folgenden Abschnitt Beispiele) ist nur ein Beispiel für diesen Typ von benutzerdefinierten Steuerelementen, aber eine Vielzahl von Steuerelementen könnte in diese Kategorie passen. Steuerelemente in dieser Kategorie erben einfach von System.Windows.Form.Control.
5. Extenderanbieter
   Diese Art von Steuerelement oder Komponente unterscheidet sich ziemlich von den anderen vier Kategorien, da sie durch Hinzufügen von Funktionen zu anderen Steuerelementen im gleichen Formular funktioniert. QuickInfo, ErrorProvider und HelpProvider sind Beispiele für diesen Steuerelementtyp. Der Prozess der Erstellung wird im ersten Beispielartikel behandelt.

Beispiele

Jedes dieser Beispiele soll bestimmte Aspekte der Steuerungsentwicklung veranschaulichen, einschließlich Vererbung, Datenbindung und Zeichnen eigener Grafiken. Die Beispiele sind alle in einem einzelnen Download enthalten, der über den Downloadlink am Anfang dieses Artikels verfügbar ist.

Der erste Beispielartikel , Hinzufügen der Validierung regulärer Ausdrücke, behandelt die Grundlagen des Erbens von einem anderen Steuerelement und des Hinzufügens eigener Eigenschaften, Methoden und Ereignisse sowie des Hinzufügens ihres eigenen Codes. In diesem Beispiel wird auch eine alternative Methode zum Hinzufügen derselben Funktionalität über ein Extenderanbietersteuerelement behandelt. Im zweiten Beispielartikel Kombinieren mehrerer Steuerelemente in einem wird ein Umfrage-Optionsfeld-Steuerelement verwendet, um zu veranschaulichen, wie ein benutzerdefiniertes Steuerelement erstellt wird, indem vorhandene Steuerelemente kombiniert werden. Außerdem wird beschrieben, wie die einfache Datenbindung mit den von Ihnen entwickelten Steuerelementen funktioniert.

Die restlichen Beispiele befassen sich mit der erweiterten Steuerungsentwicklung, einschließlich komplexer Datenbindung und Zeichnen einer eigenen Benutzeroberfläche mit GDI+. Der dritte Beispielartikel , Erweitern des TreeView-Steuerelements, führt Sie durch die Entwicklung eines relativ komplexen datengebundenen Steuerelements: einer TreeView, die eine Hierarchie von Elementen basierend auf einer Datenquelle anzeigen kann. Im abschließenden Beispielartikel Zeichnen eigener Steuerelemente mithilfe von GDI+ wird ein Steuerelement beschrieben, das die gesamte eigene Zeichnung verarbeitet: eine datengebundene Miniaturansicht. Zusätzlich zur steuerelementspezifischen Funktionalität veranschaulicht dieses letzte Beispiel auch grundlegende GDI+-Techniken, z. B. Zeichnen von Zeichenfolgen, Rechtecke und Bilder.

Zusammenfassung

Die Entwicklung benutzerdefinierter Steuerungen, sei es für den persönlichen Gebrauch, die Teamentwicklung oder den kommerziellen Vertrieb, ist eine der leistungsstärksten Formen der Komponententechnologie. Dieses Konzept, Darstellung und Funktionalität in einem verteilbaren Paket zusammenzupacken, war ein wichtiger Treiber für den Erfolg visueller Entwicklungstools wie Visual Basic und ist nach wie vor ein beliebtes Konzept in aktuellen Versionen dieser Tools. Die Steuerungsentwicklung wird in .NET stark verändert, aber sie ist eine Änderung zum Besseren, da Features wie die Vererbung den Prozess der Anpassung vorhandener Steuerelemente vereinfachen und gleichzeitig die Menge an Code reduzieren, die Sie schreiben müssen. Die oben beschriebenen Beispiele sollen Ihnen eine Einführung in das Erstellen benutzerdefinierter Steuerelemente geben, einige wichtige Steuerungsentwicklungstechniken veranschaulichen und Ihnen vielleicht sogar einige Ideen für Ihre eigenen Steuerelemente geben.