Exemplarische Vorgehensweise: Erstellen eines zusammengesetzten Steuerelements mit C#

Artikel
05/04/2023

Zusammengesetzte Steuerelemente bieten eine Möglichkeit, mit der benutzerdefinierte grafische Schnittstellen erstellt und wiederverwendet werden können. Ein zusammengesetztes Steuerelement ist im wesentlichen eine Komponente mit visueller Darstellung. Daher können zusammengesetzte Steuerelemente aus einem oder mehr Windows Forms-Steuerelementen, Komponenten oder Codeblöcken bestehen. Diese erweitern die Funktionalität durch Validieren von Benutzereingaben, verändern Anzeigeeigenschaften oder führen andere vom Autor gewünschte Aufgaben aus. Zusammengesetzte Steuerelemente können genau wie andere Steuerelemente in Windows Forms platziert werden. Im ersten Teil dieser exemplarischen Vorgehensweise erstellen Sie ein einfaches zusammengesetztes Steuerelement namens ctlClock. Im zweiten Teil der exemplarischen Vorgehensweise erweitern Sie die Funktionalität von ctlClock durch Vererbung.

Erstellen des Projekts

Geben Sie beim Erstellen des Projekts den Namen an, um den Stammnamespace, Assemblynamen und Projektnamen festzulegen und sicherzustellen, dass sich die Standardkomponente im richtigen Namespace befindet.

So erstellen Sie die ctlClockLib-Steuerelementbibliothek und das ctlClock-Steuerelement

Erstellen Sie in Visual Studio ein neues Projekt vom Typ Windows Forms-Steuerelementbibliothek, und nennen Sie es ctlClockLib.

Der Projektname ctlClockLib wird standardmäßig auch dem Stammnamespace zugewiesen. Der Stammnamespace wird verwendet, um die Namen der Komponenten in der Assembly zu qualifizieren. Wenn z.B. zwei Assemblys Komponenten mit dem Namen ctlClock bereitstellen, können Sie Ihre ctlClock-Komponente mithilfe von ctlClockLib.ctlClock. überprüfen.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf UserControl1.cs, und klicken Sie dann auf Umbenennen. Ändern Sie den Dateinamen in ctlClock.cs. Klicken Sie auf die Schaltfläche Ja, wenn Sie gefragt werden, ob alle Verweise auf das Codeelement „UserControl1“ umbenannt werden sollen.

Hinweis

Standardmäßig erbt ein zusammengesetztes Steuerelement von der Klasse UserControl, die vom System bereitgestellt wird. Die Klasse UserControl bietet Funktionalität, die von allen zusammengesetzten Steuerelementen benötigt wird, und implementiert Standardmethoden und -eigenschaften.
Klicken Sie im Menü Datei auf Alles speichern, um das Projekt zu speichern.

Hinzufügen von Windows-Steuerelementen und -Komponenten zum zusammengesetzten Steuerelement

Eine visuelle Schnittstelle ist ein wesentlicher Bestandteil von zusammengesetzten Steuerelementen. Diese visuelle Schnittstelle wird durch das Hinzufügen eines oder mehrerer Windows-Steuerelemente zur Designeroberfläche implementiert. Im folgenden Beispiel integrieren Sie Windows-Steuerelemente in das zusammengesetzte Steuerelement und schreiben Code, um Funktionalität zu implementieren.

So fügen Sie eine Bezeichnung und einen Timer zum zusammengesetzten Steuerelement hinzu

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf ctlClock.cs, und wählen Sie Designer anzeigen aus.
Erweitern Sie in der Toolbox den Knoten Allgemeine Steuerelemente, und doppelklicken Sie dann auf Bezeichnung.

Ein Label-Steuerelement mit dem Namen label1 wird zum Steuerelement auf der Oberfläche des Designers hinzugefügt.
Klicken Sie im Designer auf label1. Legen Sie im Eigenschaftenfenster die folgenden Eigenschaften fest.

Eigenschaft Ändern in

Name lblDisplay

Text (blank space)

Textausrichtung MiddleCenter

Font.Size 14
Erweitern Sie in der Toolbox den Knoten Komponenten, und doppelklicken Sie dann auf Timer.

