对类型的params数组的约束

Question

In the following method:

public void Foo(params Type[] types) {}

How can I constrain the types so that each Type passed in must derive from a certain base class?

I want something along the lines of this:

public void Foo(params Type[] types) where each types : BaseClass {}

---

Clarification:

I want the types of the classes that derive from BaseClass , not the instances of them.

For example if Bar is a subclass of BaseClass , I want to be able to pass in typeof(Bar) , not new Bar() .

Answer 1

If you want to pass an array of Type objects, than you can't do what you want. That's because constraints are part of the type system - you can set a method to get an argument of type int , or a generic method to receive a generic type parameter derived from IDisposable , or whatever, but what you have there is already a specific, concrete type - Type .

Type , confusingly, isn't part of the type system . It's just a regular class that happens to describe the type system metadata . But it's just any old class.

Being able to constrain a method to only accept a Type instance whose BaseClass property is MyBaseClass is just like being able to constrain a method to only accept string arguments whose Length == 3 - it's not a question of type (as C# sees it), but of data inside those types.

Of course, it's not unheard of in other languages to be able to create constrained types - to create a type TLA which is a type of string which must be of length 3 - but that's not how C#'s type system (currently) works.

What you can do is use generic type parameters as a wrapper:

public void Foo<T1, T2, T3>() where T1 : BaseClass, T2:BaseClass, T3:BaseClass
{
   // call untyped Foo.
   Foo(typeof(T1), typeof(T2), typeof(T3));
}

This gives you stronger type safety for some scenarios, but it won't give you the ability to pass an unbounded list of types that a params [] will.

This is conceptually similar to wrapping a method which accepts an object parameter with a typed wrapper method. If your Add(object obj) is confusing, hide it and expose Add(int i) { Add((object)i);} and Add(string s) { Add((object)s);}

Answer 2

The usual 'kind of workaround' here is to check types that are passed to the method and throw an exception if certain type is not what we expect it to be :

public void Foo(params Type[] types)
{  
     EnsureInheritedFrom<BaseClass>(types);

     // ...rest of stuff
}

private void EnsureInheritedFrom<TBaseType>(IEnumerable<Type> types)
{
     var targetType = typeof(TBaseType);
     foreach(Type type in types)
     {
         if(!targetType.IsAssignbableFrom(type))
         {
             throw new ArgumentException(nameof(types), "Type {type.Name} is not supported!");
         }
     }   
}