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.
GFU-Schulungen  [Anzeige]

C# Komplett

Sie kennen sich in objektorientierter Programmierung aus. Sie schreiben C++ oder Java? Und nun stehen Sie vor der Aufgabe, in C# Anwendungen zu erstellen. Das C# Komplett-Seminar verschafft Ihnen umfassende Programmierkenntnisse in dieser Sprache. Nach der Schulung entwickeln Sie selbständig Anwendungen mit C#. Sie kennen die Datentypen und Klassenbibliotheken der objektorientierten Programmiersprache C#. Der Komplettkurs setzt bei den Grundlagen von C# ein. Sie arbeiten mit Variablen und konvertieren Typen. Multithreading, Delegates, Generics sind nach dem Seminar für Sie kein Geheimnis mehr.

ASP.NET Core - Der Einstieg

In nur 3 Tagen lernen Sie, wie man mit ASP.NET Core und den Technologien MVC, Entity Framework, WebAPI und Razor professionelle Web-Anwendungs-Architekturen aufbaut. Diese Schulung ist der perfekte Einstieg, um datengetriebene und präsentations-orientierte Applikationen auf Basis der ASP.NET Core Plattform zu erstellen.

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!