1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

    protected void OnUpdateText(string text)
    {
      OnUpdateText(new TextEventArgs(text));
    }

    protected virtual void OnUpdateText(TextEventArgs e)
    {
      EventHandler<TextEventArgs> ev = UpdateText;
      if (ev != null)
        ev(this, e);
    }                    

1:
2:

if(UpdateText != null)
   UpdateText(this, new TextEventArgs("MeinLieberText"));                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

/// <summary>
/// Raises an event thread-safe
/// (cause the 'this' parameter of an extension method is always handled thread-safe by the compiler)
/// </summary>
/// <typeparam name="T">type of the EventArgs parameter</typeparam>
/// <param name="eventHandler">event handler</param>
/// <param name="sender">sender object</param>
/// <param name="e">event args</param>
public static void RaiseEvent<T>(this EventHandler<T> eventHandler, object sender, T e)
    where T : EventArgs
{
    if (eventHandler != null)
    {
        eventHandler(sender, e);
    }
}                    

1:

UpdateText.RaiseEvent(this, new TextEventArgs("MeinLieberText"));                    

1:
2:
3:

   at ConsoleApplication15.Program.Handler(Object sender, EventArgs e)
   at ConsoleApplication15.Program.Main(String[] args)
Drücken Sie eine beliebige Taste . . .                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:

class Program
{
    static void Main(string[] args)
    {
        var tmp = new EventRaiser();
        tmp.Event += Handler;
        tmp.ThrowEvent(new object());
    }

    static void Handler(object sender, EventArgs e)
    {
        Console.WriteLine(new StackTrace().ToString());
    }
}

public class EventRaiser
{
    public EventHandler<EventArgs> Event;

    public void ThrowEvent(object sender)
    {
        Event.RaiseEvent(sender, EventArgs.Empty);
    }
}

public static class ExtensionMethods
{
    public static void RaiseEvent<T>(this EventHandler<T> eventHandler, object sender, T e) where T : EventArgs
    {
        var ev = eventHandler;
        if (ev != null)
            ev(sender, e);
    }        
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:

public class Employee
{
    // deine Properties
}

public class AuthorizationEventArgs : EventArgs  
{
    public string PIN { get; set; }
    public bool Cancel  { get; set; } 
}

public class ControllerBase
{
    public event EventHandler<AuthorizationEventArgs> AuthorizationNeeded;

    protected bool IsUserAuthorized
    {
        get
        {
            AuthorizationEventArgs eventArgs = new AuthorizationEventArgs() { Cancel = false, PIN = string.Empty };
            OnAuthorizationNeeded(eventArgs);

            if(eventArgs.Cancel)
                return false;

            return IsValidPIN(eventArgs.PIN);
        }
    }

    private bool IsValidPIN(string pin)
    {
        // wie du das auch imer machst um die PIN zu prüfen mach es von  hier
        return true;
    }


    private void OnAuthorizationNeeded(AuthorizationEventArgs eventArgs)
    {
        EventHandler<AuthorizationEventArgs> handler = AuthorizationNeeded;
        if (handler != null)
            handler(this, eventArgs);
    }    
}

public interface IController<T> where T : class
{
    bool Save(T obj);
    T Load(long id);
}

public abstract class Controller<T> : ControllerBase, IController<T> where T : class
{
    public bool Save(T obj)
    {
        if (!IsUserAuthorized)
            throw new NotAuthorizedException(); // return false oder ein Enum um genauer zu sagen was Sache ist
        return SaveObject(obj);
    }

    protected abstract bool SaveObject(T obj); 

    public T Load(long id)
    {
        if (!IsUserAuthorized)
            throw new NotAuthorizedException(); // Enum um genauer zu sagen was Sache ist oder return null oder ..
        return LoadObject(id);
    }

    public abstract T LoadObject(long id); 
}

public class EmployeeController : Controller<Employee>
{
    protected override bool SaveObject(Employee obj)
    {
        // deine Speicherlogik
        return true;
    }

