myCSharp.de - DIE C# und .NET Community
Willkommen auf myCSharp.de! Anmelden | kostenlos registrieren
 
 | Suche | FAQ

» Hauptmenü
myCSharp.de
» Startseite
» Forum
» FAQ
» Artikel
» C#-Snippets
» Jobbörse
» Suche
» Regeln
» Wie poste ich richtig?
» Forum-FAQ

Mitglieder
» Liste / Suche
» Wer ist wo online?

Ressourcen
» openbook: Visual C#
» openbook: OO
» Microsoft Docs

Team
» Kontakt
» Übersicht
» Wir über uns

» myCSharp.de Diskussionsforum
Du befindest Dich hier: Community-Index » Diskussionsforum » Entwicklung » Code-Reviews » Label Objekt zum Blinken gebracht
Letzter Beitrag | Erster ungelesener Beitrag Druckvorschau | Thema zu Favoriten hinzufügen

Antwort erstellen
Zum Ende der Seite springen  

Label Objekt zum Blinken gebracht

 
Autor
Beitrag « Vorheriges Thema | Nächstes Thema »
Pardasus Pardasus ist männlich
myCSharp.de-Mitglied

Dabei seit: 11.09.2016
Beiträge: 61


Pardasus ist offline

Label Objekt zum Blinken gebracht

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Moin,
ich habe mir etwas gebaut, womit ein beliebiges Label Objekt zum Blinken gebracht werden kann und selbst aus einem "fremden" Thread heraus, über das Objekt der Text einfach abgeändert werden kann.

Eigentlich bin ich ganz zufrieden damit, bis auf das Dispose() vielleicht hat da jemand noch ein Tipp für mich? Wenn man nach dem Dispose() z.b. wieder Start() ausführt, kommt eine Fehlermeldung, irgendwie noch unschön. Ich weis das man nach dem Dispose() den Start() nicht wieder ausführen kann ;-) freue mich auf Feedback zum Code.

C#-Code:
    public class LabelFlash : IDisposable
    {
        private System.Timers.Timer _timer = new System.Timers.Timer(1000);
        private Label _labelObj = null;
        private bool _changeCanStop = false;

        /// <summary>
        /// Gibt das Aktuell genutzte Label zurück oder legt dieses fest.
        /// </summary>
        public Label Label
        {
            get { return _labelObj; }
            set
            {
                _labelObj.Visible = true;
                _labelObj = value;
            }
        }

        /// <summary>
        /// Gibt das Intervall in dem das Label blinken soll in ms zurück oder legt dieses fest.
        /// </summary>
        public double Interval
        {
            get { return _timer.Interval; }
            set
            {
                _timer.Interval = value;
            }
        }

        /// <summary>
        /// Legt fest ob das Label weiter Blinken soll wenn der Text geändert wird. Standard ist Deaktiviert
        /// </summary>
        public bool ChangeStop
        {
            get { return _changeCanStop; }
            set { _changeCanStop = value; }
        }

        /// <summary>
        /// Legt den Text des Label fest oder ruft diesen ab.
        /// </summary>
        public string Text
        {
            get
            {
                if (_labelObj.InvokeRequired)
                {
                    return (string)_labelObj.Invoke(new Func<string>(() => _labelObj.Text));
                }
                else
                {
                    return _labelObj.Text;
                }
            }
            set
            {
                _labelObj.ForeColor = System.Drawing.Color.Black;

                if (_labelObj.InvokeRequired)
                {
                    _labelObj.Invoke(new Func<string>(() => _labelObj.Text = value));
                }
                else
                {
                    _labelObj.Text = value;
                }
            }
        }

        /// <summary>
        /// Legt den Text des Labels fest und ändert die Farbe auf Rot ab.
        /// </summary>
        public string AlertText
        {
            set
            {
                _labelObj.ForeColor = System.Drawing.Color.Red;

                if (_labelObj.InvokeRequired)
                {
                    _labelObj.Invoke(new Func<string>(() => _labelObj.Text = value));
                }
                else
                {
                    _labelObj.Text = value;
                }
            }
        }

        /// <summary>
        /// Bringt ein Label zum Blinken in einem festgestelten ms Interval.
        /// </summary>
        /// <param name="LabelObj">Label welches blinken soll.</param>
        public LabelFlash(Label LabelObj)
        {
            _labelObj = LabelObj;
            _timer.Elapsed += _timer_Elapsed;
            _labelObj.TextChanged += _labelObj_TextChanged;
        }

        /// <summary>
        /// Bringt ein Label zum Blinken in dem übergebenen ms Interval.
        /// </summary>
        /// <param name="LabelObj">Label welches blinken soll.</param>
        /// <param name="Interval">Interval in ms.</param>
        public LabelFlash(Label LabelObj, double Interval)
        {
            _labelObj = LabelObj;
            _timer.Interval = Interval;
            _timer.Elapsed += _timer_Elapsed;
            _labelObj.TextChanged += _labelObj_TextChanged;
        }

        /// <summary>
        /// Startet das Blinken des Labels.
        /// </summary>
        /// <returns></returns>
        public LabelFlash Start()
        {
            _timer.Start();
            return this;
        }

        /// <summary>
        /// Startet das Blinken des Labels.
        /// </summary>
        /// <param name="ChangeCantStop">Legt fest ob das Label weiter Blinken soll wenn der Text geändert wird.</param>
        /// <returns></returns>
        public LabelFlash Start(bool ChangeCantStop)
        {
            _timer.Start();
            _changeCanStop = ChangeCantStop;
            return this;
        }

        /// <summary>
        /// Stop das Blinken des Labels und macht es wieder sichtbar.
        /// </summary>
        public void Stop()
        {
            _timer.Stop();
            _labelObj.Visible = true;
        }

        // Wenn Aktiviert, hört das Label auf zu Blinken wenn der Text geändert wird.
        private void _labelObj_TextChanged(object sender, EventArgs e)
        {
            if (_changeCanStop)
            {
                Stop();
            }
        }

        // Wird im Defenierten Interval ausgeführt und lässt das Label Asynchron Blinken.
        private void _timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            if (_labelObj.InvokeRequired)
            {
                _labelObj.Invoke(new Action(() => _timer_Elapsed(sender, e)));
            }
            else
            {
                _labelObj.Visible = !_labelObj.Visible;
            }
        }

        protected virtual void Dispose(bool disposing)
        {
            if(disposing)
            {
                ((IDisposable)_timer).Dispose();
                _timer = null;
            }
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(true);
        }
    }

