Why I can’t wait to get dynamic in C#

private static void BuildArgumentProvider(ContainerBuilder builder)
        {
            builder.Register<Provider<MyServiceResolvedAtRuntime, ArgumentTypeResolvedAtRuntime>>(
                ctx => argument
                       => ctx.Resolve<MyServiceResolvedAtRuntime>(new[] { new NamedPropertyParameter("param", argument) }))
                .As<Provider<MyServiceResolvedAtRuntime, ArgumentTypeResolvedAtRuntime>>();
        }

public AttributeBasedModule{
/** snip **/
        private static void BuildArgumentProvider(ConstructorInfo info, Type descriptor, ContainerBuilder builder)
        {
            /** snip **/
            ParameterInfo info = /** snip **/
            var typeToRegister = typeof(Provider<,>).MakeGenericType(new[] { descriptor, argument.ParameterType });
            builder.Register<object>(ctx => CreateCreationArgsResolver(typeToRegister,ctx, descriptor,argument))
                .As(typeToRegister);

        }

        static Delegate CreateCreationArgsResolver(Type typeToRegister,IContext ctx, Type serviceType,ParameterInfo argument)
        {
            var ctxKeeper = ContextKeeper.CreateGeneric(ctx,
                (creationContext, arg)
                    => creationContext.Resolve(serviceType,new Parameter[]{new NamedParameter(argument.Name,arg)})
                    ,serviceType, argument.ParameterType);

            return Delegate.CreateDelegate(typeToRegister, ctxKeeper, ReflectionInvokedMethodName);
        }

        /// <summary>
        /// Build the generic version to allow the binding to a particular delegate.
        /// </summary>
        static class ContextKeeper
        {
            internal static object CreateGeneric(IContext ctx, Func<IContext, object, object> invoker, Type service, Type parameter)
            {
                var genericType = typeof (ContextKeeper<,>).MakeGenericType(new[] {service, parameter});
                var constructor = genericType.GetConstructor(new[] {typeof (IContext), typeof (Func<IContext, object, object>)});
                return constructor.Invoke(new object[] {ctx,invoker});
            }
        }
        /// <summary>
        /// Keeping the context for the actual invoker. Represent the context-keeping behavior of closures
        /// </summary>
        /// <typeparam name="TService">The service to create</typeparam>
        /// <typeparam name="TArgument">The constructor-argument for the service</typeparam>
        class ContextKeeper<TService,TArgument>
        {
            private readonly IContext ctx;
            private readonly Func<IContext, object, object> invoker;

            public ContextKeeper(IContext ctx, Func<IContext, object, object> invoker)
            {
                this.ctx = ctx;
                this.invoker = invoker;
            }

            /// <summary>
            /// Is invoked by reflection, see <see cref="ReflectionInvokedMethodName"/>
            /// </summary>
            /// <param name="arg"></param>
            /// <returns></returns>
            public TService Invoke(TArgument arg)
            {
                return (TService)invoker.Invoke(ctx, arg);
            }
        }
}