diff --git a/src/Umbraco.Core/ExpressionExtensions.cs b/src/Umbraco.Core/ExpressionExtensions.cs
index 392316e4eb..3fc602927b 100644
--- a/src/Umbraco.Core/ExpressionExtensions.cs
+++ b/src/Umbraco.Core/ExpressionExtensions.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Linq;
 using System.Linq.Expressions;
 
 namespace Umbraco.Core
@@ -7,22 +6,64 @@ namespace Umbraco.Core
     internal static class ExpressionExtensions
     {
         public static Expression<Func<T, bool>> True<T>() { return f => true; }
+
         public static Expression<Func<T, bool>> False<T>() { return f => false; }
 
-        public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> left,
-                                                      Expression<Func<T, bool>> right)
+        public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> left, Expression<Func<T, bool>> right)
         {
-            var invokedExpr = Expression.Invoke(right, left.Parameters.Cast<Expression>());
-            return Expression.Lambda<Func<T, bool>>
-                (Expression.OrElse(left.Body, invokedExpr), left.Parameters);
+            var invokedExpr = Expression.Invoke(right, left.Parameters);
+            return Expression.Lambda<Func<T, bool>>(Expression.OrElse(left.Body, invokedExpr), left.Parameters);
         }
 
-        public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> left,
-                                                       Expression<Func<T, bool>> right)
+        public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> left, Expression<Func<T, bool>> right)
         {
-            var invokedExpr = Expression.Invoke(right, left.Parameters.Cast<Expression>());
-            return Expression.Lambda<Func<T, bool>>
-                (Expression.AndAlso(left.Body, invokedExpr), left.Parameters);
+            var invokedExpr = Expression.Invoke(right, left.Parameters);
+            return Expression.Lambda<Func<T, bool>> (Expression.AndAlso(left.Body, invokedExpr), left.Parameters);
+        }
+
+        public static Action CompileToDelegate(this Expression<Action> expr)
+        {
+            return ReflectionUtilities.CompileToDelegate(expr);
+        }
+
+        public static Action<T1> CompileToDelegate<T1>(this Expression<Action<T1>> expr)
+        {
+            return ReflectionUtilities.CompileToDelegate(expr);
+        }
+
+        public static Action<T1, T2> CompileToDelegate<T1, T2>(this Expression<Action<T1, T2>> expr)
+        {
+            return ReflectionUtilities.CompileToDelegate(expr);
+        }
+
+        public static Action<T1, T2, T3> CompileToDelegate<T1, T2, T3>(this Expression<Action<T1, T2, T3>> expr)
+        {
+            return ReflectionUtilities.CompileToDelegate(expr);
+        }
+
+        public static Func<TResult> CompileToDelegate<TResult>(this Expression<Func<TResult>> expr)
+        {
+            return ReflectionUtilities.CompileToDelegate(expr);
+        }
+
+        public static Func<T1, TResult> CompileToDelegate<T1, TResult>(this Expression<Func<T1, TResult>> expr)
+        {
+            return ReflectionUtilities.CompileToDelegate(expr);
+        }
+
+        public static Func<T1, T2, TResult> CompileToDelegate<T1, T2, TResult>(this Expression<Func<T1, T2, TResult>> expr)
+        {
+            return ReflectionUtilities.CompileToDelegate(expr);
+        }
+
+        public static Func<T1, T2, T3, TResult> CompileToDelegate<T1, T2, T3, TResult>(this Expression<Func<T1, T2, T3, TResult>> expr)
+        {
+            return ReflectionUtilities.CompileToDelegate(expr);
+        }
+
+        public static TMethod CompileToDelegate<TMethod>(this Expression<TMethod> expr)
+        {
+            return ReflectionUtilities.CompileToDelegate(expr);
         }
     }
 }
diff --git a/src/Umbraco.Core/Models/PublishedContent/PublishedContentModelFactory.cs b/src/Umbraco.Core/Models/PublishedContent/PublishedContentModelFactory.cs
index cc6ac093b4..898a575c02 100644
--- a/src/Umbraco.Core/Models/PublishedContent/PublishedContentModelFactory.cs
+++ b/src/Umbraco.Core/Models/PublishedContent/PublishedContentModelFactory.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq.Expressions;
 using System.Reflection;
 using System.Reflection.Emit;
 
