铸造MyClass <T> 到MyClass <object> C＃

Question

I have been having some trouble implementing an EventHandler in C# I can't seem to cast Action<T> to Action<object> for storage in a list.

private readonly IList<Action<object>> listeners;

public EventHandler() {
    listeners = new List<Action<object>>();
}

public void RegisterListener<T>(Action<T> listener) where T : class {
        Listeners.Add((Action<object>)listener);
    }

private void ReciveEvent(object evt) {
       if (evt != null)
            Listeners.Where(l => l.GetGeneric(0).
            IsAssignableFrom(evt.GetType())).
            AsParallel().ForAll(l => l(evt));
     }

I just get a cast exception:

Unable to cast object of type 'System.Action`1[Events.SendTestEvent]' to type 'System.Action`1[System.Object]'.

Events.SendTestEvent <- My current test object... it is just a class with a single property and no parent(besides obj)

Answer 1

An Action<object> is a method that can accept anything as it's parameter. An Action<T> is an object that can accept only an object of type T as its parameter. If you could treat an Action<T> as an Action<object> then you could pass an object that isn't of type T , but that action can't accept objects that aren't of type T , so the compiler prohibits you from doing this.

Answer 2

What you're trying to do is cast an Action<T> into an Action<object> , which isn't possible. You can make a new Action that triggers the action passed by the method and insert that into your list like this:

public void RegisterListener<T>(Action<T> listener) where T : class 
{
    Action<object> wrappingAction = (arg)=>
    {
       var castArg = arg as T;
       if(castArg != null)
       {
           listener(castArg);
       }
    };

    Listeners.Add(wrappingAction);    
}

Note: This will only trigger the listeners if the object can be cast to the accepted parameter type, however, this is fairly inefficient (as you'd be casting for each listener listening for that type)

Answer 3

You can't do this because it wouldn't be safe. It would allow you to do

RegisterListener<string>(s => { Console.WriteLine(s); });
Action<object> a = listeners[0];
a(3);

You could wrap the given handler in one which casts to the target type on invocation eg

public void RegisterListener<T>(Action<T> listener) where T : class {
    Listeners.Add(o => { listener((T)o); });
}