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
|
/* ****************************************************************************
*
* 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 {
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Web.Mvc.Resources;
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) {
// Crack 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 {
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 = ExpressionUtil.CachedExpressionCompiler.Process(lambda);
}
catch (InvalidOperationException ex) {
throw new InvalidOperationException(
String.Format(
CultureInfo.CurrentUICulture,
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);
}
}
}
|
