From 34f2e171e88394a033bf108a4f2c44a0eee4b00f Mon Sep 17 00:00:00 2001
From: Thomas Ibel <tibel@users.noreply.github.com>
Date: Thu, 8 Jan 2015 19:31:05 +0100
Subject: [PATCH] add reflection based builders

---
 .../Builders/ExpressionOpenActionBuilder.cs   |  50 ++++-----
 .../Builders/ExpressionOpenFuncBuilder.cs     |  50 ++++-----
 .../ReflectionDynamicDelegateBuilder.cs       |  23 ++++
 .../Builders/ReflectionOpenActionBuilder.cs   |  98 +++++++++++++++++
 .../Builders/ReflectionOpenFuncBuilder.cs     | 104 ++++++++++++++++++
 .../ReflectionPropertyAccessorBuilder.cs      |  34 ++++++
 src/Weakly/Weakly.csproj                      |   4 +
 7 files changed, 313 insertions(+), 50 deletions(-)
 create mode 100644 src/Weakly/Builders/ReflectionDynamicDelegateBuilder.cs
 create mode 100644 src/Weakly/Builders/ReflectionOpenActionBuilder.cs
 create mode 100644 src/Weakly/Builders/ReflectionOpenFuncBuilder.cs
 create mode 100644 src/Weakly/Builders/ReflectionPropertyAccessorBuilder.cs

diff --git a/src/Weakly/Builders/ExpressionOpenActionBuilder.cs b/src/Weakly/Builders/ExpressionOpenActionBuilder.cs
index 9ce981d..82fa434 100644
--- a/src/Weakly/Builders/ExpressionOpenActionBuilder.cs
+++ b/src/Weakly/Builders/ExpressionOpenActionBuilder.cs
@@ -36,11 +36,11 @@ public Action<object> BuildAction(MethodInfo method)
         public Action<object, T> BuildAction<T>(MethodInfo method)
         {
             var instance = Expression.Parameter(typeof(object), "instance");
-            var obj = Expression.Parameter(typeof(T), "obj");
+            var arg0 = Expression.Parameter(typeof(T), "arg0");
 
             var typedInstance = Expression.Convert(instance, method.DeclaringType);
-            var body = Expression.Call(typedInstance, method, obj);
-            return Expression.Lambda<Action<object, T>>(body, instance, obj).Compile();
+            var body = Expression.Call(typedInstance, method, arg0);
+            return Expression.Lambda<Action<object, T>>(body, instance, arg0).Compile();
         }
 
         /// <summary>
@@ -55,12 +55,12 @@ public Action<object, T> BuildAction<T>(MethodInfo method)
         public Action<object, T1, T2> BuildAction<T1, T2>(MethodInfo method)
         {
             var instance = Expression.Parameter(typeof(object), "instance");
-            var arg1 = Expression.Parameter(typeof(T1), "arg1");
-            var arg2 = Expression.Parameter(typeof(T2), "arg2");
+            var arg0 = Expression.Parameter(typeof(T1), "arg0");
+            var arg1 = Expression.Parameter(typeof(T2), "arg1");
 
             var typedInstance = Expression.Convert(instance, method.DeclaringType);
-            var body = Expression.Call(typedInstance, method, arg1, arg2);
-            return Expression.Lambda<Action<object, T1, T2>>(body, instance, arg1, arg2).Compile();
+            var body = Expression.Call(typedInstance, method, arg0, arg1);
+            return Expression.Lambda<Action<object, T1, T2>>(body, instance, arg0, arg1).Compile();
         }
 
         /// <summary>
@@ -76,13 +76,13 @@ public Action<object, T1, T2> BuildAction<T1, T2>(MethodInfo method)
         public Action<object, T1, T2, T3> BuildAction<T1, T2, T3>(MethodInfo method)
         {
             var instance = Expression.Parameter(typeof(object), "instance");
-            var arg1 = Expression.Parameter(typeof(T1), "arg1");
-            var arg2 = Expression.Parameter(typeof(T2), "arg2");
-            var arg3 = Expression.Parameter(typeof(T3), "arg3");
+            var arg0 = Expression.Parameter(typeof(T1), "arg0");
+            var arg1 = Expression.Parameter(typeof(T2), "arg1");
+            var arg2 = Expression.Parameter(typeof(T3), "arg2");
 
             var typedInstance = Expression.Convert(instance, method.DeclaringType);
-            var body = Expression.Call(typedInstance, method, arg1, arg2, arg3);
-            return Expression.Lambda<Action<object, T1, T2, T3>>(body, instance, arg1, arg2, arg3).Compile();
+            var body = Expression.Call(typedInstance, method, arg0, arg1, arg2);
+            return Expression.Lambda<Action<object, T1, T2, T3>>(body, instance, arg0, arg1, arg2).Compile();
         }
 
         /// <summary>
