具有强类型对象的事件回调

Question

I'm trying to get a proof of concept down for a feature I need in my code. In the real application, I have a Dependency Injection container, and children sometimes need to 'new up' an object, and I need the DI container to return that object. So I'm using an event with a callback that lets the child get that instatiated object.

The problem is, I'd like one event, but allow it to return whichever object the caller specifies. I'm not sure how to get that strongly typed object back (without casting). I feel like it should be possible. If that's confusing enough, here's my example:

class Program
{
    public static event EventHandler<MyEventArgs> MyEvent;
    public static void Main()
    {
        MyEvent += (sender, args) =>
        {
            Console.WriteLine("Event Fired");
            args.Callback("hello");
        };


        MyEvent(null, new MyEventArgs(obj => Console.WriteLine($"How do I get {obj} strongly typed")));

        Console.Read();
    }
}

and the event args:

public class MyEventArgs
{
    public Action<object> Callback { get; set; }

    public MyEventArgs(Action<object> callback)
    {
        Callback = callback;
    }
}

I'm stuck, because MyEventArgs can't take a type parameter, as I would really like just one event to handle any return object type. Is it possible to get a strongly typed object through the callback?

Again, I could send the Type through as a parameter, and cast it, but I feel like this should be do-able. It's entirely possible that this is impossible, too.

Thanks for any guidance.

Answer 1

You probably would like to take a look at dynamic types .

public class MyEventArgs 
{
    public Action<dynamic> Callback { get; set; }

    public MyEventArgs(Action<dynamic> callback)
    {
        Callback = callback;
    }
}

It will allow you to pass any type to callback.

Answer 2

I worked out a solution that is almost exactly what I was going for:

public class MyEventArgs<T> : MyEventArgs where T : class
{
    private Action<T> _callback;
    public MyEventArgs(Action<T> callback)
    {
        _callback = callback;
    }

    public override void DoCallback(object item)
    {
        _callback(item as T);
    }
}

public abstract class MyEventArgs
{
    public abstract void DoCallback(object item);
}

and in my Main:

public static event EventHandler<MyEventArgs> MyEvent;
public static void Main()
{
    MyEvent += (sender, args) =>
    {
        Console.WriteLine("Event Fired");
        args.DoCallback("hello");
    };

    MyEvent(null, new MyEventArgs<string>(s => Console.WriteLine($"{s} is a string")));

 Console.Read();
}

All it's missing is DoCallback()'s parameter is not strongly typed. But it's exremely close to what I wanted.