タイプインスタンスが特定のクラスから割り当て可能なタイプを表していることを確認してください

Question

私は主にJavaプログラマーなので、これは "Javaと同等のものは何ですか？"という質問です。だから、Javaで、あなたはそうのような、特定のスーパークラスを拡張するために、コンパイル時でクラスの型引数を抑制することができます。

public <T extends BaseClass> void foo(Class<T> type) { 
    ... 
} 

とさえ

public <T extends BaseClass> T foo(Class<T> type) { 
    ... 
} 

をあなたも複数のインタフェースをチェーンすることができます：

public <T extends BaseClass & BaseInterface1 & BaseInterface2> void foo(Class<T> type) { 
    ... 
} 

これはどのようにC＃で行われますか？私はあなたが "どこにT：BaseClass"を使うことができるのか知っていますが、これはインスタンスTを持っているときのみ適用できます。

編集：ここでの説明については、

は私がやりたいものです。

ASSEMBLY＃1（のBase.dll）：

abstract class BaseClass { 
    abstract void Foo(); 
} 

ASSEMBLY＃2（sub1.dll、参照用のBase.dll）：

class SubClass1 : BaseClass { 
    void Foo() { 
     // some code 
    } 
} 

ASSEMBLY＃3（sub2.dll、参照はのBase.dll）：

class SubClass2 : BaseClass { 
    void Foo() { 
     // some other code 
    } 
} 

ASSEMBLY＃4（MAIN.DLL、参照はのBase.dll）：

class BaseClassUtil { 
    static void CallFoo(Type<T> type) where T : BaseClass { 
     T instance = (T)Activator.CreateInstance(type); 
     instance.Foo(); 
    } 
} 

public static void Main(String[] args) { 
    // Here I use 'args' to get a class type, 
    // possibly loading it dynamically from a DLL 

    Type<? : BaseClass> type = LoadFromDll(args); // Loaded from DLL 

    BaseClassUtil.CallFoo(type); 
} 

ので、この例では、私は 'タイプ' 変数が何を表すか、クラスを気にしない限り、それはBaseClassから派生しているので、インスタンスを作成するとFoo（）を呼び出すことができます。

C＃コード（Javaモックアップではない）は、「ジェネリック」タイプクラスです：タイプ< T>タイプ<？ ：BaseClass>。

Answer 1

んで起こるはずである、Typeはジェネリック型に代入可能で、コンパイル時に強制する方法はありません。私が正しく理解していれば、何が欲しいのです：

void Foo<T>(Type type) { ... } //compile time error if an instace typed `type` is not assignable to `T`. 

を意味し、どの：

void Foo<IFormattable>(typeof(string)); //ok 
void Foo<IDisposable>(typeof(string)); //compile time error 

は明らかに、実行時にそれがtrivalですが、言語はコンパイル時に、このをサポートしていません。

Answer 2

私はあなたがここでは別の記事についてgeneric type constraint

public void Foo<T>(Type type) where T:BaseClass, BaseInterface1, BaseInterface2 
{ 
    //your code 
} 

を話している理解し何から：Constraints on Type Parameters (C# Programming Guide)

When you define a generic class, you can apply restrictions to the kinds of types that client code can use for type arguments when it instantiates your class. If client code tries to instantiate your class by using a type that is not allowed by a constraint, the result is a compile-time error.

EDIT：

ここではあなたの例を。ここでBaseClassUtil.CallFoo<T>をBaseClassとその派生クラスと異なるものにコールしようとすると、コンパイルエラーが発生します。ここにfull example in dotNetFiddle。だから、トリッキーな部分は、あなたのクラスの制限はUtilのクラス

public static void Main(string[] args) 
    { 
     //so your LoadFromDll method should return Type. Type doesn't have generic implementation ! 
     Type type = typeof(SubClass1); 

     BaseClassUtil.CallFoo<BaseClass>(type); 

     Type type2 = typeof(SubClass2); 
     //you can write BaseClassUtil.CallFoo<SubClass2>(type2); if you want 
     BaseClassUtil.CallFoo<BaseClass>(type2); 
    } 

    public class BaseClassUtil 
    { 
     public static void CallFoo<T>(Type type) where T : BaseClass 
     { 
      T instance = (T)Activator.CreateInstance(type); 
      instance.Foo(); 
     } 
    } 
    public class TestClass 
    { 
     public int ID { get; set; } 

    } 

    public abstract class BaseClass 
    { 
     public abstract void Foo(); 
    } 

    public class SubClass1 : BaseClass 
    { 
     public override void Foo() 
     { 
      Console.WriteLine("SubClass 1"); 
     } 
    } 

    public class SubClass2 : BaseClass 
    { 
     public override void Foo() 
     { 
      Console.WriteLine("SubClass 2"); 
     } 

    }