Dieser Beitrag wurde 1 mal editiert, zum letzten Mal von Pardasus am 12.02.2018 21:19.

12.02.2018 21:16 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
Palladin007 Palladin007 ist männlich
myCSharp.de-Mitglied

Dabei seit: 03.02.2012
Beiträge: 1.258
Entwicklungsumgebung: Visual Studio 2017
Herkunft: NRW


Palladin007 ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Du solltest dazu schreiben, dass es sich um WindowsForms handelt ;)


Zu deiner eigentlichen Frage bezüglich Dispose:

Ich würde den Timer nicht diposen, zumindest nicht sofort.
Ich würde ihn im ersten Schritt normal beenden, der müsste dafür eine Stop-Methode haben. Danach kannst Du immer noch diposen. Ob das bei diesem Timer notwendig oder sinnvoll ist, kann ich dir aber nicht sagen, ich halte mich aber an dieses Vorgehen, wenn die Dispose-Methode nicht im Destruktor aufgerufen wurde. Das würde bei dir zwar (vermutlich) keinen Unterschied machen, aber früher oder später wirst Du Situationen erleben, wo das einen großen Unterschied macht ;)

Ansonsten weiß ich nicht, was dich daran stört. Es ist in vielen Fällen so, dass ein Objekt nach einem Dispose nicht mehr verwendet werden kann. Grundsätzlich würde ich mich eher darauf verlassen, dass ein Objekt nach einem Dispose nicht mehr verwendet werden, selbst wenn es funktioniert.

Einziger Knackpunkt:

C#-Code:
GC.SuppressFinalize(true);

Die Methode verhindert, dass der Destruktor von GC aufgerufen wird. Du verhinderst, dass der GC den Destruktor von dem bool-Wert aufruft.
Du musst this übergeben.


Allgemein zu der Klasse:

Mir scheint es so, als würdest Du zwei Aufgaben vermischen.
Zum Einen lässt die Klasse das Label blinken und zum Anderen schreibt sie den Text des Labels mit verschiedenen Farben. Abgesehen davon, dass die Farben von außen nicht geändert werden können, hat das Text und Farbe ändern nichts mit dem Blinken an sich zu tun, oder?
Das würde ich daher komplett raus lassen, immerhin verschenkst Du dadurch Flexibilität und erhöhst unnötig die Komplexität.
Abgesehen davon würde das Ändern der Farbe aus einem anderen Thread heraus wahrscheinlich crashen ;)