    public override Employee LoadObject(long id)
    {
        // deine Ladelogik
        return null;
    }
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

//Am Anfang der Form irgendwo den passenden Controller erzeugen den Event verdrahten und in der Form vorhalten zum speichern und laden
var controller = new EmployeeController();
controller.AuthorizationNeeded += AuthorizationNeeded;

private void AuthorizationNeeded(object sender, AuthorizationEventArgs e)
{
    e.PIN = "1234567"; // hier deine sinnvolle PIN Eingabe Methodik
}

// irgendwo anders dann die Funktionen des Controllers auslösen 
controller.Save(deineLiebeEmployeeInstanz);                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Recycle.Logics
{
    public class AuthorizationEventArgs : EventArgs
    {
        public string PIN { get; set; }

        public event EventHandler<AuthorizationEventArgs> AuthorizationNeeded;

        private void OnAuthorizationNeeded(AuthorizationEventArgs eventArgs)
        {
            EventHandler<AuthorizationEventArgs> ev = AuthorizationNeeded;
            if (ev != null)
                ev(this, eventArgs);
        }  

        public bool IsValid
        {
            get
            {
                return !string.IsNullOrWhiteSpace(PIN);
            }
        }
    }
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using Recycle.Logics;

namespace Recycle.Controls
{
    public partial class AuthorizationUserControl : UserControl
    {
        public AuthorizationUserControl()
        {
            InitializeComponent();
        }

        private void txtSecId_Leave(object sender, EventArgs e)
        {

        }

        private void AuthorizationUserControl_Load(object sender, EventArgs e)
        {
            bsPin.DataSource = new AuthorizationEventArgs();

            AuthorizationEventArgs auth = new AuthorizationEventArgs();
            auth.AuthorizationNeeded += AuthorizationNeeded;
        }

        private void AuthorizationNeeded(object sender, AuthorizationEventArgs e)
        {
            MessageBox.Show("Test");
        }
    }
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:

        private void tsmMitarbeiterAnlegen_Click(object sender, EventArgs e)
        {
            //Prüft, ob lt. Optionen eine Zertifizierung vorgenommen werden soll
            if (MySqlSettings.GetOptionString(connStr, 2) == "Ja")
            {
                //ruf Zertifizeriungsform auf und übergibt das zu prüfende Recht an den Konstruktor
                Zertifizierung myAuth = new Zertifizierung(5);
                myAuth.ShowDialog();

                //Wenn das Fenster geschlossen wird prüfen, ob Auth erfolgreich
                if (myAuth.DialogResult == DialogResult.OK)
                {
                    //Wenn erfolgreich, dann Mitarbeiterverwaltung aufrufen
                    if (myAuth.Authorized == true)
                    {
                        Mitarbeiterverwaltung myEmployee = new Mitarbeiterverwaltung();
                        myEmployee.Show();

                        //Event feiern, welches im UserControl der  Mitarbeiterverwaltung behandelt werden soll
                        OnSendAuthentication(new AuthenticationEventArgs(myAuth.Employee));
                    }
                    else
                    {
                        MsgAusgabe.ShowError("Sie sind nicht berechtigt dieses Modul zu nutzen!");
                    }
                }
            }
                //Falls keine Zertifizierung stattfinden soll einfach anzeigen
            else
            {
                Mitarbeiterverwaltung myEmployee = new Mitarbeiterverwaltung();
                myEmployee.Show();
            }
        }                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

        #region EventAuthentication
        public class AuthenticationEventArgs : EventArgs
        {
            public AuthenticationEventArgs(string text)
            {
                Text = text;
            }

            public string Text { get; set; }
        }

        public event EventHandler<AuthenticationEventArgs> SendAuthentication;

        protected virtual void OnSendAuthentication(AuthenticationEventArgs e)
        {
            EventHandler<AuthenticationEventArgs> ev = SendAuthentication;
            if (ev != null)
                ev(this, e);
        }
        #endregion                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:

namespace Recycle.Dialogs
{
    public partial class Zertifizierung : KryptonForm
    {
        private static long modul;

        public string Employee { get; set; }
        public bool Authorized { get; set; }

        public Zertifizierung(Int64 id)
        {
            InitializeComponent();
            modul = id;
            Authorized = false;
            Employee = null;
        }

        private void txtSecId_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Return)
            {
                btnWeiter.PerformClick();
            }
        }

        private void btnWeiter_Click(object sender, EventArgs e)
        {
            if (txtSecId.Text != string.Empty)
            {
                Employee = EmployeeMethods.GetEmployeeNameFromSecId(Convert.ToInt64(txtSecId.Text));

                if (AuthorizationMethods.GetAuthorization(Convert.ToInt64(txtSecId.Text), modul) == 1)
                {
                    Authorized = true;                
                }
                else
                {
                    Authorized = false;                
                }
            }
            else
            {
                MsgAusgabe.ShowError("Bitte erfassen Sie eine SecurityID!");
            }
        }
    }
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:

    public class AuthorizationMethods
    {
        private static string connStr = DbInfo.GetMySqlConnStr();
        private static string strSql = string.Empty;

        public static int GetAuthorization(long secId, long modul)
        {
            int rueckgabe = 0;
            strSql = "Select count(b.berechtigungmodulid) from mitarbeiter m inner join berechtigungmodulgruppe b " +
                     "on m.berechtigunggruppeid = b.berechtigunggruppeid where m.secid = ?secid and b.berechtigungmodulid = ?berechtigungmodulid";
            using (MySqlConnection conn = new MySqlConnection (connStr))
            {
                using (MySqlCommand cmd = new MySqlCommand (strSql, conn))
                {
                    conn.Open();

                    cmd.Parameters.AddWithValue("?secid", secId);
                    cmd.Parameters.AddWithValue("?berechtigungmodulid", modul);

                    rueckgabe = Convert.ToInt16(cmd.ExecuteScalar());

                    conn.Close();
                }
            }

            return rueckgabe;
        }
    }                    

1:
2:

Mitarbeiterverwaltung myEmployee = new Mitarbeiterverwaltung(myAuth.Employee);
myEmployee.Show();