huahaofeng
/
aspnetcore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Copy over two expression-support classes from legacy MVC

This commit is contained in:
dougbu 2014-03-27 20:14:03 -07:00
parent e8a76cfd7f
commit f108315038
2 changed files with 277 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

144
src/Microsoft.AspNet.Mvc.Rendering/Expressions/CachedExpressionCompiler.cs Normal file
View File

@ -0,0 +1,144 @@
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Reflection;
namespace System.Web.Mvc.ExpressionUtil
{
internal static class CachedExpressionCompiler
{
// This is the entry point to the cached expression compilation system. The system
// will try to turn the expression into an actual delegate as quickly as possible,
// relying on cache lookups and other techniques to save time if appropriate.
// If the provided expression is particularly obscure and the system doesn't know
// how to handle it, we'll just compile the expression as normal.
public static Func<TModel, TValue> Process<TModel, TValue>(Expression<Func<TModel, TValue>> lambdaExpression)
{
return Compiler<TModel, TValue>.Compile(lambdaExpression);
}
private static class Compiler<TIn, TOut>
{
private static Func<TIn, TOut> _identityFunc;
private static readonly ConcurrentDictionary<MemberInfo, Func<TIn, TOut>> _simpleMemberAccessDict =
new ConcurrentDictionary<MemberInfo, Func<TIn, TOut>>();
private static readonly ConcurrentDictionary<MemberInfo, Func<object, TOut>> _constMemberAccessDict =
new ConcurrentDictionary<MemberInfo, Func<object, TOut>>();
private static readonly ConcurrentDictionary<ExpressionFingerprintChain, Hoisted<TIn, TOut>> _fingerprintedCache =
new ConcurrentDictionary<ExpressionFingerprintChain, Hoisted<TIn, TOut>>();
public static Func<TIn, TOut> Compile(Expression<Func<TIn, TOut>> expr)
{
return CompileFromIdentityFunc(expr)
?? CompileFromConstLookup(expr)
?? CompileFromMemberAccess(expr)
?? CompileFromFingerprint(expr)
?? CompileSlow(expr);
}
private static Func<TIn, TOut> CompileFromConstLookup(Expression<Func<TIn, TOut>> expr)
{
ConstantExpression constExpr = expr.Body as ConstantExpression;
if (constExpr != null)
{
// model => {const}
TOut constantValue = (TOut)constExpr.Value;
return _ => constantValue;
}
return null;
}
private static Func<TIn, TOut> CompileFromIdentityFunc(Expression<Func<TIn, TOut>> expr)
{
if (expr.Body == expr.Parameters[0])
{
// model => model
// don't need to lock, as all identity funcs are identical
if (_identityFunc == null)
{
_identityFunc = expr.Compile();
}
return _identityFunc;
}
return null;
}
private static Func<TIn, TOut> CompileFromFingerprint(Expression<Func<TIn, TOut>> expr)
{
List<object> capturedConstants;
ExpressionFingerprintChain fingerprint = FingerprintingExpressionVisitor.GetFingerprintChain(expr, out capturedConstants);
if (fingerprint != null)
{
var del = _fingerprintedCache.GetOrAdd(fingerprint, _ =>
{
// Fingerprinting succeeded, but there was a cache miss. Rewrite the expression
// and add the rewritten expression to the cache.
var hoistedExpr = HoistingExpressionVisitor<TIn, TOut>.Hoist(expr);
return hoistedExpr.Compile();
});
return model => del(model, capturedConstants);
}
// couldn't be fingerprinted
return null;
}
private static Func<TIn, TOut> CompileFromMemberAccess(Expression<Func<TIn, TOut>> expr)
{
// Performance tests show that on the x64 platform, special-casing static member and
// captured local variable accesses is faster than letting the fingerprinting system
// handle them. On the x86 platform, the fingerprinting system is faster, but only
// by around one microsecond, so it's not worth it to complicate the logic here with
// an architecture check.
MemberExpression memberExpr = expr.Body as MemberExpression;
if (memberExpr != null)
{
if (memberExpr.Expression == expr.Parameters[0] || memberExpr.Expression == null)
{
// model => model.Member or model => StaticMember
return _simpleMemberAccessDict.GetOrAdd(memberExpr.Member, _ => expr.Compile());
}
ConstantExpression constExpr = memberExpr.Expression as ConstantExpression;
if (constExpr != null)
{
// model => {const}.Member (captured local variable)
var del = _constMemberAccessDict.GetOrAdd(memberExpr.Member, _ =>
{
// rewrite as capturedLocal => ((TDeclaringType)capturedLocal).Member
var constParamExpr = Expression.Parameter(typeof(object), "capturedLocal");
var constCastExpr = Expression.Convert(constParamExpr, memberExpr.Member.DeclaringType);
var newMemberAccessExpr = memberExpr.Update(constCastExpr);
var newLambdaExpr = Expression.Lambda<Func<object, TOut>>(newMemberAccessExpr, constParamExpr);
return newLambdaExpr.Compile();
});
object capturedLocal = constExpr.Value;
return _ => del(capturedLocal);
}
}
return null;
}
private static Func<TIn, TOut> CompileSlow(Expression<Func<TIn, TOut>> expr)
{
// fallback compilation system - just compile the expression directly
return expr.Compile();
}
}
}
}

