Using lambdas to create generic factories


One item I find to be limiting in C# is the new generic constraint.  The syntax construct specifies that the type backing a given generic parameter contains a parameter less constructor.   It allows methods to create instances of generic parameters in a type safe manner.

public static void Example<T>() 
    where T : new()
{
    var value = new T();
    Process(value);
}

I find though that I very rarely want this capability.  The object can’t be provided any initial state since you can’t give it any values to the constructor. It’s really only useful if you want to create and then mutate a given object.   

Typically I prefer to deal with immutable data or at least types which build upon other information.  Hence my types tend to have constructors which take at least one piece of information.  In this case the new constraint is of no value because it can’t be used to describe arbitrary constructor signatures but is limited to only a parameter less constructor. 

public static void Example<T>()
    where T : new(string) // Not possible!!!
{
    var value = new T("some data");

}

Originally when I faced this situation I ran to the factory pattern.  I created a nice IFactory<T> interface which had a Create method taking a string, and modified the methods to take this type instead. 

public static void Example<T>(IFactory<T> factory) {
    var value = factory.Create("some data");
}

This works and there is nothing wrong with it.  Except of course it’s an extremely verbose solution.  Every time I want to use the method with a new type I have to create a new type which implements IFactory<MyNewType> just to call this method.   This is very tiresome and gets frustrating very fast with broad object hierarchies. 

Fortunately there is a much lighter weight solution to this problem: lambda expressions.  All we need in this instance is a method which given one or more pieces of input returns a new instance of T.  How this is implemented is of no concern to the method.  This can easily be done via a delegate. 

public static void Example<T>(Func<string, T> createInstance) {
    var value = createInstance("some data");
}

Now the caller can provide the contract with a simple light weight lambda expression

Example(data => new Widget(data));
Comments (4)

  1. Andrew Hare says:

    Very cool – I talked about something similar (togaroga.com/…/two-structural-additions-to-c) but I was more hoping to see the C# team offer us richer generic constraint syntax to allow specific constructor signatures.  This is a very cool workaround though!

  2. this is not so much about lambdas, as it is about "Func", lambdas is just an option you can use

  3. AdamR says:

    If you think you might like library support for generalized type reasoning like this, check out Autofac. nblumhardt.com/…/the-relationship-zoo touches explicitly on this.

  4. Hi Jared!

    Lack of generic constructor with parameters in c# is, in my opinion, a bad pitfall. It does limit  functional programming in c#: using generics and  immutable classes.

    F# doesn't have this kind of problems.

    Also, I feel that some simple syntax for making c# class with a parameterized constructor and (readonly) get- properties would make code lot shorter.

    I hope that in .NET 5.0 c# these things will be fixed. In a Channel 9 video of C# future, the language lead architect, Anders Hejlsberg, said that they will pay some attention to immutability. 🙂

Skip to main content