Wenn ich mich richtig erinnere, brauchst Du beim reinen Abfragen der Eigenschaften (wie Du es bei den Text-Properties tust) kein Invoke. Du änderst den Wert und damit den Zustand des Objektes nicht, abrufen sollte also aus jedem Thread heraus funktionieren. Teste das aber lieber nochmal - oder jemand korrigiert mich hier.

Die ChangeStop-Property kannst Du auch automatisch implementieren lassen, das spart eine Zeile Code :D

Ich würde - nur meine subjektive Ansicht - das Label nicht von außen ändern lassen, die Label-Property würde ich also entfernen. Alles was von außen geändert werden kann, musst Du verwalten bzw. Du musst die Änderungen beachten können. Wenn das nicht unbedingt notwendig ist, erhöht es nur die Komplexität ohne wirklichen Gewinn.
In deinem Fall würde das z.B. Probleme verursachen, denn Du musst die TextChanged-Methode vom Event des alten Labels entfernen und dem Neuen hinzufügen. Das heißt, dein ChangeStop-Feature funktioniert mit einem neuen Label nicht und eine Änderung an einem alten Label würde zu merkwürdigem Verhalten führen. Außerdem würde damit das alte Label-Objekt am Leben gehalten werden, selbst wenn es nicht mehr genutzt wird und der GC es sonst weg werfen würde.

Ich persönlich versuche Konstruktoren immer so zu bauen, dass alle Überladungen nichts weiter tun als ihre Parameter aufzubereiten und an einen anderen Konstruktor weiter zu reichen - oder Default-Werte übergeben. Daraus resultiert, dass von vielen Konstruktoren nur Einer die eigentliche Arbeit tut und die Anderen nur weiter leiten. Spätestens bei komplexen Initialisierungen wird das hilfreich.
Du könntest z.B. für den interval-Parameter optional deklarieren und mit einem sinnvollen Default-Wert versehen. Oder die Überladung ohne diesen Parameter gibt diesen Default-Wert weiter.
Das geht natürlich nur, wenn die Initialisierungs-Varianten sich nicht zu stark von einander unterscheiden, aber da muss man dann je nach Situation schauen.

Methoden-Parameter werden mit kleinem ersten Buchstaben geschrieben ;) Das ist zumindest sehr weit verbreitet, ich glaub Microsoft hat das in einer Guideline veröffentlicht.
12.02.2018 22:29 Beiträge des Benutzers | zu Buddylist hinzufügen
Abt
myCSharp.de-Team

avatar-4119.png


Dabei seit: 20.07.2008
Beiträge: 13.835
Herkunft: Stuttgart/Stockholm


Abt ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Zitat von Pardasus:
Wenn man nach dem Dispose() z.b. wieder Start() ausführt, kommt eine Fehlermeldung, irgendwie noch unschön.

Prinzipiell ist das auch korrekt.
Ein Objekt, das disposed ist, sollte bei einem weiteren Zugriff eine ObjectDisposedException werfen.
13.02.2018 00:12 Beiträge des Benutzers | zu Buddylist hinzufügen
Palin Palin ist männlich
myCSharp.de-Mitglied

Dabei seit: 22.08.2011
Beiträge: 1.090
Entwicklungsumgebung: VB.net


Palin ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Es fehlt auch der  Finalizer, der wird vom GC aufgerufen wenn man vergessen sollte Dispose aufzurufen.

Für den Timer sollte auf jeden Fall Dispose aufgerufen werden. (Wenn ich es richtig im Kopft habe) Eine der Timer Varianten wird auf dem Speicher gepinnt. Und das verhindert das der GC ihn wegräumen kann.
13.02.2018 12:29 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
Pardasus Pardasus ist männlich
myCSharp.de-Mitglied

Dabei seit: 11.09.2016
Beiträge: 61

Themenstarter Thema begonnen von Pardasus

Pardasus ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Erst einmal Danke für das Feedback!

