使用通用C＃接口作为类属性

Question

I have an interface

public interface ICallback<T> 
{
    void OnSuccess (T data);
    void OnFailure (Exception exception);
}

and a class

public class ToDoTask 
{
    private int someInt;

    public string StringProperty {get; set;}

    public ICallback Callback {get; private set;}
}

This doesn't compile because it wants me to specialize the Callback property. I don't want to specialize the property because I don't know the type. The type is determined at runtime through reflection.

Here's a small explanation of what happens:

1. A proxy class is generated (via CreateInterfaceProxyWithoutTarget<C> of Castle DynamicProxy ) at runtime to implement a given interface (Let's call this IModel )
2. A call is made to a method of this proxy class (remember, there's no target so there's no code that executes here aside from what my interceptor does)
3. The method calls are intercepted by a main class that decides what needs to be done based on the attributes on the method and it's parameters (as defined in IModel )
4. At this point, if the last parameter of the intercepted method is an ICallback<T> , it gets assigned to the Callback property, otherwise it's null .
5. If the callback is not null, the operation result is parsed and the appropriate callback method is called.

This is what the Interceptor class looks like:

public class Intercepteur : IInterceptor{
    public void Intercept(IInvocation invocation) {
        ToDoTask task = Study(invocation);

        /* 
           nothing past this point is actually written, 
           so there may be typos or compile errors below
        */

        try 
        {
            var result = Perform(task);

            if (null != task.Callback)
               task.Callback.OnSuccess (MagicalTransformation (result, typeof (T)));
        } catch (Exception e) 
        {
            if (null != task.Callback)
                task.Callback.OnFailure (e);
        }
    }
}

Is it safe to declare the callback as ICallback<object> and cast & return at runtime?

If any of the above sounds stupid, its because I don't have much experience with reflection in C# and I'm diving deep into c# after about 4 years of not touching it. Be nice!

Answer 1

You need to define what T is, or use another option.

The three simplest ways to fix this would be:

Have T defined by ToDoTask<T>

public interface ICallback<T> {
    void OnSuccess (T data);
    void OnFailure (Exception exception);
}

public class ToDoTask<T> {
    private int someInt;

    public string StringProperty {get; set;}

    public ICallback<T> Callback {get; private set;}
}

Define the OnSuccess method as generic, rather than the interface

public interface ICallback
{
    void OnSuccess<T>(T data);
    void OnFailure(Exception exception);
}

public class ToDoTask<T>
{
    private int someInt;

    public string StringProperty { get; set; }

    public ICallback Callback { get; private set; }
}

Use object instead of T

public interface ICallback {
    void OnSuccess (object data);
    void OnFailure (Exception exception);
}

public class ToDoTask {
    private int someInt;

    public string StringProperty {get; set;}

    public ICallback Callback {get; private set;}
}

Answer 2

ICallBack does not exist, it must be ICallBack<T> so you need to provide a type - or make ToDoTask generic and pass the type to ICallBack .

like so:

class ToDoTask<T>{
   ...
   ICallBack<T> CallBack {get;set;}
}

And then pass in the type after reflection or whatever.

A less safer alternative is to use dynamic . Here is a sample program that is trying to do something similar to what you're trying

class Program
{
    interface ICallBack<T>
    {
        void SetObject(T obj);
    }

    class CallBackUser<T>
    {
        public dynamic CB { get; set; }
    }

    class CB<T> : ICallBack<T>
    {
        public void SetObject(T obj)
        {
            Console.WriteLine("Works");
        }
    }

    static Type GetMyTypeThroughReflection()
    {
        return typeof (int);
    }
    static void Main(string[] args)
    {
        Type t = GetMyTypeThroughReflection();
        Type genericClass = typeof(CallBackUser<>);
        Type constructedClass = genericClass.MakeGenericType(t);

        dynamic created = Activator.CreateInstance(constructedClass);
        created.CB = new CB<int>();
        created.CB.SetObject(0);
        Console.ReadKey();
    }
}

Answer 3

Generally, since generics is a compile time feature, you will need to specify the time at compile time.

When you use reflection(runtime), you would prefer working with base types and use polymorphism to accomplish things like this.

I didn't understand by 100% what you wanted to do but you can:

1.Use an ICallback<DeriveType> and work with polymorphism or object in the worst case(be carefull to avoid boxing\\unboxing of value types).

2.Create an non generic interface that will look something like this:

public interface ICallback {
    void OnSuccess (DeriveType data);
    void OnFailure (Exception exception);
}