Question

I’m working on a small class library at work, and it naturally involves using generics for this task. But there is this thing that I don’t really understand with generics:
Why would I need to use generic type parameters, and then constrain the the type parameter to a specific base class or interface.

Here’s an example to what I mean:

public class MyGenericClass<T> where T : SomeBaseClass
{
    private T data;
}

And here’s the implementation without generics

public class MyClass
{
    private SomeBaseClass data;
}

Are these two definitions the same (if yes, then i don’t see the advatage of using generics here)?

If not, what do we benefit from using generics here?

Answer 1

As with almost all uses of generics, the benefit comes to the consumer. Constraining the type gives you the same advantages that you get by strongly typing your parameter (or you can do other things like ensure that there’s a public parameterless constructor or ensure that it’s either a value or reference type) while still retaining the niceties of generics for the consumer of your class or function.

Using generics also, for example, allows you to obtain the actual type that was specified, if that’s of any particular value.

This example is a little contrived, but look at this:

public class BaseClass
{
    public void FunctionYouNeed() {}
}

public class Derived : BaseClass
{
    public void OtherFunction() {}
}

public class MyGenericClass<T> where T: BaseClass
{
    public MyGenericClass(T wrappedValue)
    {
        WrappedValue = wrappedValue;
    }

    public T WrappedValue { get; set; }

    public void Foo()
    {
        WrappedValue.FunctionYouNeed();
    }
}

...

var bar = new MyGenericClass<Derived>(new Derived());

bar.Foo();

bar.WrappedValue.OtherFunction();