Zitat:
Mir scheint es so, als würdest Du zwei Aufgaben vermischen.
Zum Einen lässt die Klasse das Label blinken und zum Anderen schreibt sie den Text des Labels mit verschiedenen Farben. Abgesehen davon, dass die Farben von außen nicht geändert werden können, hat das Text und Farbe ändern nichts mit dem Blinken an sich zu tun, oder?
Das würde ich daher komplett raus lassen, immerhin verschenkst Du dadurch Flexibilität und erhöhst unnötig die Komplexität.
Abgesehen davon würde das Ändern der Farbe aus einem anderen Thread heraus wahrscheinlich crashen ;)

Da hast Du recht, es sieht aus als würde ich was vermischen. Ich habe ein kleines Programm was im Hintergrund z.b. Daten einliest und es soll Signalisiert werden "Hey ich tun gerade was im Hintergrund". Wenn dann etwas schief läuft, soll der Text aufhören zu Blinken und Rot werden. Damit ich aus einen beliebigen Thread heraus das machen kann, habe ich mir auch gleich noch gedacht das sich das Objekt darum kümmern kann, dass der Text auch wirklich ausgegeben wird (die ganze Invoke Geschichte).
Aus meiner Perspektive sah das alles klar aus und gehört zusammen :-)

Zitat:
Die ChangeStop-Property kannst Du auch automatisch implementieren lassen, das spart eine Zeile Code :D

Da stehe ich gerade auf dem schlauch, wie meinst Du das?

Zitat:
Ich würde - nur meine subjektive Ansicht - das Label nicht von außen ändern lassen, die Label-Property würde ich also entfernen. Alles was von außen geändert werden kann, musst Du verwalten bzw. Du musst die Änderungen beachten können. Wenn das nicht unbedingt notwendig ist, erhöht es nur die Komplexität ohne wirklichen Gewinn.

Du meinst, das _labelObj sollte nicht nach dem Instanzieren des Objekts änderbar sein? Mmh, das stimmt. Wenn man das möchte, muss man sich ein neues Objekt Instanzieren, dann kann nichts schief gehen. Danke!

Zitat:
Ich persönlich versuche Konstruktoren immer so zu bauen, dass alle Überladungen nichts weiter tun als ihre Parameter aufzubereiten und an einen anderen Konstruktor weiter zu reichen - oder Default-Werte übergeben. Daraus resultiert, dass von vielen Konstruktoren nur Einer die eigentliche Arbeit tut und die Anderen nur weiter leiten. Spätestens bei komplexen Initialisierungen wird das hilfreich.
Du könntest z.B. für den interval-Parameter optional deklarieren und mit einem sinnvollen Default-Wert versehen. Oder die Überladung ohne diesen Parameter gibt diesen Default-Wert weiter.
Das geht natürlich nur, wenn die Initialisierungs-Varianten sich nicht zu stark von einander unterscheiden, aber da muss man dann je nach Situation schauen.

Wie ruft den der eine Konstruktor den anderen auf?

Zitat:
Methoden-Parameter werden mit kleinem ersten Buchstaben geschrieben ;) Das ist zumindest sehr weit verbreitet, ich glaub Microsoft hat das in einer Guideline veröffentlicht.

Super, danke! :) ich bin immer noch dabei mein Stil zu finden. Versuche mich aber sehr an "feste" Regeln zu halten.

Zu den Dispose() mal Grundsätzlich. Da ich bis jetzt sehr kleine, unbedeutsame Anwendung geschrieben habe, habe ich mich nie damit ernsthaft Beschäftigt bei meinen eigenen Objekten.
Klar, wenn ich z.b. ein Objekt benutzt wie FileStream etc. wo ein Dispose() dabie ist, nutze ich diesen auch. Habe aber nie wirklich selbst ein in mein Objekt eingebaut.
Ist vielleicht jetzt der falsche bereich im Forum, aber wie würde ich für diese Objekt von mir ein Dispose() richtig hinterlegen?

Dieser Beitrag wurde 1 mal editiert, zum letzten Mal von Pardasus am 13.02.2018 19:23.

13.02.2018 19:21 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
Palladin007 Palladin007 ist männlich
myCSharp.de-Mitglied

Dabei seit: 03.02.2012
Beiträge: 1.258
Entwicklungsumgebung: Visual Studio 2017
Herkunft: NRW


Palladin007 ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