@@ -39,6 +40,7 @@ namespace Umbraco.Core.Models.PublishedContent
         {
             var ctorArgTypes = new[] { typeof(IPublishedElement) };
             var modelInfos = new Dictionary<string, ModelInfo>(StringComparer.InvariantCultureIgnoreCase);
+            var exprs = new List<Expression<Func<IPublishedElement, IPublishedElement>>>();
 
             ModelTypeMap = new Dictionary<string, Type>(StringComparer.InvariantCultureIgnoreCase);
 
@@ -68,31 +70,16 @@ namespace Umbraco.Core.Models.PublishedContent
                 if (modelInfos.TryGetValue(typeName, out ModelInfo modelInfo))
                     throw new InvalidOperationException($"Both types {type.FullName} and {modelInfo.ModelType.FullName} want to be a model type for content type with alias \"{typeName}\".");
 
-                // see Umbraco.Tests.Benchmarks.CtorInvokeBenchmarks
-                // using ctor.Invoke is horrible, cannot even consider it,
-                // then expressions are 6-10x slower than direct ctor, and
-                // dynamic methods are 2-3x slower than direct ctor = best
-
-                // much faster with a dynamic method but potential MediumTrust issues - which we don't support
-                // here http://stackoverflow.com/questions/16363838/how-do-you-call-a-constructor-via-an-expression-tree-on-an-existing-object
-                var meth = new DynamicMethod(string.Empty, typeof(IPublishedElement), ctorArgTypes, type.Module, true);
-                var gen = meth.GetILGenerator();
-                gen.Emit(OpCodes.Ldarg_0);
-                gen.Emit(OpCodes.Newobj, constructor);
-                gen.Emit(OpCodes.Ret);
-                var func = (Func<IPublishedElement, IPublishedElement>) meth.CreateDelegate(typeof (Func<IPublishedElement, IPublishedElement>));
-
-                // fast enough and works in MediumTrust - but we don't
-                // read http://boxbinary.com/2011/10/how-to-run-a-unit-test-in-medium-trust-with-nunitpart-three-umbraco-framework-testing/
-                //var exprArg = Expression.Parameter(typeof(IPropertySet), "content");
-                //var exprNew = Expression.New(constructor, exprArg);
-                //var expr = Expression.Lambda<Func<IPropertySet, IPropertySet>>(exprNew, exprArg);
-                //var func = expr.Compile();
-
-                modelInfos[typeName] = new ModelInfo { ParameterType = parameterType, Ctor = func, ModelType = type };
+                exprs.Add(Expression.Lambda<Func<IPublishedElement, IPublishedElement>>(Expression.New(constructor)));
+                modelInfos[typeName] = new ModelInfo { ParameterType = parameterType, ModelType = type };
                 ModelTypeMap[typeName] = type;
             }
 
+            var compiled = ReflectionUtilities.CompileToDelegates(exprs.ToArray());
+            var i = 0;
+            foreach (var modelInfo in modelInfos.Values)
+                modelInfo.Ctor = compiled[i++];
+
             _modelInfos = modelInfos.Count > 0 ? modelInfos : null;
         }
 
