如何将对象转换为自己的类型？

Question

I've read several posts on this problem but none of the answers seem to work for me. Here is the situation--I have a generic function to call in another class:

public class Dispatcher<T> where T : Event {
    public void Notify<X>(X tEvent) where X : Event {
        if (someField is IListener<X, T>) {
             //this never executes--X is Event regardless of its derived type
        }
    }
}

and the calling code:

public class Effect {
    public Event myEvent;

    public CallNotify() {
        Dispatcher.Notify(myEvent);
    }
}

The problem is that Event has dozens of derived types, and I need the Notify() call to happen with the derived type as X. So far, it just calls Notify< Event >() no matter what kind of Event I pass in. The only solution that compiles is to call Notify(myEvent as DerivedEvent), but that has to be hardcoded for every single type--not acceptable.

A similar function infers properly if I give it a "this" pointer from an instance of the derived class.

Surely there's a solution using Reflection here.

Answer 1

You've got two issues.

First, your generics are leaking. Whenever you need to determine what type a particular instance is, your function is no longer generic. Consider your design flawed and re-examine what you are trying to do.

Second, IListener<X,Y> is not a type. Generics aren't generic in .NET; the runtime determines all actual types your application will require and creates them. The runtim will create, for example, a type IListener<int,string> if you actually use that in your application.

var foo = new List<int>();
var bar = foo.GetType() == typeof(List<>);

In this examle, bar is false .

Even with all this, yes, it is possible. You just have to understand how reflection with generic type definitions works. This is a pretty good link at MSDN that explains how it works.

I would strongly suggest that you reconsider using generics in this manner. Sometimes abstraction ad absurdum isn't the best thing...

Answer 2

In order to call it as you seem to expect you would have to use reflection to generate a method of the actual type of myEvent. But I would stress that doing the following is a BAD idea and probably means your design needs to be rethought out.

MethodInfo openGenericMethod = OtherClass.GetType().GetMethod("Notify");
MethodInfo closedGenericMethod = openGenericMethod.MakeGenericMethod(myEvent.GetType());

closedGenericMethod.Invoke(OtherClass, new object[]{ myEvent });, 

I didn't actually test the above code, but it would look something like that

Answer 3

Could you just drop the constraint and check to make sure it derives from Event , like this:

public class Dispatcher<T> where T : Event {
    public void Notify<X>(X tEvent) {
        if(typeof(tEvent).IsSubclassOf(typeof(Event))
        {
            if (someField is IListener<X, T>) {
                //this never executes--X is Event regardless of its derived type
            }
        }
    }
}

Answer 4

So I seem to have figured out a workaround on the other end. Instead of

public class Dispatcher<T> where T : Event {
    public void Notify<X>(X tEvent) where X : Event {
        foreach (Object l in listeners) {
            if (l is IListener<X, T>) { //never true
                (l as IListener<X, T>).OnEvent();
            }
        }
    }
}

I have this mishmash:

public class Dispatcher<T> where T : Event {
    public void Notify<X>(X tEvent) where X : Event {
        foreach (Object l in listeners) {
            foreach (Type t in l.GetType().GetInterfaces()) {
                Type[] temp = t.GetGenericArguments();
                if (temp.Count() > 0 && temp[0] == tEvent.GetType()) {
                    MethodInfo mi = t.GetMethod("OnEvent", new Type[] {tEvent.GetType()});
                    mi.Invoke(l, new object[] { tEvent });
                }
            }
        }
    }
}

This seems to work although I don't like having to test every interface (Windows Forms have at least 10 interfaces). I'm going to try the solution from BrandonAGr