Exemplarische Vorgehensweise: Erstellen eines zusammengesetzten Steuerelements mit C#

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 einer visuellen Darstellung. Daher kann sie aus einem oder mehreren Windows Forms-Steuerelementen, Komponenten oder Codeblöcken bestehen, die Funktionen erweitern können, indem Benutzereingaben überprüft, Anzeigeeigenschaften geändert oder andere aufgaben ausgeführt werden, die vom Autor benötigt werden. Zusammengesetzte Steuerelemente können in Windows Forms auf die gleiche Weise wie andere Steuerelemente 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

Wenn Sie ein neues Projekt erstellen, geben Sie dessen Namen an, um den Stammnamespace, den Assemblynamen und den Projektnamen festzulegen, und stellen Sie sicher, 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 Windows Forms Control Library-Projekt , und nennen Sie es "ctlClockLib".

Der Projektname , ctlClockLibwird standardmäßig auch dem Stammnamespace zugewiesen. Der Stammnamespace wird verwendet, um die Namen von 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. angeben.
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 Sie alle Verweise auf das Codeelement "UserControl1" umbenennen möchten.

Hinweis

Standardmäßig erbt ein zusammengesetztes Steuerelement von der UserControl vom System bereitgestellten Klasse. Die UserControl Klasse stellt Funktionen bereit, die von allen zusammengesetzten Steuerelementen benötigt werden, und implementiert Standardmethoden und Eigenschaften.
Klicken Sie im Menü "Datei " auf " Alle speichern", um das Projekt zu speichern.

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

Eine visuelle Schnittstelle ist ein wesentlicher Bestandteil Ihres zusammengesetzten Steuerelements. Diese visuelle Schnittstelle wird durch das Hinzufügen eines oder mehrerer Windows-Steuerelemente zur Designeroberfläche implementiert. In der folgenden Demonstration integrieren Sie Windows-Steuerelemente in Ihr zusammengesetztes Steuerelement und schreiben Code zum Implementieren von Funktionen.

So fügen Sie Ihrem zusammengesetzten Steuerelement eine Beschriftung und einen Timer hinzu

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

Ein Label-Steuerelement namens label1 wird Ihrem Steuerelement auf der Designeroberfläche hinzugefügt.
Klicken Sie im Designer auf "label1". Legen Sie im Eigenschaftenfenster die folgenden Eigenschaften fest.

Eigentum Ändern in

Name lblDisplay

Text (blank space)

TextAlign MiddleCenter

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

Da es sich bei einer Timer Komponente um eine Komponente handelt, gibt es zur Laufzeit keine visuelle Darstellung. Daher wird es nicht mit den Steuerelementen auf der Designeroberfläche angezeigt, sondern im Komponenten-Designer (eine Taskleiste am unteren Rand der Designeroberfläche).
Klicken Sie im Komponenten-Designer auf Timer1, und legen Sie dann die Interval Eigenschaft auf 1000 und die Enabled Eigenschaft auf true.

Die Interval Eigenschaft steuert die Häufigkeit, mit der die Timer Komponente tickt. Jedes Mal, wenn timer1 tickt, wird der Code im timer1_Tick Ereignis ausgeführt. Das Intervall stellt die Anzahl der Millisekunden zwischen Impulsen dar.
Doppelklicken Sie im Komponenten-Designer auf timer1, um zum timer1_Tick-Ereignis für ctlClock zu wechseln.
Ändern Sie den Code so, dass er dem folgenden Codebeispiel ähnelt. Stellen Sie sicher, dass Sie den Zugriffsmodifizierer von private "in" protectedändern.
```
protected void timer1_Tick(object sender, System.EventArgs e)
{
    // Causes the label to display the current time.
    lblDisplay.Text = DateTime.Now.ToLongTimeString();
}
```
Dieser Code bewirkt, dass die aktuelle Uhrzeit in lblDisplay angezeigt wird. Da das Intervall timer1 auf 1000 festgelegt wurde, tritt dieses Ereignis alle tausend Millisekunden auf, wodurch die aktuelle Uhrzeit jedes Sekunde aktualisiert wird.
Ändern Sie die Methode so, dass sie mit dem virtual Schlüsselwort überschreibbar ist. Weitere Informationen finden Sie unten im Abschnitt "Erben von einem Benutzersteuerelement".
```
protected virtual void timer1_Tick(object sender, System.EventArgs e)
```
Klicken Sie im Menü "Datei " auf " Alle speichern", um das Projekt zu speichern.

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

Hinzufügen von Eigenschaften zum Zusammengesetzten Steuerelement

