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
|
/* ****************************************************************************
*
* Copyright (c) Microsoft Corporation. All rights reserved.
*
* This software is subject to the Microsoft Public License (Ms-PL).
* A copy of the license can be found in the license.htm file included
* in this distribution.
*
* You must not remove this notice, or any other, from this software.
*
* ***************************************************************************/
namespace System.Web.Mvc.ExpressionUtil {
using System;
using System.Linq.Expressions;
using System.Reflection;
internal static class FastTrack<TModel, TValue> {
private static Func<TModel, TValue> _identityFunc;
private static readonly ConstMemberLookupCache _constMemberLookupCache = new ConstMemberLookupCache();
private static readonly ModelMemberLookupCache _modelMemberLookupCache = new ModelMemberLookupCache();
public static Func<TModel, TValue> GetFunc(ParameterExpression modelParameter, Expression body) {
{ // model => model
if (modelParameter == body) {
return GetIdentityFunc();
}
}
{ // model => {const}
ConstantExpression constantExpression = body as ConstantExpression;
if (constantExpression != null) {
TValue value = (TValue)constantExpression.Value;
return _ => value;
}
}
{
MemberExpression memberExpression = body as MemberExpression;
if (memberExpression != null) {
if (memberExpression.Expression == null) {
// model => {static member}
return GetModelMemberLookupFunc(memberExpression.Member, true /* isStatic */);
}
else if (memberExpression.Expression == modelParameter) {
// model => model.Member
return GetModelMemberLookupFunc(memberExpression.Member, false /* isStatic */);
}
else {
ConstantExpression constantExpression = memberExpression.Expression as ConstantExpression;
if (constantExpression != null) {
// model => {const}.Member, e.g. captured local variable in a foreach
return GetConstMemberLookupFunc(memberExpression.Member, constantExpression.Value);
}
}
}
}
// don't know how to fast-track
return null;
}
private static Func<TModel, TValue> GetIdentityFunc() {
// don't need to worry about locking since all identity funcs are the same
if (_identityFunc == null) {
ParameterExpression modelParameter = Expression.Parameter(typeof(TModel), "model");
Expression<Func<TModel, TValue>> identityLambda = Expression.Lambda<Func<TModel, TValue>>(modelParameter, modelParameter);
_identityFunc = identityLambda.Compile();
}
return _identityFunc;
}
private static Func<TModel, TValue> GetModelMemberLookupFunc(MemberInfo member, bool isStatic) {
return _modelMemberLookupCache.GetFunc(member, isStatic);
}
private static Func<TModel, TValue> GetConstMemberLookupFunc(MemberInfo member, object constValue) {
Func<object, TValue> innerFunc = _constMemberLookupCache.GetFunc(member);
return _ => innerFunc(constValue);
}
private sealed class ConstMemberLookupCache : ReaderWriterCache<MemberInfo, Func<object, TValue>> {
private static Func<object, TValue> CreateFunc(MemberInfo member) {
ParameterExpression constParam = Expression.Parameter(typeof(object), "constValue");
// cast is necessary since the constant value comes in as a standard 'object'
UnaryExpression castExpr = Expression.Convert(constParam, member.DeclaringType);
MemberExpression memberExpr = Expression.MakeMemberAccess(castExpr, member);
Expression<Func<object, TValue>> lambda = Expression.Lambda<Func<object, TValue>>(memberExpr, constParam);
return lambda.Compile();
}
public Func<object, TValue> GetFunc(MemberInfo member) {
return FetchOrCreateItem(member, () => CreateFunc(member));
}
}
private sealed class ModelMemberLookupCache : ReaderWriterCache<MemberInfo, Func<TModel, TValue>> {
private static Func<TModel, TValue> CreateFunc(MemberInfo member, bool isStatic) {
ParameterExpression modelParam = Expression.Parameter(typeof(TModel), "model");
MemberExpression memberExpr = Expression.MakeMemberAccess((!isStatic) ? modelParam : null, member);
Expression<Func<TModel, TValue>> lambda = Expression.Lambda<Func<TModel, TValue>>(memberExpr, modelParam);
return lambda.Compile();
}
public Func<TModel, TValue> GetFunc(MemberInfo member, bool isStatic) {
return FetchOrCreateItem(member, () => CreateFunc(member, isStatic));
}
}
}
}
|