Da es sich bei einem Timer um eine Komponente handelt, hat sie keine visuelle Darstellung zur Laufzeit. Er wird daher nicht bei den Steuerelementen auf der Designeroberfläche angezeigt, sondern im Komponenten-Designer (eine Taskleiste am unteren Ende der Designeroberfläche).
Klicken Sie im Komponenten-Designer auf timer1, und setzen Sie die Interval-Eigenschaft auf 1000 und die Enabled-Eigenschaft auf true.

Die Eigenschaft Interval steuert die Häufigkeit, mit der die Timer-Komponente tickt. Bei jedem Tick von timer1 führt sie den Code im Ereignis timer1_Tick aus. Das Intervall stellt die Anzahl von Millisekunden zwischen Ticks dar.
Doppelklicken Sie im Komponenten-Designer auf timer1, um zum timer1_Tick-Ereignis für ctlClock zu gelangen.
Ändern Sie den Code so, dass er folgendem Codebeispiel ähnelt. Achten Sie darauf, den Zugriffsmodifizierer von private in protected zu ändern.
```
protected void timer1_Tick(object sender, System.EventArgs e)
{
    // Causes the label to display the current time.
    lblDisplay.Text = DateTime.Now.ToLongTimeString();
}
```
Durch diesen Code wird die aktuelle Zeit in lblDisplay angezeigt. Da das Intervall von timer1 auf 1000 festgelegt wurde, wird dieses Ereignis alle tausend Millisekunden ausgelöst. Dadurch wird die aktuelle Zeit jede Sekunde aktualisiert.
Ändern Sie die Methode so, dass sie mit dem Schlüsselwort virtual überschreibbar ist. Weitere Informationen finden Sie im Abschnitt „Erben von Benutzersteuerelementen“.
```
protected virtual void timer1_Tick(object sender, System.EventArgs e)
```
Klicken Sie im Menü Datei auf Alles speichern, um das Projekt zu speichern.

Eigenschaft	Ändern in
Name	`lblDisplay`
Text	`(blank space)`
Textausrichtung	`MiddleCenter`
Font.Size	`14`

Hinzufügen von Eigenschaften zum zusammengesetzten Steuerelement

Ihr Taktsteuerelement kapselt nun ein Label-Steuerelement und eine Timer-Komponente ein, die jeweils über einen eigenen Satz inhärenter Eigenschaften verfügen. Während nachfolgende Benutzer des Steuerelements nicht auf die einzelnen Eigenschaften dieser Steuerelemente zugreifen können, können Sie benutzerdefinierte Eigenschaften durch Schreiben der geeigneten Codeblöcke erstellen und verfügbar machen. Im folgenden Vorgang fügen Sie Eigenschaften zum Steuerelement hinzu, die dem Benutzer ermöglichen, die Farbe des Hintergrunds und des Texts zu ändern.

So fügen Sie eine Eigenschaft zum zusammengesetzten Steuerelement hinzu

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf ctlClock.cs, und klicken Sie dann auf Code anzeigen.

