Question

This is abit difficult to word, so I am going to rely mostly on code.

BTW if you can word the question in a better light please dont hesitate giving your 2c!

class CustomEventArgs : EventArgs
{
    public delegate void CustomEventHandler( Object sender, CustomEventArgs args );

    public int data;

    public CustomEventArgs (int _data)
    {
        data = _data;
    }
}

This is the event that we will be using in this example.

class EventGenerator
{
    public event CustomEventArgs.CustomEventHandler WeOccasion;

    public EventGenerator ()
    {
        Task.Factory.StartNew( () =>
            {
                var index = 1;

                // just loop and generate events every now and then
                while (true)
                {   
                    Thread.Sleep( 1000 );
                    WeOccasion( this, new CustomEventArgs (++index));
                }
            });
    }
}

This class just loops through firing off CustomEventHandler events.

class EventActivity
{
    // EventActivity has an event of the same type as EventGenerator's 
    public event CustomEventArgs.CustomEventHandler WeOccasion;

    // this is the part I cant seem to get right
    public event CustomEventArgs.CustomEventHandler Source ( get; set; }

    public bool Active {
        set
        {
            if (value)
            {
                Source += DoWork;
            }
            else
            {
                Source -= DoWork;
            }
        }
    }

    private void DoWork( Object sender, CustomEventArgs frame);
}

Here is where I really need help. I want almost a pointer to an event in an another class of type CustomEventHandler that I can later assign event handlers to when I activate the activity.

Here is a usage example wrapped in a class;

class EventAssigner
{
    EventGenerator Generator;
    EventActivity DoSomeThing1;
    EventActivity DoSomeThing2;

    public EventAssigner ()
    {
        // init
        Generator = new EventGenerator();
        DoSomeThing1 = new EventActivity();
        DoSomeThing2 = new EventActivity();

        // assign sources
        DoSomeThing1.Source = Generator.WeOccasion;
        DoSomeThing2.Source = DoSomeThing1.WeOccasion;

        // activate the first activity
        DoSomeThing1.Active = true;
    }

    public void Activate2()
    {
        // activate the second activity
        DoSomeThing2.Active = true;
    }

    public void Deactivate2()
    {
        // deactivate the second activity
        DoSomeThing2.Active = false;
    }
}

Obiously this code doesnt work, and I suppose thats what I am asking. Can you get this design pattern to work?

Answer 1

What you’re asking to do isn’t really possible with .NET events, and probably isn’t as desirable as you might think. A bit of background should help explain why:

Properties have a basic pattern with get and set operations. These are invoked by accessing the property (for a get) and an assignment to the property (for a set):

var x = instance.Prop1; // access
instance.Prop1 = x; // assignment

When you access an event from outside the class (i.e. instance.Event) you are given the “public” face, which, like properties, has two operations: add handler and remove handler. These are invoked using the += and -= operators.

instance.Event += this.Handler; // add
instance.Event -= this.Handler; // remove

The important thing to notice that it doesn’t have a “get” operation – there is no way to get a reference to the event outside the class; you can only modify the handlers registered.

When you access an event from within a class, you are given the “private” face, which is essentially a special collection of delegates (function pointers) to the registered event handlers. When you invoke the delegate, you’re actually asking the framework to iterate through the registered event handlers and invoke those.

if(this.Event != null)
{
    this.Event.Invoke(e, args); // raise event
}

This separation of public face and private face is what allows you have a nice simple event keyword which magically gives you an event. It is also what stops you passing a reference to the event around.

To pass the event into registration methods, you have to pass the object the event is attached to. If you have multiple classes which implement the same event and you want to register them all in the same way, you should have them implement an interface with the event (yes, events can be on interfaces) and write your method to accept the interface as an argument.