diff --git a/src/Umbraco.Core/ReflectionUtilities.cs b/src/Umbraco.Core/ReflectionUtilities.cs
new file mode 100644
index 0000000000..372f30d1f5
--- /dev/null
+++ b/src/Umbraco.Core/ReflectionUtilities.cs
@@ -0,0 +1,572 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Reflection.Emit;
+
+namespace Umbraco.Core
+{
+    /// <summary>
+    /// Provides utilities to simplify reflection.
+    /// </summary>
+    public static class ReflectionUtilities
+    {
+        private static Func<TInstance, TValue> GetPropertyGetter<TInstance, TValue>(PropertyInfo property)
+        {
+            var type = typeof(TInstance);
+
+            var getMethod = property.GetMethod;
+            if (getMethod == null)
+                throw new InvalidOperationException($"Property {type}.{property.Name} : {property.PropertyType} does not have a getter.");
+
+            var exprThis = Expression.Parameter(type, "this");
+            var exprCall = Expression.Call(exprThis, getMethod);
+            var expr = Expression.Lambda<Func<TInstance, TValue>>(exprCall, exprThis);
+            return expr.CompileToDelegate();
+        }
+
+        private static Action<TInstance, TValue> GetPropertySetter<TInstance, TValue>(PropertyInfo property)
+        {
+            var type = typeof(TInstance);
+
+            var setMethod = property.SetMethod;
+            if (setMethod == null)
+                throw new InvalidOperationException($"Property {type}.{property.Name} : {property.PropertyType} does not have a setter.");
+
+            var exprThis = Expression.Parameter(type, "this");
+            var exprArg0 = Expression.Parameter(typeof(TValue), "value");
+            var exprCall = Expression.Call(exprThis, setMethod, exprArg0);
+            var expr = Expression.Lambda<Action<TInstance, TValue>>(exprCall, exprThis, exprArg0);
+            return expr.CompileToDelegate();
+        }
+
+        public static Func<TInstance, TValue> GetPropertyGetter<TInstance, TValue>(string propertyName)
+        {
+            var type = typeof(TInstance);
+            var type0 = typeof(TValue);
+            var property = type.GetProperty(propertyName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+            if (property == null || property.PropertyType != type0)
+                throw new InvalidOperationException($"Could not get property {type}.{propertyName} : {type0}.");
+            return GetPropertyGetter<TInstance, TValue>(property);
+        }
+
+        public static Action<TInstance, TValue> GetPropertySetter<TInstance, TValue>(string propertyName)
+        {
+            var type = typeof(TInstance);
+            var type0 = typeof(TValue);
+            var property = type.GetProperty(propertyName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+            if (property == null || property.PropertyType != type0)
+                throw new InvalidOperationException($"Could not get property {type}.{propertyName} : {type0}.");
+            return GetPropertySetter<TInstance, TValue>(property);
+        }
+
+        public static void GetPropertyGetterSetter<TInstance, TValue>(string propertyName, out Func<TInstance, TValue> getter, out Action<TInstance, TValue> setter)
+        {
+            var type = typeof(TInstance);
+            var type0 = typeof(TValue);
+            var property = type.GetProperty(propertyName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+            if (property == null || property.PropertyType != type0)
+                throw new InvalidOperationException($"Could not get property {type}.{propertyName} : {type0}.");
+            getter = GetPropertyGetter<TInstance, TValue>(property);
+            setter = GetPropertySetter<TInstance, TValue>(property);
+        }
+
+        public static Func<TInstance> GetCtor<TInstance>()
+        {
+            var type = typeof(TInstance);
+
+            // get the constructor infos
+            var ctor = type.GetConstructor(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance,
+                null, Type.EmptyTypes, null);
+
+            if (ctor == null)
+                throw new InvalidOperationException($"Could not find constructor {type}.ctor().");
+
+            var exprNew = Expression.New(ctor);
+            var expr = Expression.Lambda<Func<TInstance>>(exprNew);
+            return expr.CompileToDelegate();
+        }
+
+        public static Func<TArg0, TInstance> GetCtor<TInstance, TArg0>()
+        {
+            var type = typeof(TInstance);
+            var type0 = typeof(TArg0);
+
+            // get the constructor infos
+            var ctor = type.GetConstructor(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance,
+                null, new[] { type0 }, null);
+
+            if (ctor == null)
+                throw new InvalidOperationException($"Could not find constructor {type}.ctor({type0}).");
+
+            var exprArgs = ctor.GetParameters().Select(x => Expression.Parameter(x.ParameterType, x.Name)).ToArray();
+            // ReSharper disable once CoVariantArrayConversion
+            var exprNew = Expression.New(ctor, exprArgs);
+            var expr = Expression.Lambda<Func<TArg0, TInstance>>(exprNew, exprArgs);
+            return expr.CompileToDelegate();
+        }
+
+        public static Func<TArg0, TArg1, TInstance> GetCtor<TInstance, TArg0, TArg1>()
+        {
+            var type = typeof(TInstance);
+            var type0 = typeof(TArg0);
+            var type1 = typeof(TArg1);
+
+            // get the constructor infos
+            var ctor = type.GetConstructor(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance,
+                null, new[] { type0, type1 }, null);
+
+            if (ctor == null)
+                throw new InvalidOperationException($"Could not find constructor {type}.ctor({type0}, {type1}).");
+
+            var exprArgs = ctor.GetParameters().Select(x => Expression.Parameter(x.ParameterType, x.Name)).ToArray();
+            // ReSharper disable once CoVariantArrayConversion
+            var exprNew = Expression.New(ctor, exprArgs);
+            var expr = Expression.Lambda<Func<TArg0, TArg1, TInstance>>(exprNew, exprArgs);
+            return expr.CompileToDelegate();
+        }
+
+        public static TMethod GetMethod<TMethod>(MethodInfo method)
+        {
+            var type = method.DeclaringType;
+
+            GetMethodParms<TMethod>(out var parameterTypes, out var returnType);
+            return GetStaticMethod<TMethod>(method, method.Name, type, parameterTypes, returnType);
+        }
+
+        public static TMethod GetMethod<TInstance, TMethod>(MethodInfo method)
+        {
+            var type = method.DeclaringType;
+
+            GetMethodParms<TInstance, TMethod>(out var parameterTypes, out var returnType);
+            return GetMethod<TMethod>(method, method.Name, type, parameterTypes, returnType);
+        }
+
+        public static TMethod GetMethod<TInstance, TMethod>(string methodName)
+        {
+            var type = typeof(TInstance);
+
+            GetMethodParms<TInstance, TMethod>(out var parameterTypes, out var returnType);
+
+            var method = type.GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance,
+                null, parameterTypes, null);
+
+            return GetMethod<TMethod>(method, methodName, type, parameterTypes, returnType);
+        }
+
+        private static void GetMethodParms<TMethod>(out Type[] parameterTypes, out Type returnType)
+        {
+            var typeM = typeof(TMethod);
+            var typeList = new List<Type>();
+            returnType = typeof(void);
+
+            if (!typeof(MulticastDelegate).IsAssignableFrom(typeM) || typeM == typeof(MulticastDelegate))
+                throw new InvalidOperationException("Invalid TMethod, must be a Func or Action.");
+
+            var typeName = typeM.FullName;
+            if (typeName.StartsWith("System.Func`"))
+            {
+                var i = 0;
+                while (i < typeM.GenericTypeArguments.Length - 1)
+                    typeList.Add(typeM.GenericTypeArguments[i++]);
+                returnType = typeM.GenericTypeArguments[i];
+            }
+            else if (typeName.StartsWith("System.Action`"))
+            {
+                var i = 0;
+                while (i < typeM.GenericTypeArguments.Length)
+                    typeList.Add(typeM.GenericTypeArguments[i++]);
+            }
+            else if (typeName == "System.Action")
+            {
+                // no args
+            }
+            else
+                throw new InvalidOperationException(typeName);
+
+            parameterTypes = typeList.ToArray();
+        }
+
+        private static void GetMethodParms<TInstance, TMethod>(out Type[] parameterTypes, out Type returnType)
+        {
+            var type = typeof(TInstance);
+
+            var typeM = typeof(TMethod);
+            var typeList = new List<Type>();
+            returnType = typeof(void);
+
+            if (!typeof(MulticastDelegate).IsAssignableFrom(typeM) || typeM == typeof(MulticastDelegate))
+                throw new InvalidOperationException("Invalid TMethod, must be a Func or Action.");
+
+            var typeName = typeM.FullName;
+            if (!typeM.IsGenericType)
+                throw new InvalidOperationException(typeName);
+            if (typeM.GenericTypeArguments[0] != type)
+                throw new InvalidOperationException("Invalid TMethod, the first generic argument must be TInstance.");
+            if (typeName.StartsWith("System.Func`"))
+            {
+                var i = 1;
+                while (i < typeM.GenericTypeArguments.Length - 1)
+                    typeList.Add(typeM.GenericTypeArguments[i++]);
+                returnType = typeM.GenericTypeArguments[i];
+            }
+            else if (typeName.StartsWith("System.Action`"))
+            {
+                var i = 1;
+                while (i < typeM.GenericTypeArguments.Length)
+                    typeList.Add(typeM.GenericTypeArguments[i++]);
+            }
+            else
+                throw new InvalidOperationException(typeName);
+
+            parameterTypes = typeList.ToArray();
+        }
+
+        private static TMethod GetStaticMethod<TMethod>(MethodInfo method, string methodName, Type type, Type[] parameterTypes, Type returnType)
+        {
+            if (method == null || method.ReturnType != returnType)
+                throw new InvalidOperationException($"Could not find static method {type}.{methodName}({string.Join(",", parameterTypes.Select(x => x.ToString()))}) : {returnType}");
+
+            var e = new List<ParameterExpression>();
+            foreach (var p in method.GetParameters())
+                e.Add(Expression.Parameter(p.ParameterType, p.Name));
+            var exprCallArgs = e.ToArray();
+            var exprLambdaArgs = exprCallArgs;
+
+            // ReSharper disable once CoVariantArrayConversion
+            var exprCall = Expression.Call(method, exprCallArgs);
+            var expr = Expression.Lambda<TMethod>(exprCall, exprLambdaArgs);
+            return expr.CompileToDelegate();
+        }
+
+        private static TMethod GetMethod<TMethod>(MethodInfo method, string methodName, Type type, Type[] parameterTypes, Type returnType)
+        {
+            if (method == null || method.ReturnType != returnType)
+                throw new InvalidOperationException($"Could not find method {type}.{methodName}({string.Join(",", parameterTypes.Select(x => x.ToString()))}) : {returnType}");
+
+            var e = new List<ParameterExpression>();
+            foreach (var p in method.GetParameters())
+                e.Add(Expression.Parameter(p.ParameterType, p.Name));
+            var exprCallArgs = e.ToArray();
+
+            var exprThis = Expression.Parameter(type, "this");
+            e.Insert(0, exprThis);
+            var exprLambdaArgs = e.ToArray();
+
+            // ReSharper disable once CoVariantArrayConversion
+            var exprCall = Expression.Call(exprThis, method, exprCallArgs);
+            var expr = Expression.Lambda<TMethod>(exprCall, exprLambdaArgs);
+            return expr.Compile();
+        }
+
+        public static object GetStaticProperty(this Type type, string propertyName, Func<IEnumerable<PropertyInfo>, PropertyInfo> filter = null)
+        {
+            var propertyInfo = GetPropertyInfo(type, propertyName, filter);
+            if (propertyInfo == null)
+                throw new ArgumentOutOfRangeException(nameof(propertyName),
+                    $"Couldn't find property {propertyName} in type {type.FullName}");
+            return propertyInfo.GetValue(null, null);
+        }
+
+        public static object CallStaticMethod(this Type type, string methodName, params object[] parameters)
+        {
+            var methodInfo = GetMethodInfo(type, methodName);
+            if (methodInfo == null)
+                throw new ArgumentOutOfRangeException(nameof(methodName),
+                    $"Couldn't find method {methodName} in type {type.FullName}");
+            return methodInfo.Invoke(null, parameters);
+        }
+
+        public static object CallMethod(this object obj, string methodName, params object[] parameters)
+        {
+            if (obj == null)
+                throw new ArgumentNullException(nameof(obj));
+            Type type = obj.GetType();
+            var methodInfo = GetMethodInfo(type, methodName);
+            if (methodInfo == null)
+                throw new ArgumentOutOfRangeException(nameof(methodName),
+                    $"Couldn't find method {methodName} in type {type.FullName}");
+            return methodInfo.Invoke(obj, parameters);
+        }
+
+        public static object CallMethod(this object obj, string methodName, Func<IEnumerable<MethodInfo>, MethodInfo> filter = null, params object[] parameters)
+        {
+            if (obj == null)
+                throw new ArgumentNullException(nameof(obj));
+            Type type = obj.GetType();
+            var methodInfo = GetMethodInfo(type, methodName, filter);
+            if (methodInfo == null)
+                throw new ArgumentOutOfRangeException(nameof(methodName),
+                    $"Couldn't find method {methodName} in type {type.FullName}");
+            return methodInfo.Invoke(obj, parameters);
+        }
+
+        private static MethodInfo GetMethodInfo(Type type, string methodName, Func<IEnumerable<MethodInfo>, MethodInfo> filter = null)
+        {
+            MethodInfo methodInfo;
+            do
+            {
+                try
+                {
+                    methodInfo = type.GetMethod(methodName,
+                        BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
+                }
+                catch (AmbiguousMatchException)
+                {
+                    if (filter == null) throw;
+
+                    methodInfo = filter(
+                        type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static)
+                            .Where(x => x.Name == methodName));
+                }
+                type = type.BaseType;
+            }
+            while (methodInfo == null && type != null);
+            return methodInfo;
+        }
+
+        private static PropertyInfo GetPropertyInfo(Type type, string propertyName, Func<IEnumerable<PropertyInfo>, PropertyInfo> filter = null)
+        {
+            PropertyInfo propInfo;
+            do
+            {
+                try
+                {
+                    propInfo = type.GetProperty(propertyName,
+                        BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
+                }
+                catch (AmbiguousMatchException)
+                {
+                    if (filter == null) throw;
+
+                    propInfo = filter(type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static)
+                        .Where(x => x.Name == propertyName));
+                }
+                type = type.BaseType;
+            }
+            while (propInfo == null && type != null);
+            return propInfo;
+        }
+
+        public static object GetPropertyValue(this object obj, string propertyName)
+        {
+            if (obj == null)
+                throw new ArgumentNullException(nameof(obj));
+            Type objType = obj.GetType();
+            PropertyInfo propInfo = GetPropertyInfo(objType, propertyName);
+            if (propInfo == null)
+                throw new ArgumentOutOfRangeException(nameof(propertyName),
+                    $"Couldn't find property {propertyName} in type {objType.FullName}");
+            return propInfo.GetValue(obj, null);
+        }
+
+        public static object GetPropertyValue(this object obj, string propertyName, IDictionary<string, PropertyInfo> propCache)
+        {
+            if (obj == null)
+                throw new ArgumentNullException(nameof(obj));
+            Type objType = obj.GetType();
+            PropertyInfo propInfo;
+            if (propCache.ContainsKey(propertyName))
+            {
+                propInfo = propCache[propertyName];
+            }
+            else
+            {
+                propInfo = GetPropertyInfo(objType, propertyName);
+                if (propInfo == null)
+                    throw new ArgumentOutOfRangeException(nameof(propertyName),
+                        $"Couldn't find property {propertyName} in type {objType.FullName}");
+
+                propCache[propertyName] = propInfo;
+            }
+            return propInfo.GetValue(obj, null);
+        }
+
+        public static void SetPropertyValue(this object obj, string propertyName, object val)
+        {
+            if (obj == null)
+                throw new ArgumentNullException(nameof(obj));
+            Type objType = obj.GetType();
+            PropertyInfo propInfo = GetPropertyInfo(objType, propertyName);
+            if (propInfo == null)
+                throw new ArgumentOutOfRangeException(nameof(propertyName),
+                    $"Couldn't find property {propertyName} in type {objType.FullName}");
+            propInfo.SetValue(obj, val, null);
+        }
+
+        public static void SetPropertyValue(this object obj, string propertyName, object val, IDictionary<string, PropertyInfo> propCache)
+        {
+            if (obj == null) throw new ArgumentNullException(nameof(obj));
+            if (propCache == null) throw new ArgumentNullException(nameof(propCache));
+
+            Type objType = obj.GetType();
+            PropertyInfo propInfo;
+            if (propCache.ContainsKey(propertyName))
+            {
+                propInfo = propCache[propertyName];
+            }
+            else
+            {
+                propInfo = GetPropertyInfo(objType, propertyName);
+                if (propInfo == null)
+                    throw new ArgumentOutOfRangeException(nameof(propertyName),
+                        $"Couldn't find property {propertyName} in type {objType.FullName}");
+
+                propCache[propertyName] = propInfo;
+            }
+
+            propInfo.SetValue(obj, val, null);
+        }
+
+        public static Action CompileToDelegate(Expression<Action> expr)
+        {
+            var typeBuilder = CreateTypeBuilder();
+
+            var builder = typeBuilder.DefineMethod("Method",
+                MethodAttributes.Public | MethodAttributes.Static); // CompileToMethod requires a static method
+
+            expr.CompileToMethod(builder);
+
+            return (Action) Delegate.CreateDelegate(typeof (Action), typeBuilder.CreateType().GetMethod("Method"));
+        }
+
+        public static Action<T1> CompileToDelegate<T1>(Expression<Action<T1>> expr)
+        {
+            var typeBuilder = CreateTypeBuilder();
+
+            var builder = typeBuilder.DefineMethod("Method",
+                MethodAttributes.Public | MethodAttributes.Static, // CompileToMethod requires a static method
+                typeof (void), new[] { typeof (T1) });
+
+            expr.CompileToMethod(builder);
+
+            return (Action<T1>) Delegate.CreateDelegate(typeof (Action<T1>), typeBuilder.CreateType().GetMethod("Method"));
+        }
+
+        public static Action<T1, T2> CompileToDelegate<T1, T2>(Expression<Action<T1, T2>> expr)
+        {
+            var typeBuilder = CreateTypeBuilder();
+
+            var builder = typeBuilder.DefineMethod("Method",
+                MethodAttributes.Public | MethodAttributes.Static, // CompileToMethod requires a static method
+                typeof (void), new[] { typeof(T1), typeof (T2) });
+
+            expr.CompileToMethod(builder);
+
+            return (Action<T1, T2>) Delegate.CreateDelegate(typeof (Action<T1, T2>), typeBuilder.CreateType().GetMethod("Method"));
+        }
+
+        public static Action<T1, T2, T3> CompileToDelegate<T1, T2, T3>(Expression<Action<T1, T2, T3>> expr)
+        {
+            var typeBuilder = CreateTypeBuilder();
+
+            var builder = typeBuilder.DefineMethod("Method",
+                MethodAttributes.Public | MethodAttributes.Static, // CompileToMethod requires a static method
+                typeof (void), new[] { typeof (T1), typeof (T2) , typeof (T3) });
+
+            expr.CompileToMethod(builder);
+
+            return (Action<T1, T2, T3>) Delegate.CreateDelegate(typeof (Action<T1, T2, T3>), typeBuilder.CreateType().GetMethod("Method"));
+        }
+
+        public static Func<TResult> CompileToDelegate<TResult>(Expression<Func<TResult>> expr)
+        {
+            var typeBuilder = CreateTypeBuilder();
+
+            var builder = typeBuilder.DefineMethod("Method",
+                MethodAttributes.Public | MethodAttributes.Static,
+                typeof (TResult), Array.Empty<Type>()); // CompileToMethod requires a static method
+
+            expr.CompileToMethod(builder);
+
+            return (Func<TResult>) Delegate.CreateDelegate(typeof (Func<TResult>), typeBuilder.CreateType().GetMethod("Method"));
+        }
+
+        public static Func<T1, TResult> CompileToDelegate<T1, TResult>(Expression<Func<T1, TResult>> expr)
+        {
+            var typeBuilder = CreateTypeBuilder();
+
+            var builder = typeBuilder.DefineMethod("Method",
+                MethodAttributes.Public | MethodAttributes.Static, // CompileToMethod requires a static method
+                typeof (TResult), new[] { typeof (T1) });
+
+            expr.CompileToMethod(builder);
+
+            return (Func<T1,TResult>) Delegate.CreateDelegate(typeof (Func<T1, TResult>), typeBuilder.CreateType().GetMethod("Method"));
+        }
+
+        public static Func<T1, T2, TResult> CompileToDelegate<T1, T2, TResult>(Expression<Func<T1, T2, TResult>> expr)
+        {
+            var typeBuilder = CreateTypeBuilder();
+
+            var builder = typeBuilder.DefineMethod("Method",
+                MethodAttributes.Public | MethodAttributes.Static, // CompileToMethod requires a static method
+                typeof(TResult), new[] { typeof (T1), typeof(T2) });
+
+            expr.CompileToMethod(builder);
+
+            return (Func<T1, T2, TResult>) Delegate.CreateDelegate(typeof (Func<T1, T2, TResult>), typeBuilder.CreateType().GetMethod("Method"));
+        }
+
+        public static Func<T1, T2, T3, TResult> CompileToDelegate<T1, T2, T3, TResult>(Expression<Func<T1, T2, T3, TResult>> expr)
+        {
+            var typeBuilder = CreateTypeBuilder();
+
+            var builder = typeBuilder.DefineMethod("Method",
+                MethodAttributes.Public | MethodAttributes.Static, // CompileToMethod requires a static method
+                typeof (TResult), new[] { typeof (T1), typeof (T2), typeof (T3) });
+
+            expr.CompileToMethod(builder);
+
+            return (Func<T1, T2, T3, TResult>) Delegate.CreateDelegate(typeof (Func<T1, T2, T3, TResult>), typeBuilder.CreateType().GetMethod("Method"));
+        }
+
+        public static TMethod CompileToDelegate<TMethod>(Expression<TMethod> expr)
+        {
+            var typeBuilder = CreateTypeBuilder();
+
+            GetMethodParms<TMethod>(out var parameterTypes, out var returnType);
+
+            var builder = typeBuilder.DefineMethod("Method",
+                MethodAttributes.Public | MethodAttributes.Static, // CompileToMethod requires a static method
+                returnType, parameterTypes);
+
+            expr.CompileToMethod(builder);
+
+            return (TMethod) (object) Delegate.CreateDelegate(typeof (TMethod), typeBuilder.CreateType().GetMethod("Method"));
+        }
+
+        public static TMethod[] CompileToDelegates<TMethod>(params Expression<TMethod>[] exprs)
+        {
+            var typeBuilder = CreateTypeBuilder();
+
+            GetMethodParms<TMethod>(out var parameterTypes, out var returnType);
+
+            var i = 0;
+            foreach (var expr in exprs)
+            {
+                var builder = typeBuilder.DefineMethod($"Method_{i++}",
+                    MethodAttributes.Public | MethodAttributes.Static, // CompileToMethod requires a static method
+                    returnType, parameterTypes);
+
+                expr.CompileToMethod(builder);
+            }
+
+            var type = typeBuilder.CreateType();
+
+            var methods = new TMethod[exprs.Length];
+            for (i = 0; i < exprs.Length; i++)
+                methods[i] = (TMethod) (object) Delegate.CreateDelegate(typeof (TMethod), type.GetMethod($"Method_{i++}"));
+            return methods;
+        }
+
+        private static TypeBuilder CreateTypeBuilder()
+        {
+            var assemblyName = new AssemblyName("Umbraco.Core.DynamicAssemblies." + Guid.NewGuid().ToString("N"));
+            var assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Save);
+            var module = assembly.DefineDynamicModule(assemblyName.Name, assemblyName.Name + ".dll");
+            return module.DefineType("Class", TypeAttributes.Public | TypeAttributes.Abstract);
+        }
+    }
+}
diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj
index ae251bea45..4448bcfb4c 100644
--- a/src/Umbraco.Core/Umbraco.Core.csproj
+++ b/src/Umbraco.Core/Umbraco.Core.csproj
@@ -28,6 +28,7 @@
     <WarningLevel>4</WarningLevel>
     <DocumentationFile>bin\Release\Umbraco.Core.xml</DocumentationFile>
     <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
@@ -1280,6 +1281,7 @@
     <Compile Include="PropertyEditors\ValueValidatorAttribute.cs" />
     <Compile Include="Publishing\ScheduledPublisher.cs" />
     <Compile Include="ReadLock.cs" />
+    <Compile Include="ReflectionUtilities.cs" />
     <Compile Include="RenderingEngine.cs" />
     <Compile Include="RuntimeLevel.cs" />
     <Compile Include="RuntimeState.cs" />
diff --git a/src/Umbraco.Tests.Benchmarks/CtorInvokeBenchmarks.cs b/src/Umbraco.Tests.Benchmarks/CtorInvokeBenchmarks.cs
index 7cce05c51d..46fe21f2c9 100644
--- a/src/Umbraco.Tests.Benchmarks/CtorInvokeBenchmarks.cs
+++ b/src/Umbraco.Tests.Benchmarks/CtorInvokeBenchmarks.cs
@@ -1,16 +1,13 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
 using System.Reflection.Emit;
-using System.Text;
-using System.Threading.Tasks;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Diagnosers;
 using BenchmarkDotNet.Horology;
 using BenchmarkDotNet.Jobs;
+using Umbraco.Core;
 
 namespace Umbraco.Tests.Benchmarks
 {
@@ -28,16 +25,19 @@ namespace Umbraco.Tests.Benchmarks
                 // see benchmarkdotnet FAQ
                 Add(Job.Default
                     .WithLaunchCount(1) // benchmark process will be launched only once
-                    .WithIterationTime(TimeInterval.FromMilliseconds(100)) // 100ms per iteration
-                    .WithWarmupCount(3) // 3 warmup iteration
-                    .WithTargetCount(3)); // 3 target iteration
+                    .WithIterationTime(TimeInterval.FromMilliseconds(400)) 
+                    .WithWarmupCount(3)
+                    .WithTargetCount(6));
             }
         }
 
