#2782

An Alternative to the C# Generic new() Constraint

Here’s something I came up with other the weekend while playing with some code…

I wanted to write a method that ensured that some object of type T was always available.

    ModelElement element = EnsureElementExists<ModelElement>(_store);

Unfortunately in this case the ModelElement class does not have a parameterless constructor. This means I can’t use the where T:New() constraint and then just create a new instance in my generic method. What I can do is use a delegate to provide a new instance of the object if I need it:

    public delegate T ConstructorDelegate<T>() where T : class; 

    public static T EnsureElementExists<T>(Store store, ConstructorDelegate<T> ctor) 
        where T : ModelElement 
    { 
        T element = store.GetElement<T>(); 

        if (element == null) 
            element = ctor(); 

        return element; 
    }

This means I can now write code like this where DiagramElement (a class derived from ModelElement) is created by the delegate:

    DiagramElement diagramElement = EnsureElementExists<DiagramElement>(_store, 
        delegate() 
        { 
            return new DiagramElement(_store); 
        });

Calls to EnsureElementExists can use the anonymous delegate to create a new DiagramElement with a parameterized constructor.

March 2009 Update: Cleaner syntax using lambdas

I was playing around with this again recently and realized that  lambda expressions can make the syntax you need to use much simpler and remove the need to define a ConstructorDelegate.

    public static T EnsureElementExists<T>(Store store, Func<T> ctor) 
        where T : ModelElement 
    { 
        T element = store.GetElement<T>(); 

        if (element == null) 
            element = ctor(); 

        return element; 
    }

The calling code is further simplified:

    DiagramElement diagramElement = EnsureElementExists<DiagramElement>(_store, 
        () => new DiagramElement(_store));