Zitat:
Da hast Du recht, es sieht aus als würde ich was vermischen. Ich habe ein kleines Programm was im Hintergrund z.b. Daten einliest und es soll Signalisiert werden "Hey ich tun gerade was im Hintergrund". Wenn dann etwas schief läuft, soll der Text aufhören zu Blinken und Rot werden. Damit ich aus einen beliebigen Thread heraus das machen kann, habe ich mir auch gleich noch gedacht das sich das Objekt darum kümmern kann, dass der Text auch wirklich ausgegeben wird (die ganze Invoke Geschichte).
Aus meiner Perspektive sah das alles klar aus und gehört zusammen :-)

Ich sehe das immer noch als gemischte Aufgaben :P
Vermutlich willst Du eher etwas, was sich um das korrekte ausführen bei mehreren Threads kümmert und da würde ich dann eine InvokeIfNecessary-Erweiterungsmethode definieren. Die sähe dann z.B. so aus:

C#-Code:
public static void InvokeIfNecessary(this Control control, Action action)
{
    if (_labelObj.InvokeRequired)
        _labelObj.Invoke(action);
    else
        action();
}

Ich hoffe, ich hab jetzt nichts über den Haufen geworfen, ich hab lange nichts mehr mit WinForms gemacht.

Wenn Du das Text schreiben und ändern der Farbe raus ziehst, hast Du langfristig betrachtet, mehr Möglichkeiten. Wenn Du z.B. irgendwann mehrere Labels hast, wo Du verschiedene Farben oder drei Zustände anstatt zwei hast, dann musst Du jedes Mal deine Klasse so erweitern, dass sie das kann.
Und das nur um zwei Property-Zuweisungen zu "verstecken"?

Zitat:
Da stehe ich gerade auf dem schlauch, wie meinst Du das?

C#-Code:
public int MyProperty1 { get; set; }
public int MyProperty2 { get; private set; }
public int MyProperty3 { get; }

1. Ist eine normale Property, wie dein ChangeStop. Der Compiler generiert auch einfach nur ein BackingField dafür, technisch ändert sich also nichts, es ist bloß weniger Schreibarbeit.
2. Kann nur in der selben Klasse geschrieben werden.
3. Kann gar nicht geschrieben werden, außer per Reflection.

Zitat:
Du meinst, das _labelObj sollte nicht nach dem Instanzieren des Objekts änderbar sein? Mmh, das stimmt. Wenn man das möchte, muss man sich ein neues Objekt Instanzieren, dann kann nichts schief gehen. Danke!

Genau. Du hast auch keinen Nachteil dadurch, außer einen minimal größeren Speicherbedarf, aber das ist heutzutage völlig irrelevant, dass es mehr Nachteile als Vorteile bringt, wenn Du in dem Maße darauf achtest.

Zitat:
Wie ruft den der eine Konstruktor den anderen auf?

C#-Code:
public MyClass()
    : this(5)
{
    // Der Code hier wird nach MyClass(int) aufgerufen
}
public MyClass(int zahl)
    : this(zahl.ToString())
{
    // Der Code hier wird nach MyClass(string) aufgerufen
}
public MyClass(string text)
{
    _text = text;
    // Und was noch so nötig ist
}

Das this in dem Fall "zeigt" auf einen anderen Konstruktor, der zu den übergebenen Parametern passt. Meine Kommentare zeigen dabei die Reihenfolge auf, denn der Konstruktor, auf den this "zeigt", der wird immer vor dem eigentlichen Konstruktor-Inhalt ausgeführt.


Bezüglich Dispose:

Ich würde sagen, Du brauchst dieses Dispose-Muster gar nicht, solange Du nur verwaltete Ressourcen verwendest.
Wenn Du z.B. von der Windows-API irgendein Handle anfragst, das später wiederfrei gegeben werden muss, dann brauchst Du das Dispose-Muster in seiner umfangreichen Form:

C#-Code:
public MyClass()
{
    // ...
}
// Das ist der Destruktor:
~MyClass()
{
    Dispose(false);
}

public void Dispose()
{
    Dispose(true);
    GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
    if (disposing)
    {
        // verwaltete Ressourcen frei geben
    }

    // nicht verwaltete Ressourcen (wie das Handle) frei geben.
}

Wenn Du Dispose aufrufst, dann werden alle Ressourcen normal frei gegeben und der Garbage Collector weiß, dass er den Destruktor nicht mehr aufrufen soll.
Wenn das aus irgendeinem Grund nicht klappt, dann wird früher oder später der GC aufräumen und den Destruktor aufrufen. Er stellt damit sicher, dass die nicht verwalteten Ressourcen frei gegeben werden, wenn alle anderen Sicherungen versagt haben. Die verwalteten Ressourcen interessieren an der Stelle nicht, denn die sind dem GC bekannt (daher verwaltet), der wird bei denen auch noch aufräumen.

