Quick question about c# custom events and how they work exactly

Here's an example of using the Action delegate Type for event notification:

using System;
using System.Collections.Generic;

namespace PersonCollectionDemo
{
    public enum TransactionType
    {
        ClearAndReset,
        Deposit,
        Withdraw
    }

    // Person
    public class Person
    {
        // expose only ability to 'read
        public string Name { private set; get; }
        public decimal Cash { private set; get; }

        public Person
        (
            string name, decimal initialCash
        )
        {
            Name = name;
            Cash = initialCash;
        }

        public void SetCash(decimal amount)
        {
            // consider throwing an error if amount is negative ?
            if (amount == Cash || amount < 0) return;

            Cash = amount;

            Persons.CashChangedMethod(this, TransactionType.ClearAndReset, amount, Cash);
        }

        public void AddCash(decimal amount)
        {
            // amount must be positive
            // consider throwing an error if negative ?
            if (amount <= 0) return;

            Cash += amount;

            Persons.CashChangedMethod(this, TransactionType.Deposit, amount, Cash);
        }

        public void WithDrawCash(decimal amount)
        {
            // amount must be negative
            // consider throwing an error if positive ?
            if (amount >= 0) return;

            // detect and handle overdraft
            if (Cash + amount < 0)
            {
                Persons.OverDraftAlertMethod(this, TransactionType.Withdraw, amount, Cash);
                return;
            }

            Cash += amount;

            Persons.CashChangedMethod(this, TransactionType.Withdraw, amount, Cash);        
        }
    }

    // Collection of Person
    public class Persons : List<Person>
    {
        public static Action<Person,> CashChangedMethod { private set; get; }

        public static Action<Person,> OverDraftAlertMethod { private set; get; }

        public Persons
        (
            Action<Person,> cashChangedMethod,
            Action<Person,> overDraftAlertMethod
        )
        {
            if(CashChangedMethod == null) CashChangedMethod = cashChangedMethod;
            if(OverDraftAlertMethod == null) OverDraftAlertMethod = overDraftAlertMethod;
        }

        public void Add(string name, decimal initialcash)
        {
            Person newPerson = new Person(name, initialcash);
            this.Add(newPerson);
        }
    }
}

Sample test:

using PersonCollectionDemo;

private void TestPersonDemo
{
    Persons ThePersons = new Persons(CashChangedMethod, OverDraftAlertMethod);
    
    ThePersons.Add("Person1", 100.23M);
    ThePersons[0].SetCash(245.35M);
    ThePersons.Add("Person2", 499.00M);
    
    ThePersons[0].AddCash(23.35M);
    ThePersons[1].WithDrawCash(-500.00M);
}

// EventHandlers invoked from Person class
private void OverDraftAlertMethod(Person person, TransactionType transactionType, decimal amount, decimal balance)
{
    Console.WriteLine("Account Action: Withdrawal Rejected: Account Name: {0} | Transaction Type: {1} | Withdraw Amount: {2} | Balance: {3}", person.Name, transactionType, amount, balance);
}

private void CashChangedMethod(Person person, TransactionType transactionType, decimal amount, decimal balance)
{
    Console.WriteLine("Account Action: Account Name: {0} | Transaction Type: {1} | Amount: {2} | Balance: {3}", person.Name, transactionType, amount, balance);
}

Test output to Console:

Account Action: Account Name: Person1 | Transaction Type: ClearAndReset | Amount: 245.35 | Balance: 245.35

Account Action: Account Name: Person1 | Transaction Type: Deposit | Amount: 23.35 | Balance: 268.70

Account Action: Withdrawal Rejected: Account Name: Person2 | Transaction Type: Withdraw | Withdraw Amount: -500.00 | Balance: 499.00

Notes:

