how c# events work behind scenes?

i'm controlling c#, .net 3.5. i know exercise events, announce class, offshoot somewhere else, etc. constructed example:

public category mylist
{
    private list<string> m_strings = new list<string>();
    open eventhandler<eventargs> elementaddedevent;

    open vacant add(string value)
    {
        m_strings.add(value);
        (elementaddedevent != null)
            elementaddedevent(value, eventargs.empty);
    }
}

[testclass]
public category testmylist
{
    private bool m_fired = false;

    [testmethod]
    open vacant testevents()
    {
        mylist tmp = new mylist();
        tmp.elementaddedevent += new eventhandler<eventargs>(fired);
        tmp.add("test");
        assert.istrue(m_fired);
    }

    private vacant fired(object sender, eventargs args)
    {
        m_fired = true;
    }
}

however, i not understand, declares an eventuality handler

public eventhandler<eventargs> elementaddedevent;

it's never initialized - what, exactly, elementaddedevent? does indicate to? following won't work, since eventhandler never initialized:

[testclass]
public category testmylist
{
    private bool m_fired = false;

    [testmethod]
    open vacant testevents()
    {
        eventhandler<eventargs> somethinghappend;
        somethinghappend += new eventhandler<eventargs>(fired);
        somethinghappend(this, eventargs.empty);
        assert.istrue(m_fired);
    }

    private vacant fired(object sender, eventargs args)
    {
        m_fired = true;
    }
}

i notice there an eventhandler.createdelegate(...), nonetheless slight signatures advise wholly used attaching representatives an already existent eventhandler by customary elementaddedevent += new eventhandler(mymethod).

i'm certain what i am perplexing help... nonetheless eventually i'd adult an summary progenitor datacontext linq whose children register list forms wish "observed" i have events such beforeupdate afterupdate, nonetheless specific types. something this:

public category basedatacontext : datacontext
{
    private stationary dictionary<type, dictionary<changeaction, eventhandler>> m_observedtypes = new dictionary<type, dictionary<changeaction, eventhandler>>();

    open stationary vacant observe(type type)
    {
        (m_observedtypes.containskey(type) == false)
        {
            m_observedtypes.add(type, new dictionary<changeaction, eventhandler>());

            eventhandler eventhandler = eventhandler.createdelegate(typeof(eventhandler), null, null) eventhandler;
            m_observedtypes[type].add(changeaction.insert, eventhandler);

            eventhandler = eventhandler.createdelegate(typeof(eventhandler), null, null) eventhandler;
            m_observedtypes[type].add(changeaction.update, eventhandler);

            eventhandler = eventhandler.createdelegate(typeof(eventhandler), null, null) eventhandler;
            m_observedtypes[type].add(changeaction.delete, eventhandler);
        }
    }

    open stationary dictionary<type, dictionary<changeaction, eventhandler>> events
    {
        { relapse m_observedtypes; }
    }
}


public category myclass
{
    open myclass()
    {
        basedatacontext.events[typeof(user)][changeaction.update] += new eventhandler(onuserupdate);
    }

    open vacant onuserupdated(object sender, eventargs args)
    {
        // something
    }
}

thinking finished me comprehend i don't unequivocally know what's duty underneath hod events - i know :)