Der Timer ist eine verwaltete Ressource. Der bzw. die intern verwendeten Ressourcen kümmern sich selber darum, dass alle nicht verwalteten Ressourcen frei gegeben werden.
In dem Fall sähe das dann so aus:

C#-Code:
public MyClass()
{
}

public void Dispose()
{
    _timer.Dispose();
}

Prinzipiell solltest Du darauf achten, dass jede Klasse, die Ressourcen verwendet, die frei gegeben werden müssen, immer IDisposable implementiert und je nach Art der Ressource auch sicher stellt, dass nicht verwaltete Ressourcen aufgeräumt werden können, selbst wenn Dispose nicht aufgerufen wurde.
Der Nutzer einer Klasse sollte nur noch als einzige Verantwortung sicher stellen, dass er Dispose aufruft. Alles Weitere sollte die Klasse intern für sich klären.

Beachte aber:
Du kannst nicht einfach alles im Destruktor aufräumen und auf IDispoable verzichten, denn Du weißt darin nicht, welches Objekt noch existiert (es könnte sein, dass irgendetwas plötzlich null ist). Es gibt noch mehr Nachteile, aber ich will jetzt nichts schreiben, was ich nicht sicher weiß.

Eigentlich ist der Destruktor in dem Konzept nur ein Notfall-Pflaster. Wenn der Destruktor gebraucht wird, hast Du etwas falsch gemacht, denn eigentlich sollte der nie aufgerufen werden, da immer Dispose alles regelt.
In dem Zuge solltest Du dir auch mal  using anschauen, denn das sorgt dafür, dass auch im Fall einer Exception das Dispose aufgerufen wird.
13.02.2018 21:25 Beiträge des Benutzers | zu Buddylist hinzufügen
Pardasus Pardasus ist männlich
myCSharp.de-Mitglied

Dabei seit: 11.09.2016
Beiträge: 61

Themenstarter Thema begonnen von Pardasus

Pardasus ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

WoW, vielen Dank für dein sehr ausführlichen Beitrag und tollen Tipps! Ich habe den Code mal angepasst.
Ist das Dispose() nun auch richtig?

C#-Code:
    public class LabelFlash : IDisposable
    {
        private System.Timers.Timer _timer = new System.Timers.Timer(1000);

        /// <summary>
        /// Gibt das Aktuell genutzte Label zurück.
        /// </summary>
        public Label LabelObj { get; } = null;

        /// <summary>
        /// Gibt das Intervall in dem das Label blinken soll in ms zurück oder legt dieses fest.
        /// </summary>
        public double Interval
        {
            get { return _timer.Interval; }
            set { _timer.Interval = value; }
        }

        /// <summary>
        /// Legt fest ob das Label weiter Blinken soll wenn der Text geändert wird. Standard ist Deaktiviert
        /// </summary>
        public bool ChangeStop { get; set; } = false;

        /// <summary>
        /// Legt den Text des Label fest oder ruft diesen ab.
        /// </summary>
        public string Text
        {
            get
            {
                if (LabelObj.InvokeRequired)
                {
                    return (string)LabelObj.Invoke(new Func<string>(() => LabelObj.Text));
                }
                else
                {
                    return LabelObj.Text;
                }
            }
            set
            {
                LabelObj.ForeColor = System.Drawing.Color.Black;

                if (LabelObj.InvokeRequired)
                {
                    LabelObj.Invoke(new Func<string>(() => LabelObj.Text = value));
                }
                else
                {
                    LabelObj.Text = value;
                }
            }
        }

        /// <summary>
        /// Legt den Text des Labels fest und ändert die Farbe auf Rot ab.
        /// </summary>
        public string AlertText
        {
            set
            {
                LabelObj.ForeColor = System.Drawing.Color.Red;

                if (LabelObj.InvokeRequired)
                {
                    LabelObj.Invoke(new Func<string>(() => LabelObj.Text = value));
                }
                else
                {
                    LabelObj.Text = value;
                }
            }
        }

        /// <summary>
        /// Bringt ein Label zum Blinken in einem festgestelten ms Interval.
        /// </summary>
        /// <param name="labelObj">Label weches blinken soll.</param>
        public LabelFlash(Label labelObj)
        {
            this.LabelObj = labelObj;
            _timer.Elapsed += _timer_Elapsed;
            this.LabelObj.TextChanged += LabelObj_TextChanged;
        }

        /// <summary>
        /// Bringt ein Label zum Blinken in dem übergebenen ms Interval.
        /// </summary>
        /// <param name="labelObj">Label welches blinken soll.</param>
        /// <param name="interval">Interval in ms.</param>
        public LabelFlash(Label labelObj, double interval) : this(labelObj)
        {
            _timer.Interval = interval;
        }

        /// <summary>
        /// Startet das Blinken des Labels.
        /// </summary>
        /// <returns></returns>
        public LabelFlash Start()
        {
            _timer.Start();
            return this;
        }

        /// <summary>
        /// Startet das Blinken des Labels.
        /// </summary>
        /// <param name="changeStop">Legt fest ob das Label weiter Blinken soll wenn der Text geändert wird.</param>
        /// <returns></returns>
        public LabelFlash Start(bool changeStop)
        {
            _timer.Start();
            ChangeStop = changeStop;
            return this;
        }

        /// <summary>
        /// Stop das Blinken des Labels und macht es wieder sichtbar.
        /// </summary>
        public void Stop()
        {
            _timer.Stop();
            LabelObj.Visible = true;
        }

        // Wenn Aktiviert, hört das Label auf zu Blinken wenn der Text geändert wird.
        private void LabelObj_TextChanged(object sender, EventArgs e)
        {
            if (ChangeStop)
            {
                Stop();
            }
        }

        // Wird im Defenierten Interval ausgeführt und lässt das Label Asynchron Blinken.
        private void _timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            if (LabelObj.InvokeRequired)
            {
                LabelObj.Invoke(new Action(() => _timer_Elapsed(sender, e)));
            }
            else
            {
                LabelObj.Visible = !LabelObj.Visible;
            }
        }

        ~LabelFlash()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                _timer.Dispose();
            }

            LabelObj.TextChanged -= LabelObj_TextChanged;
            _timer.Elapsed -= _timer_Elapsed;
        }
    }

