Question

At the moment I am in the process of building a custom button handler (I needed to integrate the kinect into the button system which also used a mouse) then I got to a horrible thing called Event Handling.. at least an hour yelling at my pc :P. I was wondering, before I go and spend a while changing my system to allow for my new want, which is to have multiple events per handler, I was wondering, is the way I'm going to try work (I would just try, but I'm getting off for the night, so my hope is that I can save some time when I boot the computer up tomorrow and not attempt if my system isn't designed for it)

Also, ive seen a getInvoc list or somthing like that before when I was coding.. Would I add multiple delegates onto it then get that list and itterate over it?

On previous examples I had seen where people used:

public event EventHandler myEventHandler;

I had to use:

private Dictionary<BtnEvent, Delegate> m_events;

and then they did the following to add a handler (their way, not mine):

myObj.myEventHandler += delegate(object sender, EventArgs ea)
{
     //do stuff on event
};

first.. If they ran this twice, once with funcA and second with funcb would it run both? or just one?

second, if I applied that logic of += to a Delegate would it work? (I had to use Delegate as I was storing the handlers inside of a dictionary, this allowed for logical access to handlers through use of an enum)

(my code)

private Dictionary<BtnEvent, Delegate> m_events;

//....

m_events = new Dictionary<BtnEvent, Delegate>(6);
m_events.Add(BtnEvent.CLICK_ENTER,  null);
m_events.Add(BtnEvent.CLICK_LEAVE,  null);
m_events.Add(BtnEvent.CLICK_STAY,   null);
m_events.Add(BtnEvent.HOVER_ENTER,  null);
m_events.Add(BtnEvent.HOVER_LEAVE,  null);
m_events.Add(BtnEvent.HOVER_STAY,   null);

//....

public bool addHandle(BtnEvent stateToGet, Delegate function)
{
    bool success = false;

    if(m_events.ContainsKey(stateToGet))
    {
        m_events[stateToGet] = function;
    }

    return(success);
}

// CHANGE ABOVE TO:

public bool addHandle(BtnEvent stateToGet, Delegate function)
{
    bool success = false;

    if(m_events.ContainsKey(stateToGet))
    {
        m_events[stateToGet] += function;
    }

    return(success);
}

Will changing m_events[stateToGet] = function; to m_events[stateToGet] += function; allow me to have multiple event handles (functions I passed to addHandle) be called through the following code?

private void ExecuteEvent(BtnEvent currEvent)
{
    if(m_events.ContainsKey(currEvent))
    {
        if(m_events[currEvent] != null)
        {
           m_events[currEvent].DynamicInvoke(null);
        }
    }
}

Answer 1

Please see below code which answers your first question:

public partial class Form1 : Form
    {    
        public Form1()
        {
            InitializeComponent();
            this.Load += new EventHandler(Form1_Load);
        }

        void Form1_Load(object sender, EventArgs e)
        {
            funcA();
            funcB();
        }

        private void funcA()
        {
            button1.Click += new EventHandler(button1_Click);
        }

        private void funcB()
        {
            button1.Click += new EventHandler(button1_Click);
        }

        void button1_Click(object sender, EventArgs e)
        {
            MessageBox.Show("I am in event handler");
        }

    }

On clicking the Button, “I am in event handler” message is shown twice which means += operator works in similar way with delegates as it works with integers or strings. It simply adds the function handler to the queue and upon execution of events, calls all the function pointers in queue.

Regarding your second question, I think you wont achieve the expected behavior by changing = to +=. What I understand from your statement is that, you wish to execute multiple events handlers like CLICK_ENTER, CLICK_LEAVE on calling ExecuteEvent() function. However, since you are storing event handlers and their delegates in a Dictionary, changing = to += will only work in the same way as illustrated in above code.