Question

So here’s what I’m trying to do.

I’m creating a generic class that allocates the type specified by the generic parameter in one of two ways, determined by which overloaded constructor is used.

Here is the example:

class MyClass<T>
    where T : class
{
    public delegate T Allocator();
    public MyClass()
    {
        obj = new T();
    }

    public MyClass( Allocator alloc )
    {
        obj = alloc();
    }

    T obj;
}

This class requires that type T is a reftype in all cases. For the default constructor, we want to instantiate T via its default constructor. I’d like to put a where T : new() on my default constructor, like this:

public MyClass()
    where T : new()
{
    obj = new T();
}

However, this is not valid C#. Basically I only want to add the constraint on type T to have a default constructor only when the default constructor of MyClass() is used.

In the second constructor for MyClass, we let the user determine how to allocate for T with their own allocation method, so obviously it makes sense for MyClass to not enforce T be default constructible in all cases.

I have a feeling that I’ll need to use reflection in the default constructor for this, but I hope not.

I know this can be done because the Lazy<T> class in .NET 4.0 does not require T to be default constructible at the class level, yet it has constructors similar to those in my example. I’d like to know how Lazy<T> does it at least.

Answer 1

You can only include constraints in the declaration where you’re introducing a generic type parameter.

However, you could introduce a generic method on a non-generic type:

public class MyClass
{
    public static MyClass<T> Create<T>() where T : class, new()
    {
        return new MyClass<T>(() => new T());
    }
}

public class MyClass<T> where T : class
{
    T obj;

    public MyClass(Allocator allocator)
    {
        obj = allocator();
    }
}

(I’d personally just use Func<T> instead of declaring a separate delegate type btw.)

Then you can use:

MyClass<Foo> foo = MyClass.Create<Foo>(); // Enforces the constraint