How to create a Func<> delegate programmatically

Question

I have a small dependency injection framework, and I am trying to make it resolve Lazy<> instances dynamically. The idea is to do something like that:

DIContainer.Register<IDbCommand,SqlCommand>();

var lazyCommand = DIContainer.Resolve<Lazy<IDbCommand>>();

I read the other day that Autofac was able of doing that.

I am stuck trying to set the constructor for that Lazy<> instance. In the next test code, a exception is thrown because the desired type constructor is expecting a Func<arg>, but I am passing a Func<Object>:

    static readonly Type _lazyType = typeof(Lazy<>);
    static Object ResolveTest(Type type)
    {
        if (type.IsGenericType && type.GetGenericTypeDefinition() == _lazyType)
        {
            var arg = type.GetGenericArguments()[0];

            return Activator.CreateInstance(_lazyType.MakeGenericType(arg), new Func<Object>(() => ResolveType(arg)));
        }
        else 
            return ResolveType(type);
    }

I am out of ideas about how to create a delegate that fits for the Lazy<> constructor parameter. Any idea?

Cheers.

That is a tricky one, but you should be able to just create any generic type in the same fashion. http://msdn.microsoft.com/en-us/library/b8ytshk6.aspx might help push you in the right direction. — Michael J. Gray, Oct 23 '13 at 15:11

Daniel Hilgarth · Accepted Answer · 2013-10-23T17:40:03.290

4

That's not trivial. One possible solution would be to work with reflection:

Create a generic ResolveType method:

public static T ResolveType<T>()
{
    return (T)ResolveType(typeof(T));
}

Create a delegate that uses this method:

// You probably want to cache this MethodInfo:
var method = typeof(TypeContainingResolveType)
                 .GetMethods()
                 .Single(x => x.IsGenericMethod && 
                              x.Name == "ResolveType")
                 .MakeGenericMethod(arg);

var delegate = Delegate.CreateDelegate(
                   typeof(Func<>).MakeGenericType(arg),
                   method);

Use that delegate:

return Activator.CreateInstance(_lazyType.MakeGenericType(arg), delegate);

edited Oct 23 '13 at 17:40

answered Oct 23 '13 at 15:25

Daniel Hilgarth

171,043
40
335
443

1

+1 for You Daniel for this good answer. vtortola check this alos very nice @JonSkeet http://stackoverflow.com/questions/773099/generating-delegate-types-dynamically-in-c-sharp/773133#773133 – Bassam Alugili Oct 23 '13 at 15:43
It does not work: "Cannot bind to the target method because its signature or security transparency is not compatible with that of the delegate type." – vtortola Oct 23 '13 at 15:49
@BassamAlugili it is not only create the Func<>, but also the logic that must run in it when invoked. – vtortola Oct 23 '13 at 15:51
@EliArbel: Indeed. Forgot to copy it over from the test project. Fixed – Daniel Hilgarth Oct 23 '13 at 17:40

Tim S. · Answer 2 · 2013-10-23T15:54:04.337

This app outputs "True" and "0". I.e. ResolveTest(typeof(Lazy<int>)) returns a Lazy<int> object, constructed like you wanted.

using System;
using System.Linq.Expressions;

namespace TestApp
{
    public class Class1
    {
        public static void Main()
        {
            object lazyInt = ResolveTest(typeof(Lazy<int>));
            Console.WriteLine(lazyInt.GetType() == typeof(Lazy<int>));
            Console.WriteLine(((Lazy<int>)lazyInt).Value);
        }

        static readonly Type _lazyType = typeof(Lazy<>);
        static Object ResolveTest(Type type)
        {
            if (type.IsGenericType && type.GetGenericTypeDefinition() == _lazyType)
            {
                var arg = type.GetGenericArguments()[0];
                var lazyArgType = _lazyType.MakeGenericType(arg);
                var funcArgType = typeof(Func<>).MakeGenericType(arg);
                var funcCtor = lazyArgType.GetConstructor(new[] { funcArgType });
                Expression<Func<object>> f = () => ResolveTest(arg);
                var func = typeof(Class1).GetMethod("BuildCastedThing").MakeGenericMethod(arg).Invoke(null, new[] { f });
                var arguments = new object[] { func };

                var retVal = funcCtor.Invoke(arguments);
                return retVal;
            }
            else
                return ResolveType(type);
        }
        public static object ResolveType(Type type)
        {
            return Activator.CreateInstance(type);
        }
        public static Func<T> BuildCastedThing<T>(Expression<Func<object>> f)
        {
            Expression<Func<T>> expr =
                Expression.Lambda<Func<T>>(
                    Expression.Convert(
                        Expression.Invoke(f),
                        typeof(T)));

            return expr.Compile();
        }
    }
}

This is a way to rewrite ResolveTest as a generic Resolve<T> (e.g. Resolve<int> returns Lazy<int>). This is a little different, since there's no equivalent to ResolveTest(typeof(int)), which returns an int.

static Lazy<T> Resolve<T>()
{
    var arg = typeof(T);
    return new Lazy<T>(() => (T)ResolveType(arg));
}

Or with a generic ResolveType<T>:

static Lazy<T> Resolve<T>()
{
    return new Lazy<T>(() => ResolveType<T>());
}
public static T ResolveType<T>()
{
    return Activator.CreateInstance<T>();
}

I think there is no need for expressions, but it is interesting. Thanks! — vtortola, Oct 23 '13 at 16:03
@vtortola I couldn't find a better way to cast the return value of `object ResolveType(Type)` to the type. — Tim S., Oct 23 '13 at 16:14

score 1 · Answer 3 · answered Oct 23 '13 at 17:09

public static Object ResolveTest(Type type)
{
    if (type.IsGenericType && type.GetGenericTypeDefinition() == _lazyType)
    {
        var arg = type.GetGenericArguments()[0];

        Expression<Func<object>> expressionWithFuncOfTypeObject = () => ResolveType(arg);
        UnaryExpression expressionThatEvaluatesToAnObjectOfTypeArg = Expression.Convert(expressionWithFuncOfTypeObject.Body, arg);
        LambdaExpression expressionWithFuncOfTypeArg = Expression.Lambda(typeof(Func<>).MakeGenericType(arg), expressionThatEvaluatesToAnObjectOfTypeArg);
        Delegate funcOfTypeArg = expressionWithFuncOfTypeArg.Compile(); // <-- At runtime this will be of type Func<T>

        return Activator.CreateInstance(_lazyType.MakeGenericType(arg), funcOfTypeArg);
    }
    else
        return ResolveType(type);
}

I like how you don't need a static helper method :) – vtortola Oct 24 '13 at 09:57 — vtortola, Oct 24 '13 at 09:57

How to create a Func<> delegate programmatically

3 Answers3

Linked