Ihr Uhr-Steuerelement kapselt jetzt ein Label Steuerelement und eine Timer Komponente, die jeweils einen eigenen Satz von inhärenten Eigenschaften enthält. Während auf die einzelnen Eigenschaften dieser Steuerelemente für nachfolgende Benutzer Ihres Steuerelements nicht zugegriffen werden kann, können Sie benutzerdefinierte Eigenschaften erstellen und verfügbar machen, indem Sie die entsprechenden Codeblöcke schreiben. Im folgenden Verfahren fügen Sie Ihrem Steuerelement Eigenschaften hinzu, mit denen der Benutzer die Farbe des Hintergrunds und des Texts ändern kann.

So fügen Sie dem zusammengesetzten Steuerelement eine Eigenschaft 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 Ihr Steuerelement wird geöffnet.
Suchen Sie die public partial class ctlClock Anweisung. Geben Sie unter der öffnenden Klammer ({)) den folgenden Code ein.
```
private Color colFColor;
private Color colBColor;
```
Diese Anweisungen erstellen die privaten Variablen, die Sie zum Speichern der Werte für die Eigenschaften verwenden, die Sie erstellen möchten.

Geben Sie den folgenden Code unter den Variablendeklarationen aus Schritt 2 ein, oder fügen Sie ihn ein.

// 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;
    }
}

Der vorangehende Code stellt zwei benutzerdefinierte Eigenschaften ClockForeColor und ClockBackColorfür nachfolgende Benutzer dieses Steuerelements zur Verfügung. Die Anweisungen get und set bieten die Speicherung und den Abruf des Eigenschaftswerts sowie Code zur Implementierung von Funktionen, die der Eigenschaft entsprechen.

Klicken Sie im Menü "Datei " auf " Alle 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 üben Sie dessen Eigenschaften mit dem UserControl Test-Container aus. Weitere Informationen finden Sie unter Testen des Laufzeitverhaltens eines UserControl.

Um Ihre Kontrolle zu testen

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 ClockBackColor Eigenschaft, und wählen Sie dann 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 von Ihnen ausgewählte Farbe.
Verwenden Sie eine ähnliche Abfolge von Ereignissen, um zu überprüfen, ob die ClockForeColor Eigenschaft wie erwartet funktioniert.

In diesem Abschnitt und den vorherigen Abschnitten haben Sie gesehen, wie Komponenten und Windows-Steuerelemente mit Code und Verpackung kombiniert werden können, um benutzerdefinierte Funktionen in Form eines zusammengesetzten Steuerelements bereitzustellen. Sie haben gelernt, Eigenschaften in Ihrem zusammengesetzten Steuerelement freizugeben und wie Sie das Steuerelement testen, nachdem es abgeschlossen ist. Im nächsten Abschnitt erfahren Sie, wie Sie ein geerbtes zusammengesetztes Steuerelement mithilfe ctlClock einer Basis erstellen.

Erben von einem zusammengesetzten Steuerelement

In den vorherigen Abschnitten haben Sie erfahren, wie Sie Windows-Steuerelemente, -Komponenten und -Code in wiederverwendbare zusammengesetzte Steuerelemente kombinieren. Ihr zusammengesetztes Steuerelement kann jetzt als Basis verwendet werden, auf der andere Steuerelemente erstellt werden können. Der Prozess der Ableitung einer Klasse von einer Basisklasse wird als Vererbung bezeichnet. In diesem Abschnitt erstellen Sie ein zusammengesetztes Steuerelement namens ctlAlarmClock. Dieses Steuerelement wird von seinem übergeordneten Steuerelement ctlClock abgeleitet. Sie lernen, die Funktionalität ctlClock zu erweitern, indem Sie übergeordnete Methoden überschreiben und neue Methoden und Eigenschaften hinzufügen.

Der erste Schritt beim Erstellen eines abgeleiteten Steuerelements besteht darin, es von seinem übergeordneten Element abzuleiten. Diese Aktion erstellt ein neues Steuerelement mit allen Eigenschaften, Methoden und grafischen Merkmalen des übergeordneten Steuerelements, kann aber auch als Basis für das Hinzufügen neuer oder geänderter Funktionen fungieren.

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 dann auf Benutzersteuerelement.

Das Dialogfeld Neues Element hinzufügen wird geöffnet.
Wählen Sie die Vorlage "Geerbtes Benutzersteuerelement " aus.
Geben Sie im ctlAlarmClock.cs" den Namen ein, und klicken Sie dann auf "Hinzufügen".

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

Hinweis

Dem aktuellen Projekt wurde eine Datei namens ctlAlarmClock.cs hinzugefügt.

Hinzufügen der Alarmeigenschaften