+        private readonly IFoo _foo = new Foo(null);
         private ConstructorInfo _ctorInfo;
         private Func<IFoo, IFoo> _dynamicMethod;
-        private Func<IFoo, IFoo> _expression;
-        private IFoo _foo = new Foo(null);
+        private Func<IFoo, IFoo> _expressionMethod;
+        private Func<IFoo, IFoo> _expressionMethod2;
+        private Func<IFoo, IFoo> _expressionMethod3;
+        private Func<IFoo, IFoo> _expressionMethod4;
 
         [Setup]
         public void Setup()
@@ -55,18 +55,91 @@ namespace Umbraco.Tests.Benchmarks
             //IL_000b: pop
             //IL_000c: ret
 
-            var meth = new DynamicMethod(string.Empty, typeof(Foo), ctorArgTypes, type.Module, true);
+            // generate a dynamic method
+            //
+            // ldarg.0      // obj0
+            // newobj instance void [Umbraco.Tests.Benchmarks]Umbraco.Tests.Benchmarks.CtorInvokeBenchmarks / Foo::.ctor(class [Umbraco.Tests.Benchmarks] Umbraco.Tests.Benchmarks.CtorInvokeBenchmarks/IFoo)
+            // ret
+
+            var meth = new DynamicMethod(string.Empty, typeof (IFoo), ctorArgTypes, type.Module, true);
             var gen = meth.GetILGenerator();
             gen.Emit(OpCodes.Ldarg_0);
