C#: Restricting Types in method parameters (not generic parameters)

You can use the following:

public void Foo<T>(T variable) where T : MyClass
{ ... }

The call would be like the following:

{
    ...
    Foo(someInstanceOfMyClass);
    ...
}

What you want could theoretically be done with attributes. But this is much clearer (imo) and does exactly the same thing:

public void Foo(MyClass m) {
   Type t = m.GetType();
   // ...
}

Specifying the type be MyClass, or derived from it, is a value check on the argument itself. It's like saying the hello parameter in

void Foo(int hello) {...}

must be between 10 and 100. It's not possible to check at compile time.

You must use generics or check the type at run time, just like any other parameter value check.

If your method has to take a Type type as it's argument, there's no way to do this. If you have flexibility with the method call you could do:

public void Foo(MyClass myClass)

and the get the Type by calling .GetType().

To expand a little. System.Type is the type of the argument, so there's no way to further specify what should be passed. Just as a method that takes an integer between 1 and 10, must take an int and then do runtime checking that the limits were properly adhered to.