Eigenschaften werden einem geerbten Steuerelement auf die gleiche Weise hinzugefügt, wie sie einem zusammengesetzten Steuerelement hinzugefügt werden. Sie verwenden nun die Eigenschaftsdeklarationssyntax, um Ihrem Steuerelement zwei Eigenschaften hinzuzufügen: AlarmTime, wodurch der Wert des Datums und der Uhrzeit gespeichert wird, an dem der Alarm ausgelöst wird, und AlarmSet, der angibt, ob der Alarm gestellt ist.

So fügen Sie dem zusammengesetzten Steuerelement Eigenschaften hinzu

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

Suchen Sie die public class Anweisung. Beachten Sie, dass Ihr Steuerelement von ctlClockLib.ctlClock erbt. Geben Sie unter der öffnenden geschweiften Klammer ({)) 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;
    }
}

Zur grafischen Benutzeroberfläche des Steuerelements hinzufügen

Ihr geerbtes Steuerelement verfügt über eine visuelle Schnittstelle, die mit dem Steuerelement identisch ist, von dem es erbt. Es verfügt über dieselben Bestandteilsteuerelemente wie das übergeordnete Steuerelement, aber die Eigenschaften der Bestandteilsteuerelemente sind nur zugänglich, wenn sie speziell offengelegt wurden. Sie können der grafischen Benutzeroberfläche eines geerbten zusammengesetzten Steuerelements genauso hinzufügen, wie Sie es bei jedem zusammengesetzten Steuerelement tun würden. Wenn Sie weiterhin zur visuellen Oberfläche Ihres Weckers hinzufügen möchten, fügen Sie ein Bezeichnungssteuerelement hinzu, das blinkt, wenn der Alarm ertönt.

So fügen Sie das Beschriftungsfeld hinzu

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

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

Hinweis

Solange alle Eigenschaften angezeigt werden, erscheinen sie gedimmt. Dies gibt an, dass diese Eigenschaften nativ lblDisplay sind und im Eigenschaftenfenster nicht geändert oder darauf zugegriffen werden kann. Standardmäßig sind Steuerelemente, die in einem zusammengesetzten Steuerelement enthalten sind private, und ihre Eigenschaften sind auf keine Weise zugänglich.

Hinweis

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

Eigentum Konfiguration

Name lblAlarm

Text Alarm!

TextAlign MiddleCenter

Sichtbaren false

Eigentum	Konfiguration
Name	`lblAlarm`
Text	Alarm!
TextAlign	`MiddleCenter`
Sichtbaren	`false`

Hinzufügen der Alarmfunktion

In den vorherigen Verfahren haben Sie Eigenschaften und ein Steuerelement hinzugefügt, das Alarmfunktionen in Ihrem zusammengesetzten Steuerelement ermöglicht. In diesem Verfahren fügen Sie Code hinzu, um die aktuelle Uhrzeit mit der Alarmzeit zu vergleichen und, wenn sie identisch sind, um einen Alarm zu blinken. Indem Sie die timer1_Tick-Methode von ctlClock überschreiben und zusätzlichen Code hinzufügen, erweitern Sie die Fähigkeiten von ctlAlarmClock, während Sie die gesamte innere Funktionalität von ctlClock beibehalten.

So überschreiben Sie die Timer1_Tick-Methode von ctlClock

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

Suchen Sie im Code-Editor die schließende geschweifte Klammer (}) am Ende der Klasse). Fügen Sie direkt vor der geschweiften 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 erledigt mehrere Aufgaben. Die override Anweisung leitet das Steuerelement an, diese Methode anstelle der Methode zu verwenden, die vom Basissteuerelement geerbt wurde. Wenn diese Methode aufgerufen wird, ruft sie die Methode auf, die sie überschreibt, indem sie die base.timer1_Tick Anweisung aufruft, um sicherzustellen, dass alle funktionen, die in das ursprüngliche Steuerelement integriert sind, in diesem Steuerelement reproduziert werden. Anschließend wird zusätzlicher Code ausgeführt, um die Alarmfunktion zu integrieren. Ein blinkendes Label-Steuerelement wird erscheinen, wenn der Alarm ausgelöst wird.

Ihre Weckersteuerung ist fast vollständig. Das einzige, was bleibt, besteht darin, eine Möglichkeit zum Deaktivieren zu implementieren. Dazu fügen Sie der lblAlarm_Click Methode Code hinzu.

So implementieren Sie die Abschaltmethode

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

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

Eigentum Wert

Name btnAlarmOff

Text Alarm deaktivieren
Doppelklicken Sie im Designer auf btnAlarmOff.

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

Eigentum	Wert
Name	`btnAlarmOff`
Text	Alarm deaktivieren

Ändern Sie diese Methode so, dass sie dem folgenden 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 " Alle speichern", um das Projekt zu speichern.

