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);