@@ -99,14 +99,14 @@ public Action<object, T1, T2, T3> BuildAction<T1, T2, T3>(MethodInfo method)
         public Action<object, T1, T2, T3, T4> BuildAction<T1, T2, T3, T4>(MethodInfo method)
         {
             var instance = Expression.Parameter(typeof(object), "instance");
-            var arg1 = Expression.Parameter(typeof(T1), "arg1");
-            var arg2 = Expression.Parameter(typeof(T2), "arg2");
-            var arg3 = Expression.Parameter(typeof(T3), "arg3");
-            var arg4 = Expression.Parameter(typeof(T4), "arg4");
+            var arg0 = Expression.Parameter(typeof(T1), "arg0");
+            var arg1 = Expression.Parameter(typeof(T2), "arg1");
+            var arg2 = Expression.Parameter(typeof(T3), "arg2");
+            var arg3 = Expression.Parameter(typeof(T4), "arg3");
 
             var typedInstance = Expression.Convert(instance, method.DeclaringType);
-            var body = Expression.Call(typedInstance, method, arg1, arg2, arg3, arg4);
-            return Expression.Lambda<Action<object, T1, T2, T3, T4>>(body, instance, arg1, arg2, arg3, arg4).Compile();
+            var body = Expression.Call(typedInstance, method, arg0, arg1, arg2, arg3);
+            return Expression.Lambda<Action<object, T1, T2, T3, T4>>(body, instance, arg0, arg1, arg2, arg3).Compile();
         }
 
         /// <summary>
@@ -124,15 +124,15 @@ public Action<object, T1, T2, T3, T4> BuildAction<T1, T2, T3, T4>(MethodInfo met
         public Action<object, T1, T2, T3, T4, T5> BuildAction<T1, T2, T3, T4, T5>(MethodInfo method)
         {
             var instance = Expression.Parameter(typeof(object), "instance");
-            var arg1 = Expression.Parameter(typeof(T1), "arg1");
-            var arg2 = Expression.Parameter(typeof(T2), "arg2");
-            var arg3 = Expression.Parameter(typeof(T3), "arg3");
-            var arg4 = Expression.Parameter(typeof(T4), "arg4");
-            var arg5 = Expression.Parameter(typeof(T5), "arg5");
+            var arg0 = Expression.Parameter(typeof(T1), "arg0");
+            var arg1 = Expression.Parameter(typeof(T2), "arg1");
+            var arg2 = Expression.Parameter(typeof(T3), "arg2");
+            var arg3 = Expression.Parameter(typeof(T4), "arg3");
+            var arg4 = Expression.Parameter(typeof(T5), "arg4");
 
             var typedInstance = Expression.Convert(instance, method.DeclaringType);
-            var body = Expression.Call(typedInstance, method, arg1, arg2, arg3, arg4, arg5);
-            return Expression.Lambda<Action<object, T1, T2, T3, T4, T5>>(body, instance, arg1, arg2, arg3, arg4, arg5).Compile();
+            var body = Expression.Call(typedInstance, method, arg0, arg1, arg2, arg3, arg4);
+            return Expression.Lambda<Action<object, T1, T2, T3, T4, T5>>(body, instance, arg0, arg1, arg2, arg3, arg4).Compile();
         }
     }
 }
diff --git a/src/Weakly/Builders/ExpressionOpenFuncBuilder.cs b/src/Weakly/Builders/ExpressionOpenFuncBuilder.cs
index 09fbd61..a3a91c3 100644
--- a/src/Weakly/Builders/ExpressionOpenFuncBuilder.cs
+++ b/src/Weakly/Builders/ExpressionOpenFuncBuilder.cs
@@ -38,11 +38,11 @@ public Func<object, TResult> BuildFunc<TResult>(MethodInfo method)
         public Func<object, T, TResult> BuildFunc<T, TResult>(MethodInfo method)
         {
             var instance = Expression.Parameter(typeof(object), "instance");
-            var obj = Expression.Parameter(typeof(T), "obj");
+            var arg0 = Expression.Parameter(typeof(T), "arg0");
 
             var typedInstance = Expression.Convert(instance, method.DeclaringType);
-            var body = Expression.Call(typedInstance, method, obj);
-            return Expression.Lambda<Func<object, T, TResult>>(body, instance, obj).Compile();
+            var body = Expression.Call(typedInstance, method, arg0);
+            return Expression.Lambda<Func<object, T, TResult>>(body, instance, arg0).Compile();
         }
 
         /// <summary>
