using System;

using System.Threading.Tasks;

using System.Linq;

using System.Linq.Expressions;

using System.Reflection;

using System.Collections.Generic;

​

public class Program

{

    public static void Main()

    {

        new MyClass();  

    }

}

​

public class HandlerAttribute : Attribute { }

​

public class SomeType1 { }

public class SomeType2 { }

​

public class Base

{

    protected void Register<T>(Action<T> action)

    {

        Console.WriteLine($"Registering {action}"); 

        action(default(T));

    }

}

​

public sealed class MyClass : Base

{

    public MyClass()

    {      

        Ext.RegisterHandlers(this);

    }

​

    [Handler]

    private void Handle(SomeType1 t) => Console.WriteLine("Invoking Handle(SomeType1)");

    [Handler]

    private void Handle(SomeType2 t) => Console.WriteLine("Invoking Handle(SomeType2)");

}

​

public static class Ext

{

    private static class Cache<T> where T : Base

    {

        public static readonly Action<T> Instance = CreateInstance();

        private static Action<T> CreateInstance()

        {

            var methods = typeof(T).GetMethods(BindingFlags.NonPublic | BindingFlags.Instance).Where(x => x.GetCustomAttribute<HandlerAttribute>() != null);

            var registerMethod = typeof(Base).GetMethod("Register", BindingFlags.NonPublic | BindingFlags.Instance);

​

            var instanceParameter = Expression.Parameter(typeof(T));

​

            var blockItems = new List<Expression>();

            foreach (var method in methods)

            {

                if (method.IsGenericMethod || method.GetParameters().Length != 1 || method.ReturnType != typeof(void))

                    throw new Exception($"Invalid method signature for method {method}");

​

                // The type of the Handle method's parameter (e.g. SomeType1 or SomeType2)

                var parameterType = method.GetParameters()[0].ParameterType;

​

                // MethodInfo for e.g. the Register<SomeType1> method

                var typedRegisterMethod = registerMethod.MakeGenericMethod(parameterType);

​

                // The type of delegate we'll pass to Register, e.g. Actino<SomeType1>

                var delegateType = typeof(Action<>).MakeGenericType(parameterType);

​

                // Construct the x => Handle(x) delegate

                var delegateParameter = Expression.Parameter(parameterType);

                var delegateConstruction = Expression.Lambda(delegateType, Expression.Call(instanceParameter, method, delegateParameter), delegateParameter);

​

                // Construct the Register(delegate) call

                var methodCall = Expression.Call(instanceParameter, typedRegisterMethod, new[] { delegateConstruction });

​

                // Add this to the list of expressions we'll put in our block

                blockItems.Add(methodCall);

            }

​

            var compiled = Expression.Lambda<Action<T>>(Expression.Block(blockItems), instanceParameter).Compile();

            return compiled;

        }

    }

    public static void RegisterHandlers<T>(T t) where T : Base

    {

        Cache<T>.Instance(t);

    }

}