Can C# generics have a specific base type?

Question

Is it possible for a generic interface's type to be based on a specific parent class?

For example:

public interface IGenericFace<T : BaseClass>
{
}

Obviously the above code doesn't work but if it did, what I'm trying to tell the compiler is that T must be a sub-class of BaseClass. Can that be done, are there plans for it, etc.?

I think it would be useful in terms of a specific project, making sure a generic interface/class isn't used with unintended type(s) at compile time. Or also to sort of self-document: show what kind of type is intended.

Answer 1

public interface IGenericFace<T> where T : SomeBaseClass

Answer 2

yes.

public interface IGenericFace<T>
    where T : BaseClass
{
}

Answer 3

More info on Generic Interfaces: http://msdn.microsoft.com/en-us/library/kwtft8ak(VS.80).aspx

Answer 4

What your are referring to is called "Generic Constraints". There are numerous constraints that can be put on a generic type.

Some baseic examples are as follows:

• where T: struct - The type argument must be a value type. Any value type except Nullable -can be specified. See Using Nullable Types (C# Programming Guide) for more information.

• where T : class - The type argument must be a reference type; this applies also to any class, interface, delegate, or array type.

• where T : new() - The type argument must have a public parameterless constructor. When used together with other constraints, the new() constraint must be specified last.

• where T : <base class name> - The type argument must be or derive from the specified base class.

• where T : <interface name> - The type argument must be or implement the specified interface. Multiple interface constraints can be specified. The constraining interface can also be generic.

• where T : U - The type argument supplied for T must be or derive from the argument supplied for U. This is called a naked type constraint.

These can also be linked together like this:

C#

public class TestClass<T> Where T : MyBaseClass, INotifyPropertyChanged, new() { }
public interface IGenericFace<T> where T : SomeBaseClass

VB

Public Class TestClass(Of T As {MyBaseClass, INotifyPropertyChanged, New})
Public Interface IGenericInterface(Of T As SomeBaseClass)