133
src/Microsoft.AspNet.Mvc.Rendering/Expressions/ExpressionHelper.cs Normal file
View File

@ -0,0 +1,133 @@
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Web.Mvc.ExpressionUtil;
using System.Web.Mvc.Properties;
namespace System.Web.Mvc
{
public static class ExpressionHelper
{
public static string GetExpressionText(string expression)
{
return
String.Equals(expression, "model", StringComparison.OrdinalIgnoreCase)
? String.Empty // If it's exactly "model", then give them an empty string, to replicate the lambda behavior
: expression;
}
public static string GetExpressionText(LambdaExpression expression)
{
// Split apart the expression string for property/field accessors to create its name
Stack<string> nameParts = new Stack<string>();
Expression part = expression.Body;
while (part != null)
{
if (part.NodeType == ExpressionType.Call)
{
MethodCallExpression methodExpression = (MethodCallExpression)part;
if (!IsSingleArgumentIndexer(methodExpression))
{
break;
}
nameParts.Push(
GetIndexerInvocation(
methodExpression.Arguments.Single(),
expression.Parameters.ToArray()));
part = methodExpression.Object;
}
else if (part.NodeType == ExpressionType.ArrayIndex)
{
BinaryExpression binaryExpression = (BinaryExpression)part;
nameParts.Push(
GetIndexerInvocation(
binaryExpression.Right,
expression.Parameters.ToArray()));
part = binaryExpression.Left;
}
else if (part.NodeType == ExpressionType.MemberAccess)
{
MemberExpression memberExpressionPart = (MemberExpression)part;
nameParts.Push("." + memberExpressionPart.Member.Name);
part = memberExpressionPart.Expression;
}
else if (part.NodeType == ExpressionType.Parameter)
{
// Dev10 Bug #907611
// When the expression is parameter based (m => m.Something...), we'll push an empty
// string onto the stack and stop evaluating. The extra empty string makes sure that
// we don't accidentally cut off too much of m => m.Model.
nameParts.Push(String.Empty);
part = null;
}
else
{
break;
}
}
// If it starts with "model", then strip that away
if (nameParts.Count > 0 && String.Equals(nameParts.Peek(), ".model", StringComparison.OrdinalIgnoreCase))
{
nameParts.Pop();
}
if (nameParts.Count > 0)
{
return nameParts.Aggregate((left, right) => left + right).TrimStart('.');
}
return String.Empty;
}
private static string GetIndexerInvocation(Expression expression, ParameterExpression[] parameters)
{
Expression converted = Expression.Convert(expression, typeof(object));
ParameterExpression fakeParameter = Expression.Parameter(typeof(object), null);
Expression<Func<object, object>> lambda = Expression.Lambda<Func<object, object>>(converted, fakeParameter);
Func<object, object> func;
try
{
func = CachedExpressionCompiler.Process(lambda);
}
catch (InvalidOperationException ex)
{
throw new InvalidOperationException(
String.Format(
CultureInfo.CurrentCulture,
MvcResources.ExpressionHelper_InvalidIndexerExpression,
expression,
parameters[0].Name),
ex);
}
return "[" + Convert.ToString(func(null), CultureInfo.InvariantCulture) + "]";
}
internal static bool IsSingleArgumentIndexer(Expression expression)
{
MethodCallExpression methodExpression = expression as MethodCallExpression;
if (methodExpression == null || methodExpression.Arguments.Count != 1)
{
return false;
}
return methodExpression.Method
.DeclaringType
.GetDefaultMembers()
.OfType<PropertyInfo>()
.Any(p => p.GetGetMethod() == methodExpression.Method);
}
}
}