Der Code-Editor für das Steuerelement wird geöffnet.
Suchen Sie die Anweisung public partial class ctlClock. Geben Sie unter der öffnenden Klammer ({) den folgenden Code ein.
```
private Color colFColor;
private Color colBColor;
```
Diese Anweisungen erstellen die privaten Variablen, die Sie verwenden, um die Werte für die Eigenschaften zu speichern, die Sie gleich erstellen werden.

Geben Sie den folgenden Code unter den variablen Deklarationen aus Schritt 2 ein oder verwenden Sie Kopieren und Einfügen.

// Declares the name and type of the property.
public Color ClockBackColor
{
    // Retrieves the value of the private variable colBColor.
    get
    {
        return colBColor;
    }
    // Stores the selected value in the private variable colBColor, and
    // updates the background color of the label control lblDisplay.
    set
    {
        colBColor = value;
        lblDisplay.BackColor = colBColor;
    }
}
// Provides a similar set of instructions for the foreground color.
public Color ClockForeColor
{
    get
    {
        return colFColor;
    }
    set
    {
        colFColor = value;
        lblDisplay.ForeColor = colFColor;
    }
}

Dieser Code stellt nachfolgenden Benutzern dieses Steuerelements zwei benutzerdefinierte Eigenschaften zur Verfügung, ClockForeColor und ClockBackColor. Die Anweisungen get und set ermöglichen das Speichern und Abrufen des Eigenschaftswerts sowie des Codes zum Implementieren der geeigneten Funktionalität der Eigenschaft.

Klicken Sie im Menü Datei auf Alles speichern, um das Projekt zu speichern.

Testen des Steuerelements

Steuerelemente sind keine eigenständigen Anwendungen. Sie müssen in einem Container gehostet werden. Testen Sie das Laufzeitverhalten Ihres Steuerelements, und überprüfen Sie die Eigenschaften im UserControl-Testcontainer. Weitere Informationen finden Sie unter Vorgehensweise: Testen des Laufzeitverhaltens eines UserControl.

So testen Sie das Steuerelement

Drücken Sie F5, um das Projekt zu erstellen, und führen Sie das Steuerelement im UserControl-Testcontainer aus.
Suchen Sie im Eigenschaftenraster des Testcontainers die Eigenschaft ClockBackColor, und wählen Sie anschließend die Eigenschaft aus, um die Farbpalette anzuzeigen.
Wählen Sie eine Farbe aus, indem sie darauf klicken.

Die Hintergrundfarbe des Steuerelements ändert sich in die ausgewählte Farbe.
Verwenden Sie eine ähnliche Abfolge von Ereignissen, um zu überprüfen, ob die Eigenschaft ClockForeColor funktioniert wie erwartet.

In diesem Abschnitt und in den vorherigen Abschnitten haben Sie gesehen, wie Komponenten und Windows-Steuerelemente mit Code und Paketen kombiniert werden können, um benutzerdefinierte Funktionalität in Form eines zusammengesetzten Steuerelements zu bieten. Sie haben gelernt, Eigenschaften in Ihrem zusammengesetzten Steuerelement verfügbar zu machen, und das Steuerelement nach Abschluss zu überprüfen. Im nächsten Abschnitt erfahren Sie, wie man ein vererbtes zusammengesetztes Steuerelement mithilfe von ctlClock als Basis verwendet.

Erben von einem zusammengesetzten Steuerelement

In den vorherigen Abschnitten haben Sie gelernt, wie man Windows-Steuerelemente, Komponenten und Code in wiederverwendbare zusammengesetzte Steuerelemente kombiniert. Das zusammengesetzte Steuerelement kann jetzt als Basis für die Erstellung anderer Steuerelemente verwendet werden. Der Vorgang, bei dem eine Klasse von einer Basisklasse abgeleitet wird, nennt man Vererbung. In diesem Abschnitt erstellen Sie ein zusammengesetztes Steuerelement namens ctlAlarmClock. Dieses Steuerelement wird von seinem übergeordneten Steuerelement, ctlClock, abgeleitet. Sie erfahren, wie Sie die Funktionalität von ctlClock durch Überschreiben der übergeordneten Methoden und Hinzufügen neuer Methoden und Eigenschaften erweitern können.

Der erste Schritt beim Erstellen eines geerbten Steuerelements ist das Ableiten vom übergeordneten Steuerelement. Diese Aktion erstellt ein neues Steuerelement, das über alle Eigenschaften, Methoden und grafischen Merkmale des übergeordneten Steuerelements verfügt, aber auch als Basis für das Hinzufügen neuer oder veränderter Funktionalität dienen kann.

So erstellen Sie das geerbte Steuerelement

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf ctlClockLib, zeigen Sie auf Hinzufügen, und klicken Sie anschließend auf Benutzersteuerelement.

Das Dialogfeld Neues Element hinzufügen wird angezeigt.
Wählen Sie die Vorlage Geerbtes Benutzersteuerelement.
Geben Sie im Feld Name die Bezeichnung ctlAlarmClock.cs ein, und klicken Sie dann auf Hinzufügen.

Das Dialogfeld Vererbungsauswahl wird angezeigt.
Doppelklicken Sie unter Komponentenname auf ctlClock.
Durchsuchen Sie die aktuellen Projekte im Projektmappen-Explorer.

Hinweis

Eine Datei namens ctlAlarmClock.cs wurde zum aktuellen Projekt hinzugefügt.

Hinzufügen von Wecker-Eigenschaften

Eigenschaften werden auf die gleiche Weise zu einem geerbten Steuerelement hinzugefügt wie zu einem zusammengesetzten Steuerelement. Sie verwenden jetzt die Syntax zum Deklarieren von Eigenschaften, um zwei Eigenschaften zu Ihrem Steuerelement hinzuzufügen: AlarmTime, wodurch der Wert des Datums und der Uhrzeit gespeichert wird, zu der der Wecker klingelt, und AlarmSet, die anzeigt, ob der Wecker eingestellt wurde.

So fügen Sie Eigenschaften zum zusammengesetzten Steuerelement hinzu

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf ctlAlarmClock, und klicken Sie dann auf Code anzeigen.

Suchen Sie die Anweisung public class. Beachten Sie, dass das Steuerelement von ctlClockLib.ctlClock erbt. Geben Sie unter der öffnenden Klammer ({)-Anweisung den folgenden Code ein.

private DateTime dteAlarmTime;
private bool blnAlarmSet;
// These properties will be declared as public to allow future
// developers to access them.
public DateTime AlarmTime
{
    get
    {
        return dteAlarmTime;
    }
    set
    {
        dteAlarmTime = value;
    }
}
public bool AlarmSet
{
    get
    {
        return blnAlarmSet;
    }
    set
    {
        blnAlarmSet = value;
    }
}

Hinzufügen zur grafischen Oberfläche des Steuerelements

Das geerbte Steuerelement verfügt über eine visuelle Schnittstelle, die mit dem Steuerelement identisch ist, von dem es erbt. Es verfügt über die gleichen konstituierenden Steuerelemente wie das übergeordnete Steuerelement. Allerdings sind die Eigenschaften der konstituierenden Steuerelemente nicht verfügbar, solange sie nicht explizit verfügbar gemacht werden. Sie können zur grafischen Schnittstelle des geerbten zusammengesetzten Steuerelements auf die gleiche Weise hinzufügen, wie Sie zu jedem anderen zusammengesetzten Steuerelement hinzufügen würden. Um den Vorgang fortzusetzen, zur visuellen Schnittstelle Ihres Weckers hinzuzufügen, fügen Sie ein Label-Steuerelement hinzu, das leuchtet, wenn der Wecker klingelt.

So fügen Sie das Label-Steuerelement hinzu

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf ctlAlarmClock, und klicken Sie dann auf Designer anzeigen.

Der Designer für ctlAlarmClock wird im Hauptfenster geöffnet.
Klicken Sie auf den Anzeigebereich des Steuerelements, und zeigen Sie das Eigenschaftenfenster an.

Hinweis

Alle Eigenschaften werden angezeigt, sind aber abgeblendet. Das bedeutet, dass die Eigenschaften nativ zu lblDisplay sind, und dass sie nicht im Eigenschaftenfenster geändert oder auf sie zugegriffen werden können. Standardmäßig sind in einem zusammengesetzten Steuerelement enthaltene Steuerelemente private, und es ist nicht möglich, auf ihre Eigenschaften zuzugreifen.

Hinweis

Wenn Sie möchten, dass nachfolgende Benutzer des zusammengesetzten Steuerelements Zugriff auf interne Steuerelemente haben, deklarieren Sie sie als public oder protected. Dadurch können Sie Eigenschaften von Steuerelementen, die in Ihrem zusammengesetzten Steuerelement enthalten sind, festlegen und ändern, indem Sie den entsprechenden Code verwenden.
Fügen Sie Ihrem zusammengesetzten Steuerelement ein Label-Steuerelement hinzu.
Ziehen Sie mit der Maus das Label-Steuerelement direkt unter das Anzeigefeld. Legen Sie im Eigenschaftenfenster die folgenden Eigenschaften fest.

Eigenschaft Einstellung

Name lblAlarm

Text Alarm!

Textausrichtung MiddleCenter

Visible false

Eigenschaft	Einstellung
Name	`lblAlarm`
Text	Alarm!
Textausrichtung	`MiddleCenter`
Visible	`false`

Hinzufügen der Wecker-Funktionalität

In den vorherigen Schritten haben Sie Eigenschaften und ein Steuerelement hinzugefügt, dass die Wecker-Funktionalität in Ihrem zusammengesetzten Steuerelement aktiviert. In diesem Verfahren fügen Sie Code hinzu, um die aktuelle Zeit mit der Weckzeit zu vergleichen, und bei Gleichheit einen Wecker auszulösen. Durch Überschreiben der Methode timer1_Tick von ctlClock und Hinzufügen von zusätzlichem Code erweitern Sie die Funktion von ctlAlarmClock während alle geerbten Funktionen von ctlClock erhalten bleiben.

So überschreiben Sie die Methode „Timer1_Tick“ von „ctlClock“

Suchen Sie im Code-Editor eine private bool blnAlarmSet;-Anweisung hinzu. Fügen Sie direkt darunter die folgende Anweisung hinzu.
```
private bool blnColorTicker;
```

Suchen Sie im Code-Editor die schließende Klammer (}) am Ende der Klasse. Fügen Sie direkt vor der Klammer den folgenden Code hinzu.

protected override void timer1_Tick(object sender, System.EventArgs e)
{
    // Calls the Timer1_Tick method of ctlClock.
    base.timer1_Tick(sender, e);
    // Checks to see if the alarm is set.
    if (AlarmSet == false)
        return;
    else
        // If the date, hour, and minute of the alarm time are the same as
        // the current time, flash an alarm.
    {
        if (AlarmTime.Date == DateTime.Now.Date && AlarmTime.Hour ==
            DateTime.Now.Hour && AlarmTime.Minute == DateTime.Now.Minute)
        {
            // Sets lblAlarmVisible to true, and changes the background color based on
            // the value of blnColorTicker. The background color of the label
            // will flash once per tick of the clock.
            lblAlarm.Visible = true;
            if (blnColorTicker == false)
            {
                lblAlarm.BackColor = Color.Red;
                blnColorTicker = true;
            }
            else
            {
                lblAlarm.BackColor = Color.Blue;
                blnColorTicker = false;
            }
        }
        else
        {
            // Once the alarm has sounded for a minute, the label is made
            // invisible again.
            lblAlarm.Visible = false;
        }
    }
}

Das Hinzufügen dieses Codes dient mehreren Zwecken. Die Anweisung override weist das Steuerelement an, diese Methode statt der Methode zu verwenden, die vom Basissteuerelement geerbt wurde. Wenn diese Methode aufgerufen wird, ruft sie durch Aufruf der base.timer1_Tick-Anweisung die überschriebene Methode auf. Damit wird sichergestellt, dass die gesamte Funktionalität, die im ursprünglichen Steuerelement enthalten ist, in diesem Steuerelement reproduziert wird. Anschließend ruft sie zusätzlichen Code auf, um die Wecker-Funktionalität zu integrieren. Ein blinkendes Label-Steuerelement erscheint, wenn der Wecker ausgelöst wird.

Das Wecker-Steuerelement ist fast abgeschlossen. Sie müssen nur noch eine Möglichkeit zum Deaktivieren implementieren. Zu diesem Zweck fügen Sie Code zur Methode lblAlarm_Click hinzu.

So implementieren Sie die Methode zum Deaktivieren

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf ctlAlarmClock.cs, und klicken Sie dann auf Designer anzeigen.

Der Designer wird geöffnet.
Fügen Sie eine Schaltfläche zum Steuerelement hinzu. Legen Sie die Eigenschaften der Schaltfläche wie folgt fest.

Eigenschaft Wert

Name btnAlarmOff

Text Wecker deaktivieren
Doppelklicken Sie im Designer auf btnAlarmOff.

Der Code-Editor wird in der Zeile private void btnAlarmOff_Click geöffnet.

Eigenschaft	Wert
Name	`btnAlarmOff`
Text	Wecker deaktivieren

Ändern Sie die Methode so, dass sie folgendem Code ähnelt.

private void btnAlarmOff_Click(object sender, System.EventArgs e)
{
    // Turns off the alarm.
    AlarmSet = false;
    // Hides the flashing label.
    lblAlarm.Visible = false;
}

Klicken Sie im Menü Datei auf Alles speichern, um das Projekt zu speichern.

Verwenden des geerbten Steuerelements in einem Formular

Sie können Ihr geerbtes Steuerelement so testen, wie Sie das Steuerelement der Basisklasse, ctlClock, getestet haben: Drücken Sie F5, um das Projekt zu erstellen, und führen Sie das Steuerelement im UserControl Testcontainer aus. Weitere Informationen finden Sie unter Vorgehensweise: Testen des Laufzeitverhaltens eines UserControl.

Sie müssen das Steuerelement auf einem Formular hosten, um es verwenden zu können. Wie standardmäßige zusammengesetzten Steuerelemente kann ein geerbtes zusammengesetztes Steuerelement nicht alleine stehen und muss in einem Formular oder einem anderen Container gehostet werden. Da ctlAlarmClock über eine tiefer gehende Funktionalität verfügt, wird zusätzlicher Code für das Testen benötigt. In dieser Vorgehensweise schreiben Sie ein einfaches Programm, um die Funktionalität von ctlAlarmClock zu testen. Sie schreiben Code zum Einstellen und Anzeigen der Eigenschaft AlarmTime von ctlAlarmClock und testen die geerbten Funktionen.

So erstellen Sie ein Steuerelement und fügen es zu einem Testformular hinzu

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf ctlClockLib, und klicken Sie dann auf Erstellen.
Fügen Sie der Projektmappe ein neues Windows Forms-Anwendungsprojekt mit dem Namen Test hinzu.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Knoten Verweise für das neue Testprojekt. Klicken Sie auf Verweis hinzufügen, um das Dialogfeld Verweis hinzufügen anzuzeigen. Klicken Sie auf die Registerkarte mit der Bezeichnung Projekte. Ihr ctlClockLib-Projekt wird unter Projektname aufgelistet. Doppelklicken Sie auf das Projekt, um den Verweis auf das Testprojekt hinzuzufügen.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Test, und klicken Sie dann auf Erstellen.
Erweitern Sie in der Toolbox den Knoten ctlClockLib Components.
Doppelklicken Sie auf ctlAlarmClock, um eine Kopie von ctlAlarmClock zu Ihrem Formular hinzuzufügen.
Suchen Sie in der Toolbox nach DateTimePicker, und doppelklicken Sie darauf, um ein DateTimePicker-Steuerelement zu Ihrem Formular hinzuzufügen. Fügen Sie anschließend ein Label-Steuerelement hinzu, indem Sie auf Label doppelklicken.
Verwenden Sie die Maus, um das Steuerelement an einem geeigneten Ort auf dem Formular zu positionieren.
Legen Sie die Eigenschaften dieser Steuerelemente wie folgt fest.

Control Eigenschaft Value

label1 Text (blank space)

Name lblTest

dateTimePicker1 Name dtpTest

Format Time
Doppelklicken Sie im Designer auf dtpTest.

Der Code-Editor für private void dtpTest_ValueChanged wird geöffnet.

Control	Eigenschaft	Value
`label1`	Text	`(blank space)`
	Name	`lblTest`
`dateTimePicker1`	Name	`dtpTest`
	Format	Time

Ändern Sie den Code so, dass er folgendem Beispiel ähnelt.

private void dtpTest_ValueChanged(object sender, System.EventArgs e)
{
    ctlAlarmClock1.AlarmTime = dtpTest.Value;
    ctlAlarmClock1.AlarmSet = true;
    lblTest.Text = "Alarm Time is " +
        ctlAlarmClock1.AlarmTime.ToShortTimeString();
}

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Test, und klicken Sie dann auf Als Startprojekt festlegen.
Klicken Sie im Menü Debuggen auf Debuggen starten.

Das Testprogramm wird gestartet. Beachten Sie, dass die aktuelle Zeit im ctlAlarmClock-Steuerelement aktualisiert wird und dass die Startzeit im DateTimePicker-Steuerelement angezeigt wird.
Klicken Sie auf den DateTimePicker, wo die Minuten der Stunde angezeigt werden.
Legen Sie mithilfe der Tastatur einen Wert für die Minuten fest, der eine Minute höher ist als die aktuell von ctlAlarmClock angezeigte Zeit.

Die Zeit für die Einstellung des Weckers wird in lblTest angezeigt. Warten Sie, bis die angezeigte Zeit die für den Wecker eingestellte Zeit erreicht hat. Wenn die angezeigte Zeit die Zeit erreicht, auf die der Wecker eingestellt ist, leuchtet lblAlarm.
Deaktivieren Sie den Wecker, indem Sie auf btnAlarmOff klicken. Sie können den Wecker nun zurücksetzen.

In diesem Artikel wurden zahlreiche wichtige Konzepte behandelt. Sie haben gelernt, ein zusammengesetztes Steuerelement zu erstellen, indem Sie Steuerelemente und Komponenten in einem Container für zusammengesetzte Steuerelemente kombiniert haben. Sie haben gelernt, Eigenschaften zu Ihrem Steuerelement hinzuzufügen und Code für das Implementieren benutzerdefinierter Funktionalität zu schreiben. Im letzten Abschnitt haben Sie gelernt, die Funktionalität eines bestimmten zusammengesetzten Steuerelements durch Vererbung zu erweitern und die Funktionalität von Host-Methoden durch außer Kraft setzen dieser Methoden zu ändern.