@@ -58,12 +58,12 @@ public Func<object, T, TResult> BuildFunc<T, TResult>(MethodInfo method)
         public Func<object, T1, T2, TResult> BuildFunc<T1, T2, TResult>(MethodInfo method)
         {
             var instance = Expression.Parameter(typeof(object), "instance");
-            var arg1 = Expression.Parameter(typeof(T1), "arg1");
-            var arg2 = Expression.Parameter(typeof(T2), "arg2");
+            var arg0 = Expression.Parameter(typeof(T1), "arg0");
+            var arg1 = Expression.Parameter(typeof(T2), "arg1");
 
             var typedInstance = Expression.Convert(instance, method.DeclaringType);
-            var body = Expression.Call(typedInstance, method, arg1, arg2);
-            return Expression.Lambda<Func<object, T1, T2, TResult>>(body, instance, arg1, arg2).Compile();
+            var body = Expression.Call(typedInstance, method, arg0, arg1);
+            return Expression.Lambda<Func<object, T1, T2, TResult>>(body, instance, arg0, arg1).Compile();
         }
 
         /// <summary>
@@ -80,13 +80,13 @@ public Func<object, T1, T2, TResult> BuildFunc<T1, T2, TResult>(MethodInfo metho
         public Func<object, T1, T2, T3, TResult> BuildFunc<T1, T2, T3, TResult>(MethodInfo method)
         {
             var instance = Expression.Parameter(typeof(object), "instance");
-            var arg1 = Expression.Parameter(typeof(T1), "arg1");
-            var arg2 = Expression.Parameter(typeof(T2), "arg2");
-            var arg3 = Expression.Parameter(typeof(T3), "arg3");
+            var arg0 = Expression.Parameter(typeof(T1), "arg0");
+            var arg1 = Expression.Parameter(typeof(T2), "arg1");
+            var arg2 = Expression.Parameter(typeof(T3), "arg2");
 
             var typedInstance = Expression.Convert(instance, method.DeclaringType);
-            var body = Expression.Call(typedInstance, method, arg1, arg2, arg3);
-            return Expression.Lambda<Func<object, T1, T2, T3, TResult>>(body, instance, arg1, arg2, arg3).Compile();
+            var body = Expression.Call(typedInstance, method, arg0, arg1, arg2);
+            return Expression.Lambda<Func<object, T1, T2, T3, TResult>>(body, instance, arg0, arg1, arg2).Compile();
         }
 
         /// <summary>
@@ -104,14 +104,14 @@ public Func<object, T1, T2, T3, TResult> BuildFunc<T1, T2, T3, TResult>(MethodIn
         public Func<object, T1, T2, T3, T4, TResult> BuildFunc<T1, T2, T3, T4, TResult>(MethodInfo method)
         {
             var instance = Expression.Parameter(typeof(object), "instance");
-            var arg1 = Expression.Parameter(typeof(T1), "arg1");
-            var arg2 = Expression.Parameter(typeof(T2), "arg2");
-            var arg3 = Expression.Parameter(typeof(T3), "arg3");
-            var arg4 = Expression.Parameter(typeof(T4), "arg4");
+            var arg0 = Expression.Parameter(typeof(T1), "arg0");
+            var arg1 = Expression.Parameter(typeof(T2), "arg1");
+            var arg2 = Expression.Parameter(typeof(T3), "arg2");
+            var arg3 = Expression.Parameter(typeof(T4), "arg3");
 
             var typedInstance = Expression.Convert(instance, method.DeclaringType);
-            var body = Expression.Call(typedInstance, method, arg1, arg2, arg3, arg4);
-            return Expression.Lambda<Func<object, T1, T2, T3, T4, TResult>>(body, instance, arg1, arg2, arg3, arg4).Compile();
+            var body = Expression.Call(typedInstance, method, arg0, arg1, arg2, arg3);
+            return Expression.Lambda<Func<object, T1, T2, T3, T4, TResult>>(body, instance, arg0, arg1, arg2, arg3).Compile();
         }
 
         /// <summary>
@@ -130,15 +130,15 @@ public Func<object, T1, T2, T3, T4, TResult> BuildFunc<T1, T2, T3, T4, TResult>(
         public Func<object, T1, T2, T3, T4, T5, TResult> BuildFunc<T1, T2, T3, T4, T5, TResult>(MethodInfo method)
         {
             var instance = Expression.Parameter(typeof(object), "instance");
-            var arg1 = Expression.Parameter(typeof(T1), "arg1");
-            var arg2 = Expression.Parameter(typeof(T2), "arg2");
-            var arg3 = Expression.Parameter(typeof(T3), "arg3");
-            var arg4 = Expression.Parameter(typeof(T4), "arg4");
-            var arg5 = Expression.Parameter(typeof(T5), "arg5");
+            var arg0 = Expression.Parameter(typeof(T1), "arg0");
+            var arg1 = Expression.Parameter(typeof(T2), "arg1");
+            var arg2 = Expression.Parameter(typeof(T3), "arg2");
+            var arg3 = Expression.Parameter(typeof(T4), "arg3");
+            var arg4 = Expression.Parameter(typeof(T5), "arg4");
 
             var typedInstance = Expression.Convert(instance, method.DeclaringType);
-            var body = Expression.Call(typedInstance, method, arg1, arg2, arg3, arg4, arg5);
-            return Expression.Lambda<Func<object, T1, T2, T3, T4, T5, TResult>>(body, instance, arg1, arg2, arg3, arg4, arg5).Compile();
+            var body = Expression.Call(typedInstance, method, arg0, arg1, arg2, arg3, arg4);
+            return Expression.Lambda<Func<object, T1, T2, T3, T4, T5, TResult>>(body, instance, arg0, arg1, arg2, arg3, arg4).Compile();
         }
     }
 }
diff --git a/src/Weakly/Builders/ReflectionDynamicDelegateBuilder.cs b/src/Weakly/Builders/ReflectionDynamicDelegateBuilder.cs
new file mode 100644
index 0000000..feda334
--- /dev/null
+++ b/src/Weakly/Builders/ReflectionDynamicDelegateBuilder.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Reflection;
+
+namespace Weakly.Builders
+{
+    /// <summary>
+    /// Reflection based <see cref="IDynamicDelegateBuilder"/>.
+    /// </summary>
+    public sealed class ReflectionDynamicDelegateBuilder : IDynamicDelegateBuilder
+    {
+        /// <summary>
+        /// Create a dynamic delegate from the specified method.
+        /// </summary>
+        /// <param name="method">The method.</param>
+        /// <returns>
+        /// The dynamic delegate.
+        /// </returns>
+        public Func<object, object[], object> BuildDynamic(MethodInfo method)
+        {
+            return method.Invoke;
+        }
+    }
+}
diff --git a/src/Weakly/Builders/ReflectionOpenActionBuilder.cs b/src/Weakly/Builders/ReflectionOpenActionBuilder.cs
new file mode 100644
index 0000000..3cf3299
--- /dev/null
+++ b/src/Weakly/Builders/ReflectionOpenActionBuilder.cs
@@ -0,0 +1,98 @@
+using System;
+using System.Reflection;
+
+namespace Weakly.Builders
+{
+    /// <summary>
+    /// Reflection based <see cref="IOpenActionBuilder"/>.
+    /// </summary>
+    public sealed class ReflectionOpenActionBuilder : IOpenActionBuilder
+    {
+        /// <summary>
+        /// Create an open delegate from the specified method.
+        /// </summary>
+        /// <param name="method">The method.</param>
+        /// <returns>
+        /// The open delegate.
+        /// </returns>
+        public Action<object> BuildAction(MethodInfo method)
+        {
+            return instance => method.Invoke(instance, null);
+        }
+
+        /// <summary>
+        /// Create an open delegate from the specified method.
+        /// </summary>
+        /// <typeparam name="T">The type of the parameter of the method that this delegate encapsulates.</typeparam>
+        /// <param name="method">The method.</param>
+        /// <returns>
+        /// The open delegate.
+        /// </returns>
+        public Action<object, T> BuildAction<T>(MethodInfo method)
+        {
+            return (instance, arg0) => method.Invoke(instance, new object[] {arg0});
+        }
+
+        /// <summary>
+        /// Create an open delegate from the specified method.
+        /// </summary>
+        /// <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
+        /// <param name="method">The method.</param>
+        /// <returns>
+        /// The open delegate.
+        /// </returns>
+        public Action<object, T1, T2> BuildAction<T1, T2>(MethodInfo method)
+        {
+            return (instance, arg0, arg1) => method.Invoke(instance, new object[] { arg0, arg1 });
+        }
+
+        /// <summary>
+        /// Create an open delegate from the specified method.
+        /// </summary>
+        /// <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
+        /// <param name="method">The method.</param>
+        /// <returns>
+        /// The open delegate.
+        /// </returns>
+        public Action<object, T1, T2, T3> BuildAction<T1, T2, T3>(MethodInfo method)
+        {
+            return (instance, arg0, arg1, arg2) => method.Invoke(instance, new object[] { arg0, arg1, arg2 });
+        }
+
+        /// <summary>
+        /// Create an open delegate from the specified method.
+        /// </summary>
+        /// <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>
+        /// <param name="method">The method.</param>
+        /// <returns>
+        /// The open delegate.
+        /// </returns>
+        public Action<object, T1, T2, T3, T4> BuildAction<T1, T2, T3, T4>(MethodInfo method)
+        {
+            return (instance, arg0, arg1, arg2, arg3) => method.Invoke(instance, new object[] { arg0, arg1, arg2, arg3 });
+        }
+
+        /// <summary>
+        /// Create an open delegate from the specified method.
+        /// </summary>
+        /// <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam>
+        /// <param name="method">The method.</param>
+        /// <returns>
+        /// The open delegate.
+        /// </returns>
+        public Action<object, T1, T2, T3, T4, T5> BuildAction<T1, T2, T3, T4, T5>(MethodInfo method)
+        {
+            return (instance, arg0, arg1, arg2, arg3, arg4) => method.Invoke(instance, new object[] { arg0, arg1, arg2, arg3, arg4 });
+        }
+    }
+}
diff --git a/src/Weakly/Builders/ReflectionOpenFuncBuilder.cs b/src/Weakly/Builders/ReflectionOpenFuncBuilder.cs
new file mode 100644
index 0000000..3d8defb
--- /dev/null
+++ b/src/Weakly/Builders/ReflectionOpenFuncBuilder.cs
@@ -0,0 +1,104 @@
+using System;
+using System.Reflection;
+
+namespace Weakly.Builders
+{
+    /// <summary>
+    /// Reflection based <see cref="IOpenFuncBuilder"/>.
+    /// </summary>
+    public sealed class ReflectionOpenFuncBuilder : IOpenFuncBuilder
+    {
+        /// <summary>
+        /// Create an open delegate from the specified method.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the return value of the method that this delegate encapsulates.</typeparam>
+        /// <param name="method">The method.</param>
+        /// <returns>
+        /// The open delegate.
+        /// </returns>
+        public Func<object, TResult> BuildFunc<TResult>(MethodInfo method)
+        {
+            return instance => (TResult) method.Invoke(instance, null);
+        }
+
+        /// <summary>
+        /// Create an open delegate from the specified method.
+        /// </summary>
+        /// <typeparam name="T">The type of the parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="TResult">The type of the return value of the method that this delegate encapsulates.</typeparam>
+        /// <param name="method">The method.</param>
+        /// <returns>
+        /// The open delegate.
+        /// </returns>
+        public Func<object, T, TResult> BuildFunc<T, TResult>(MethodInfo method)
+        {
+            return (instance, arg0) => (TResult) method.Invoke(instance, new object[] {arg0});
+        }
+
+        /// <summary>
+        /// Create an open delegate from the specified method.
+        /// </summary>
+        /// <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="TResult">The type of the return value of the method that this delegate encapsulates.</typeparam>
+        /// <param name="method">The method.</param>
+        /// <returns>
+        /// The open delegate.
+        /// </returns>
+        public Func<object, T1, T2, TResult> BuildFunc<T1, T2, TResult>(MethodInfo method)
+        {
+            return (instance, arg0, arg1) => (TResult)method.Invoke(instance, new object[] { arg0, arg1 });
+        }
+
+        /// <summary>
+        /// Create an open delegate from the specified method.
+        /// </summary>
+        /// <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="TResult">The type of the return value of the method that this delegate encapsulates.</typeparam>
+        /// <param name="method">The method.</param>
+        /// <returns>
+        /// The open delegate
+        /// </returns>
+        public Func<object, T1, T2, T3, TResult> BuildFunc<T1, T2, T3, TResult>(MethodInfo method)
+        {
+            return (instance, arg0, arg1, arg2) => (TResult) method.Invoke(instance, new object[] {arg0, arg1, arg2});
+        }
+
+        /// <summary>
+        /// Create an open delegate from the specified method.
+        /// </summary>
+        /// <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="TResult">The type of the return value of the method that this delegate encapsulates.</typeparam>
+        /// <param name="method">The method.</param>
+        /// <returns>
+        /// The open delegate
+        /// </returns>
+        public Func<object, T1, T2, T3, T4, TResult> BuildFunc<T1, T2, T3, T4, TResult>(MethodInfo method)
+        {
+            return (instance, arg0, arg1, arg2, arg3) => (TResult)method.Invoke(instance, new object[] { arg0, arg1, arg2, arg3 });
+        }
+
+        /// <summary>
+        /// Create an open delegate from the specified method.
+        /// </summary>
+        /// <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam>
+        /// <typeparam name="TResult">The type of the return value of the method that this delegate encapsulates.</typeparam>
+        /// <param name="method">The method.</param>
+        /// <returns>
+        /// The open delegate
+        /// </returns>
+        public Func<object, T1, T2, T3, T4, T5, TResult> BuildFunc<T1, T2, T3, T4, T5, TResult>(MethodInfo method)
+        {
+            return (instance, arg0, arg1, arg2, arg3, arg4) => (TResult)method.Invoke(instance, new object[] { arg0, arg1, arg2, arg3, arg4 });
+        }
+    }
+}
diff --git a/src/Weakly/Builders/ReflectionPropertyAccessorBuilder.cs b/src/Weakly/Builders/ReflectionPropertyAccessorBuilder.cs
new file mode 100644
index 0000000..c45680c
--- /dev/null
+++ b/src/Weakly/Builders/ReflectionPropertyAccessorBuilder.cs
@@ -0,0 +1,34 @@
+using System;
+
+namespace Weakly.Builders
+{
+    /// <summary>
+    /// Reflection based <see cref="IPropertyAccessorBuilder"/>.
+    /// </summary>
+    public sealed class ReflectionPropertyAccessorBuilder : IPropertyAccessorBuilder
+    {
+        /// <summary>
+        /// Get compiled Getter function from a given <paramref name="property" />.
+        /// </summary>
+        /// <param name="property">The property.</param>
+        /// <returns>
+        /// The function to get the property value.
+        /// </returns>
+        public Func<object, object> BuildGetter(System.Reflection.PropertyInfo property)
+        {
+            return property.GetValue;
+        }
+
+        /// <summary>
+        /// Get compiled Setter function from a given <paramref name="property" />.
+        /// </summary>
+        /// <param name="property">The property.</param>
+        /// <returns>
+        /// The function to set the property value.
+        /// </returns>
+        public Action<object, object> BuildSetter(System.Reflection.PropertyInfo property)
+        {
+            return property.SetValue;
+        }
+    }
+}
diff --git a/src/Weakly/Weakly.csproj b/src/Weakly/Weakly.csproj
index 2309579..263cddc 100644
--- a/src/Weakly/Weakly.csproj
+++ b/src/Weakly/Weakly.csproj
@@ -53,7 +53,11 @@
     <Compile Include="Builders\Builder.cs" />
     <Compile Include="Builders\CachingDynamicDelegateBuilderDecorator.cs" />
     <Compile Include="Builders\CachingPropertyAccessorBuilderDecorator.cs" />
+    <Compile Include="Builders\ReflectionDynamicDelegateBuilder.cs" />
     <Compile Include="Builders\ExpressionDynamicDelegateBuilder.cs" />
+    <Compile Include="Builders\ReflectionOpenActionBuilder.cs" />
+    <Compile Include="Builders\ReflectionOpenFuncBuilder.cs" />
+    <Compile Include="Builders\ReflectionPropertyAccessorBuilder.cs" />
     <Compile Include="Builders\ExpressionPropertyAccessorBuilder.cs" />
     <Compile Include="Builders\IDynamicDelegateBuilder.cs" />
     <Compile Include="Builders\IPropertyAccessorBuilder.cs" />