`System.Type` 如何成为具有约束的通用参数？

Question

System.Type 如何成为具有约束的通用参数？

这里的接口I 有一个方法M，类C 和D 实现。

public interface I {
    void M;
}

public class C: I {
    public void M();
}
public class D: I {
    public void M();
}

Service 实例化一个新的 T()（实际上是 C/D 实现 I）并在其上运行 I 接口方法

public class Service {
    public void Fn<T>(T t): where T : Type, I, new() {
        ( new t() ).M();
        // ...
    }
}

这最终将成为服务的公共 API，因此我希望它尽可能简洁：

public class Main {
    public void main() {
        Service.Fn( typeof( C ));
        Service.Fn( typeof( D ));
        // ...
    }
}

这不是编译，错误是： 'System.Type' must be a non-abstract type with a public parameterless constructor in order to use it as parameter 'T' in the generic type or method ...

这里的最终目标是能够简洁地调用Service.Fn，如Main 中所述。也欢迎我的接口尝试的任何替代方案。

Answer 1

以下代码适用于我：

public class Service {
    public void Fn<T>() where T : I, new() {
        (new T()).M();
        // ...
    }
}
public interface I
{
    void M();
}

public class C : I
{
    public void M();
}
public class D : I
{
    public void M();
}

static void Main()
{
    var service = new Service();
    service.Fn<C>();
    service.Fn<D>();
}

问题在于where 子句中多余的Type。 T 无论如何都是一个类型，因为它是一个通用参数 - 但 A 或 B 类型的对象不能转换为 Type 类 - 这就是 where T : Type 的意思。

一般来说，where T: X, Y, Z 意味着任何T 必须（取决于X、Y 和Z 是什么）要么实现接口，要么是X、@987654337 的子类@ 和 Z。 new() 约束略有不同，它使编译器知道您还希望能够在方法中创建 T 类型的新对象。 （详情请参阅http://msdn.microsoft.com/en-gb/library/bb384067.aspx 和http://msdn.microsoft.com/en-gb/library/d5x73970.aspx）

另外，我已经从您的输入中删除了typeOf()，因为当您使用泛型时，可以在函数中直接引用该类型（见上文）。希望这是有道理的。有任何问题，尽管问！

Answer 2

这个例子可以帮助你理解这里发生了什么：

void PrintTypeName(Type t) { Console.WriteLine(t.Name); }
void PrintTypeName<T>() { Console.WriteLine(typeof(T).Name); }

void Main()
{
    Type cType = typeof(C);
    Type dType = typeof(D);
    C cInstance = new C();
    D dInstance = new D();

    PrintNameOfType(cType.GetType());     //prints "RuntimeType"
    PrintNameOfType(dType.GetType());     //prints "RuntimeType"
    PrintNameOfType(cInstance.GetType()); //prints "C"
    PrintNameOfType(dInstance.GetType()); //prints "D"

    PrintNameOfType(cType);     //prints "C"
    PrintNameOfType(dType);     //prints "D"

    //does not compile:
    //PrintNameOfType(cInstance);
    //PrintNameOfType(dInstance);

    PrintNameOfType<Type>(); //prints "Type"
    PrintNameOfType<C>();    //prints "C"
    PrintNameOfType<D>();    //prints "D"
}

Answer 3

似乎“正确”的实现是摆脱 Type 约束：

public class Service {
    public void Fn<T>(): where T : I, new() {
        ( new T() ).M();
        // ...
    }
}

public class Main {
    public void main() {
        Service.Fn<C>();
        Service.Fn<D>();
        // ...
    }
}

如果你真的，真的想要传入一个类型，那么你将不得不使用反射而不是泛型：

public class Service {
    public void Fn<T>(Type t) {
        I i = Activator.CreateInstance(t) as I;
        if(i != null)
            i.M();
        // ...
    }
}

问题是你不能设置t 是一个也实现I 的类型的编译时约束。