1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
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();
}
}
}
}
|
