Need an OOP Trick

Question

I want an abstract class that raises an event, this event will be raised by the concrete class.

What I want is when I use another class to listen to these events the signature of the delegate should have the concrete type not the abstract, I don't want to cast it.

For the moment I have come up with this solution. It works but I don't find it particularly clever especially because of the "STUPID, DOESN'T MAKE SENSE......" part.

Here is my solution :

public delegate void ClassAEventHandler<TClassA>(TClassA classA) where TClassA : ClassA;

//Abstract class that raise Event
public abstract class ClassA<TClassA> : where TClassA : ClassA
{
    public event ClassAEventHandler<TClassA> onClassEventRaised;    
    private TClassA eventClassA;

    public void registerEventClass(TClassA classA)
    {
        this.eventClassA = classA;
    }

    public void raiseClassEvent()
    {
        this.onClassEventRaised(this.eventClassA);
    }
}

// Exemple of concrete type
public class ClassB : ClassA<ClassB> // <------ IT SEEMS DUMB
{
    public void action()
    {
        //Do something then raise event
        this.raiseClassEvent();
    }

    public void saySomething() {};
}

// Exemple of concrete type
public class ClassC : ClassA<ClassC> // <------ IT SEEMS DUMB
{
    public void command()
    {
        //Do something then raise event
        this.raiseClassEvent();
    }

    public void destroySomething() {};
}

//Class that listen to the event raised
public class MyEventListener
{
    private ClassB classB;
    private ClassC classC;

    public MyEventListener()
    {
        this.classB = new ClassB();
        this.classB.registerEventClass(this.classB); // <------ STUPID, DOESN'T MAKE SENSE......
        this.classB.onClassEventRaised += classB_onClassEventRaised;

        this.classC = new ClassC();
        this.classC.registerEventClass(this.classC); // <------ STUPID, DOESN'T MAKE SENSE......
        this.classC.onClassEventRaised += classC_onClassEventRaised;
    }

    public void classB_onClassEventRaised(ClassB classB)
    {
        classB.saySomething();
    }

    public void classC_onClassEventRaised(ClassC classC)
    {
        classC.destroySomething();
    }

    //What i don't want
    /*
    public void classB_onClassEventRaised(ClassA classA)
    {
        ((classB)classA).saySomething();
    }   
    */
}

Answer 1

First of all, you're not following regular event design in .NET.

Instead of implementing your own delegate, use EventHandler<TArgs>, and create a derived class of EventArgs.

Your CustomEventArgs should have a T generic parameter:

public class CustomEventArgs<T> where T : A
{
     private readonly T _instance;

     public CustomEventArgs(T instance)
     {
          _instance = instance;
     }

     public T Instance { get { return _instance; } }
}

Also, don't implement a custom way of registering events. If you want to encapsulate how handlers are added to the event, you need to use event accessors.

Finally, you could implement your classes as follows:

public class A<T> where T : A
{
     private event EventHandler<CustomEventArgs<T>> _someEvent;

     // An event accessor acts like the event but it can't be used
     // to raise the event itself. It's just an accessor like an special
     // event-oriented property (get/set)
     public event EventHandler<CustomEventArgs<T>> SomeEvent
     {
          add { _someEvent += value; }
          remove { _someEvent -= value; }
     }

     protected virtual void RaiseSomeEvent(CustomEventArgs<T> args)
     {
           // If C# >= 6
           _someEvent?.Invoke(this, args);

           // Or in C# < 6
           // if(_someEvent != null) _someEvent(this, args);
     }
}


public class B : A<B> 
{ 
      public void DoStuff()
      {
           // It's just about raising the event accessing the whole
           // protected method and give an instance of CustomEventArgs<B> 
           // passing current instance (i.e. this) to CustomEventArgs<T>
           // constructor.
           RaiseSomeEvent(new CustomEventArgs<B>(this));
      }
}

Now, if you try to handle SomeEvent, you'll get the CustomEventArgs<B> typed as B instead of A:

B b = new B();
b.SomeEvent += (sender, args) =>
{
    // args.Instance is B
    B instance = args.Instance;
};
b.DoStuff(); // Raises SomeEvent internally