1. some care is taken in this example to make the instances of the Action Delegates used (they are declared as 'static Properties) only accessible (can be set) the first time the constructor of the Persons class is called.

The reason for this is to prevent any code outside the Class from adding additional EventHandlers to those Action Delegates.

To start with, those are not events. And this is not how events and work and not how event data is passed. Please see my comments to the question.

I would quickly send you to the reading of standard documentation on events. You need to learn this topic anyway. But you also need to do something which is not properly explained in MSDN, because this "something" is not formally required, be is a part of some conventions for the cultured code. Perhaps it would be better to show you some code sample.

First of all, event data should be passed using the class derived from System.EventArgs. This is not required formally but is required as the good style convention; in return, .NET give you valuable support by its .NET BCL types. Do this:

class Person { /* ... */ }

public class MyEventArgs : System.EventArgs {
     internal MyEventArgs(Person person) { this.Person = person; } // not public!
     public Person Person { get; private set; } // private is important
}

Now, let's add the class declaring an event instance. It can be your Person, but it's better to show more general case when this is a different class. First of all, if you used a "regular" delegate instance, not event instance, your delegate type matching the event delegate type could be based on the System.Action declaration. It could be

System.Action<object, MyEventArgs> myDelegateInstance;

But! This convention is not applied to "regular delegate instances", but only to delegate instances. But for delegate instances, .NET BCL gives you more , different support, so you don't even need this Action declaration. Instead, you should use

public class EventImplementor {
    public event System.EventHandler<MyEventArgs> PersonChanged;
}

Now, the problem is: where to invoke the event? The trick is: it is only allowed to be done in the same class; any other code won't compile. This is a very important .NET fool-proof feature.
So, you would need to add:

public class EventImplementor {
    
    public event System.EventHandler<MyEventArgs> PersonChanged;
    
    // private, by default, but could be, say, protected, to grant access
    // to derived classes:
    void InvokePersonChanged() {
        if (PersonChanged != null) // important!
            PersonChanged.Invoke(this, new MyEventArgs(this.person));
    }

    // now you can called it whenever something changes the person;
    // for example, it could be done by public/internal setter (!)
    // of the property:
    Person Person {
        get { return this.person; }
        set {
            if (value == this.person) return;
            this.person = value;
            InvokePersonChanged();
        }
    }
    
    Person person;

}

Not it's time to address your OnSomethingChanged. The convention is: if you have the property Person, the method named like OnPersonChanged 1) should be virtual, 2) only protected, 3) should invoke PersonChanged:

public class EventImplementor {
    
    public event System.EventHandler<MyEventArgs> PersonChanged;
    
    // private, by default, but could be, say, protected, to grant access
    // to derived classes:
    protected virtual void OnPersonChanged() {
        if (PersonChanged != null) // important!
            PersonChanged.Invoke(this, new MyEventArgs(this.person));
    }

    // ...

}

Why? By a very serious reason. It give some extra flexibility for handling the change of the person. First way won't use the event, but will not allow for event multi-casting. It's faster:

class MyDerivedClass : EventImplementor {
    protected override void OnPersonChanged() {
        // do something when person changed
        // note that you can ignore event, then it won't multi-cast
    } //protected override void OnPersonChanged()
}

Another way is handling the event; as I made event public (could be internal), it can be done in any place of code, even in a different assembly:

EventImplementor implementor = new EventImplementor();
implementor.PersonChanged += (sender, eventArgs) => {
    // this is also based on convention:
    // the declaring class member send "this" as sender:
    EventImplementor implementorSender = (EventImplementor)sender;
    // but for static event instances, it should be null
    Person person = eventArgs.Person; // this was the whole purpose
    // of the event argument class
};

Are you getting the idea?

[EDIT #1]

I apparently pretty much ignore the fact that you are changing some hash, not person. This if, first of all, because I wanted to make my tutorial as simple as possible. The difference is very little. Instead of having MyEventArgs.Person, you could have two: one property for person, another for hash object. Also, you should rather add more events, such as PersonAdding, PersonAdded, PersonRemoving, PersonRemoved. If this is not clear, please ask me the question.

[EDIT #2]

Some weird members of this site don't accept anonymous methods. I think this is a big mistake, but for completeness:

static void PersonHandler(object sender, MyEventArgs eventArg) { /* ... */ }

//...

implementor.PersonChanged += PersonHandler; // no need in "new" 

For C#.v2, type inference cannot be used even for the anonymous. You would need:

implementor.PersonChanged += delegate(object sender, MyEventArgs) => {
    // ...
}

Several handlers can be added to the invocation list of each event handler; they all will be invoked through one invocation call.

—SA