Dieser Beitrag wurde 2 mal editiert, zum letzten Mal von Pardasus am 13.02.2018 23:24.

13.02.2018 23:22 E-Mail | Beiträge des Benutzers | zu Buddylist hinzufügen
Palladin007 Palladin007 ist männlich
myCSharp.de-Mitglied

Dabei seit: 03.02.2012
Beiträge: 1.258
Entwicklungsumgebung: Visual Studio 2017
Herkunft: NRW


Palladin007 ist offline

Beitrag: beantworten | zitieren | editieren | melden/löschen       | Top

In deinem Fall reicht ein ganz simples

C#-Code:
public void Dispose()
{
    _timer.Dispose();
}

Das Event beim Timer zu entfernen ist vermutlich überflüssig, da der Timer sowieso nicht mehr arbeitet.

Ach was mir dabei auch auffällt:
Ich würde das Event am Label nicht im Konstruktor registrieren, sondern in Start(), denn erst dann ist es von Bedeutung, oder?
Das Timer-Event kann auch im Konstruktor definiert werden, die Klasse hat ja intern die Kontrolle, wann es geworfen wird.

So würde ich es machen:

C#-Code:
public void Start()
{
    _label.TextChanged += LabelObj_TextChanged;
    _timer.Start();
}
public void Stop()
{
    _timer.Stop();
    _label.TextChanged -= LabelObj_TextChanged;

    _label.InvokeIfNecessary(() => LabelObj.Visible = true);
}
public void Dispose()
{
    Stop();
    _timer.Dispose();
}

Nagel mich nicht darauf fest, dass das funktioniert. Der Code ist im Browser runter getippt und nicht getestet, aber ich denke, das Prinzip wird klar.

Ach ja:
Das Zuweisen der ForeColor kann immer noch zu Problemen führen :P
14.02.2018 11:27 Beiträge des Benutzers | zu Buddylist hinzufügen
Baumstruktur | Brettstruktur       | Top 
myCSharp.de | Forum Der Startbeitrag ist älter als 2 Jahre.
Der letzte Beitrag ist älter als 2 Jahre.
Antwort erstellen


© Copyright 2003-2020 myCSharp.de-Team | Impressum | Datenschutz | Alle Rechte vorbehalten. | Dieses Portal verwendet zum korrekten Betrieb Cookies. 05.06.2020 19:43