Feedback

C# - Eigenes Ereignis für die Progressbar und sonstige Meldungen

Veröffentlicht von am 08.11.2015
(0 Bewertungen)
Dieses Snippet zeigt, wie eine eigene Event-Klasse erstellt werden kann und deren Implementierung. Als Beispiel dient die Ausgabe des Programmfortschritts. Über ein Enum und eine SwitchCase-Anweisung können Ereignisse differenziert werden. Die Beispielklasse 'ProgressEventArgs' bietet zudem die Möglichkeit einen boolschen Wert 'Cancel' zu setzen und für einen Abbruch auszuwerten. Dem object Tag kann ein beliebiger Wert übergeben werden.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EventTest
{
    class Program
    {
       
        static void Main(string[] args)
        {
            //Implementierung
            Langerprozess.ProgressChanged += Langerprozess_ProgressChanged;
            //Start langer Prozess..
            Langerprozess.Run(1000);

        }
        /// <summary>
        /// Ereignisbehandlung
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e">object ProgressEventArgs</param>
        private static void Langerprozess_ProgressChanged(object sender, ProgressEventArgs e)
        {
            Console.Clear();

            switch (e.EventTyp)
            {

                case ProgressEventArgs.eEventTyp.Progress:
                    Console.WriteLine(e.Message + e.Prozent + "%");
                    break;
                case ProgressEventArgs.eEventTyp.Start:
                case ProgressEventArgs.eEventTyp.Abbruch:
                case ProgressEventArgs.eEventTyp.Error:
                case ProgressEventArgs.eEventTyp.Ende:
                    Console.WriteLine(e.Message);
                    break;
                default:
                    break;
            }
        }
    }

    class Langerprozess
    {
        #region Events..

        /// <summary>
        /// Ereignis - Fortschritt
        /// </summary>
        public static event EventHandler<ProgressEventArgs> ProgressChanged;
        /// <summary>
        /// Ereignisbehandlungsmethode Prozess-Fortschritt
        /// </summary>
        /// <param name="e">ProgressEventArgs e</param>
        public static void OnProgressChanged(ProgressEventArgs e)
        {
            if (ProgressChanged != null) ProgressChanged(null, e);
        }

        #endregion

        public static void Run(int Count)
        {

            OnProgressChanged(new ProgressEventArgs(ProgressEventArgs.eEventTyp.Progress, "Start"));

            for (int i = 0; i < Count; i++)
            {
                ProgressEventArgs Pea = new ProgressEventArgs(ProgressEventArgs.eEventTyp.Progress, "Verarbeitet:", (100.00f * i) / Count);

                OnProgressChanged(Pea);

                if (Pea.Cancel)
                {
                    OnProgressChanged(new ProgressEventArgs(ProgressEventArgs.eEventTyp.Abbruch, "Abbruch durch Benutzer"));

                    return;
                }

                System.Threading.Thread.Sleep(10);
            }

            OnProgressChanged(new ProgressEventArgs(ProgressEventArgs.eEventTyp.Progress, "Start"));
        }

    }
    /// <summary>
    /// Eigenes Ereignis
    /// </summary>
    class ProgressEventArgs:EventArgs
    {
        public enum eEventTyp {Start, Progress, Abbruch, Error, Ende }
        public eEventTyp EventTyp { get; set; }

        public string Message { get; set; }
        public float Prozent { get; set; }
        public bool Cancel { get; set; }
        public object Tag { get; set; }

        public ProgressEventArgs() { }

        public ProgressEventArgs(eEventTyp eventtyp, string message) : this(eventtyp, message, 0, false, null)
        {

        }

        public ProgressEventArgs(eEventTyp eventtyp, string message,float prozent):this(eventtyp, message, prozent, false, null)
        {

        }
        public ProgressEventArgs(eEventTyp eventtyp, string message, float prozent,bool cancel) : this(eventtyp, message, prozent, false, null)
        {

        }
        public ProgressEventArgs(eEventTyp eventtyp, string message, float prozent, bool cancel, object tag)
        {
            this.EventTyp = eventtyp;
            this.Message = message;
            this.Prozent = prozent;
            this.Cancel = cancel;
            this.Tag = tag;
        }
    }
}

Abgelegt unter C#, Ereignis, Progress, Enum.

3 Kommentare zum Snippet

Koopakiller schrieb am 09.11.2015:
Was ist bei deinem Snippet der wirkliche Vorteil gegenüber dem Einsatz eines Backgroundworker's?
Martin Dauskardt schrieb am 10.11.2015:
Es geht im Snippet um das grundsätzliche Implementieren von eigenen Ereignissen und ein Aufzeigen von Möglichkeiten der Nutzung (für Anfänger). Natürlich kann man das auch asynchrone über Threads oder Worker-Threads lösen, das ist aber nicht immer erwünscht oder notwendig. Das Control Progressbar dient hier nur als einfaches Beispiel.
Koopakiller schrieb am 11.11.2015:
Alles klar, also mehr ein "Lehr-Snippet".
 

Logge dich ein, um hier zu kommentieren!