Verwenden des geerbten Steuerelements in einem Formular

Sie können das geerbte Steuerelement auf die gleiche Weise testen, wie Sie das Basisklassensteuerelement getestet haben: Drücken Sie ctlClock, um das Projekt zu erstellen und das Steuerelement im UserControl Test-Container auszuführen. Weitere Informationen finden Sie unter Testen des Laufzeitverhaltens eines UserControl.

Damit Ihr Steuerelement verwendet werden kann, müssen Sie es auf einem Formular hosten. Wie bei einem standardmäßigen zusammengesetzten Steuerelement kann ein geerbtes zusammengesetztes Steuerelement nicht eigenständig sein und muss in einem Formular oder einem anderen Container gehostet werden. Da ctlAlarmClock mehr Funktionalität bietet, ist zusätzlicher Code erforderlich, um es zu testen. In diesem Verfahren schreiben Sie ein einfaches Programm zum Testen der Funktionalität von ctlAlarmClock. Sie schreiben Code zum Festlegen und Anzeigen der AlarmTime Eigenschaft von ctlAlarmClock, und testen ihre inhärenten Funktionen.

So erstellen und hinzufügen Sie Ihr Steuerelement zu einem Testformular

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 hinzu, und nennen Sie es "Test".
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Knoten "Verweise " für Ihr Testprojekt. Klicken Sie auf "Verweis hinzufügen ", um das Dialogfeld " Verweis hinzufügen " anzuzeigen. Klicken Sie auf die Registerkarte " Projekte". Ihr ctlClockLib Projekt wird unter "Projektname" aufgeführt. Doppelklicken Sie auf das Projekt, um den Verweis auf das Testprojekt hinzuzufügen.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf "Testen", und klicken Sie dann auf "Erstellen".
Erweitern Sie in der Toolbox den Knoten „ctlClockLib-Komponenten“.
Doppelklicken Sie auf ctlAlarmClock, um Ihrem Formular eine Kopie ctlAlarmClock hinzuzufügen.
Suchen und doppelklicken Sie in der Toolbox auf DateTimePicker, um Ihrem Formular ein DateTimePicker Steuerelement hinzuzufügen. Fügen Sie dann ein Label Steuerelement hinzu, indem Sie auf Label doppelklicken.
Verwenden Sie die Maus, um die Steuerelemente an einer praktischen Stelle im Formular zu positionieren.
Legen Sie die Eigenschaften dieser Steuerelemente wie folgt fest.

Steuerung Eigentum Wert

label1 Text (blank space)

Name lblTest

dateTimePicker1 Name dtpTest

Format Time
Doppelklicken Sie im Designer auf "dtpTest".

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

Steuerung	Eigentum	Wert
`label1`	Text	`(blank space)`
	Name	`lblTest`
`dateTimePicker1`	Name	`dtpTest`
	Format	Time

Ändern Sie den Code so, dass er wie folgt aussieht.

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 "Testen", 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 Uhrzeit im ctlAlarmClock Steuerelement aktualisiert wird und dass die Startzeit im DateTimePicker Steuerelement angezeigt wird.
Klicken Sie auf die Stelle, an der DateTimePicker die Minuten der Stunde angezeigt werden.
Verwenden Sie die Tastatur, um den Minutenwert so einzustellen, dass er eine Minute größer ist als die aktuelle Zeit, die von ctlAlarmClock angezeigt wird.

Die Uhrzeit für die Alarmeinstellung wird angezeigt in lblTest. Warten Sie, bis die angezeigte Zeit die Alarmzeit erreicht. Wenn die angezeigte Zeit die Zeit erreicht, auf die der Alarm eingestellt ist, wird der lblAlarm blinken.
Klicken Sie auf btnAlarmOff, um den Alarm zu deaktivieren. Sie können jetzt den Alarm zurücksetzen.

Dieser Artikel befasst sich mit einer Reihe wichtiger Konzepte. Sie haben gelernt, ein zusammengesetztes Steuerelement zu erstellen, indem Sie Steuerelemente und Komponenten in einem zusammengesetzten Steuerelementcontainer kombinieren. Sie haben gelernt, Ihrem Steuerelement Eigenschaften hinzuzufügen und Code zu schreiben, um benutzerdefinierte Funktionen zu implementieren. Im letzten Abschnitt haben Sie gelernt, die Funktionalität eines bestimmten zusammengesetzten Steuerelements durch Vererbung zu erweitern und die Funktionalität von Hostmethoden durch Außerkraftsetzung dieser Methoden zu ändern.

Siehe auch

Feedback

War diese Seite hilfreich?

Last updated on 2025-05-07