-            //gen.Emit(OpCodes.Call, constructor);
             gen.Emit(OpCodes.Newobj, constructor);
             gen.Emit(OpCodes.Ret);
-            _dynamicMethod = (Func<IFoo, IFoo>) meth.CreateDelegate(typeof(Func<IFoo, IFoo>));
+            _dynamicMethod = (Func<IFoo, IFoo>) meth.CreateDelegate(typeof (Func<IFoo, IFoo>));
 
-            var exprArg = Expression.Parameter(typeof(IFoo), "content");
+            // generate a compiled expression
+            //
+            // ldarg.0      // content
+            // newobj instance void [Umbraco.Tests.Benchmarks]Umbraco.Tests.Benchmarks.CtorInvokeBenchmarks / Foo::.ctor(class [Umbraco.Tests.Benchmarks] Umbraco.Tests.Benchmarks.CtorInvokeBenchmarks/IFoo)
+            // ret
+
+            var exprArg = Expression.Parameter(typeof (IFoo), "content");
             var exprNew = Expression.New(constructor, exprArg);
             var expr = Expression.Lambda<Func<IFoo, IFoo>>(exprNew, exprArg);
-            _expression = expr.Compile();
+            _expressionMethod = expr.Compile();
+
+            // create a dynamic assembly
+            // dump to disk so we can review IL code with eg DotPeek
+
+            var assemblyName = new AssemblyName("Umbraco.Tests.Benchmarks.IL");
+            var assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Save);
+            var module = assembly.DefineDynamicModule(assemblyName.Name, assemblyName.Name + ".dll");
+            var typeBuilder = module.DefineType("CtorInvoke", TypeAttributes.Public | TypeAttributes.Abstract);
+
+            var expressionMethodBuilder = typeBuilder.DefineMethod("ExpressionCtor",
+                MethodAttributes.Public | MethodAttributes.Static, // CompileToMethod requires a static method
+                typeof (IFoo), ctorArgTypes);
+            expr.CompileToMethod(expressionMethodBuilder);
+
+            var dynamicMethodBuilder = typeBuilder.DefineMethod("DynamicCtor",
+                MethodAttributes.Public | MethodAttributes.Static,
+                typeof(IFoo), ctorArgTypes);
+            gen = dynamicMethodBuilder.GetILGenerator();
+            gen.Emit(OpCodes.Ldarg_0);
+            gen.Emit(OpCodes.Newobj, constructor);
+            gen.Emit(OpCodes.Ret);
+            meth.CreateDelegate(typeof (Func<IFoo, IFoo>));
+
+            var btype = typeBuilder.CreateType(); // need to build before saving
+            assembly.Save("Umbraco.Tests.Benchmarks.IL.dll");
+
+            // at that point,
+            //   _dynamicMethod is 2x slower than direct ctor
+            //   _expressionMethod is 6x slower than direct ctor
+            // which is weird as inspecting the assembly IL shows that they are generated
+            // exactly the same, and yet it is confirmed eg by https://stackoverflow.com/questions/4211418
+            //
+            // not sure why exactly
+            // see https://stackoverflow.com/questions/13431573
+            // see http://mattwarren.org/2017/01/25/How-do-.NET-delegates-work/#different-types-of-delegates
+            //
+            // note that all the benchmark methods have the very same IL code so it's
+            // really the 'callvirt ...' that ends up doing different things
+            //
+            // more readings:
+            // http://byterot.blogspot.dk/2012/05/performance-comparison-of-code.html
+            // https://stackoverflow.com/questions/1296683
+            // https://stackoverflow.com/questions/44239127
+            // that last one points to
+            // https://blogs.msdn.microsoft.com/seteplia/2017/02/01/dissecting-the-new-constraint-in-c-a-perfect-example-of-a-leaky-abstraction/
+            // which reads ... "Expression.Compile creates a DynamicMethod and associates it with an anonymous assembly
+            // to run it in a sandboxed environment. This makes it safe for a dynamic method to be emitted and executed
+            // by partially trusted code but adds some run-time overhead."
+            // and, turning things into a delegate (below) removes that overhead...
+
+            // turning it into a delegate seems cool, _expressionMethod2 is ~ _dynamicMethod
+            _expressionMethod2 = (Func<IFoo, IFoo>) Delegate.CreateDelegate(typeof (Func<IFoo, IFoo>), btype.GetMethod("ExpressionCtor"));
+
+            // nope, this won't work, throws an ArgumentException because 'MethodInfo must be a MethodInfo object'
+            // and here it's of type System.Reflection.Emit.DynamicMethod+RTDynamicMethod - whereas the btype one is ok
+            // so, the dynamic assembly step is required
+            //
+            //_expressionMethod3 = (Func<IFoo, IFoo>) Delegate.CreateDelegate(typeof (Func<IFoo, IFoo>), _expressionMethod.Method);
+
+            // but, our utilities know how to do it!
+            _expressionMethod3 = expr.CompileToDelegate();
+            _expressionMethod4 = ReflectionUtilities.GetCtor<Foo, IFoo>();
         }
 
         public IFoo IlCtor(IFoo foo)
@@ -74,7 +147,7 @@ namespace Umbraco.Tests.Benchmarks
             return new Foo(foo);
         }
 
-        [Benchmark]
+        [Benchmark(Baseline = true)]
         public void DirectCtor()
         {
             var foo = new Foo(_foo);
@@ -95,7 +168,25 @@ namespace Umbraco.Tests.Benchmarks
         [Benchmark]
         public void ExpressionCtor()
         {
-            var foo = _expression(_foo);
+            var foo = _expressionMethod(_foo);
+        }
+
+        [Benchmark]
+        public void Expression2Ctor()
+        {
+            var foo = _expressionMethod2(_foo);
+        }
+
+        [Benchmark]
+        public void Expression3Ctor()
+        {
+            var foo = _expressionMethod3(_foo);
+        }
+
+        [Benchmark]
+        public void Expression4Ctor()
+        {
+            var foo = _expressionMethod4(_foo);
         }
 
         public interface IFoo