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
|
//------------------------------------------------------------------------------
// <copyright file="ExpressionBuilder.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.Compilation {
using System;
using System.CodeDom;
using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel.Design;
using System.Web.Configuration;
using System.Reflection;
using System.Web;
using System.Web.Hosting;
#if !FEATURE_PAL
using System.Web.UI.Design;
#endif // !FEATURE_PAL
using System.Web.UI;
using System.Web.Util;
public abstract class ExpressionBuilder {
private static ExpressionBuilder dataBindingExpressionBuilder;
internal virtual void BuildExpression(BoundPropertyEntry bpe, ControlBuilder controlBuilder,
CodeExpression controlReference, CodeStatementCollection methodStatements, CodeStatementCollection statements, CodeLinePragma linePragma, ref bool hasTempObject) {
CodeExpression codeExpression = GetCodeExpression(bpe,
bpe.ParsedExpressionData, new ExpressionBuilderContext(controlBuilder.VirtualPath));
CodeDomUtility.CreatePropertySetStatements(methodStatements, statements,
controlReference, bpe.Name, bpe.Type,
codeExpression,
linePragma);
}
internal static ExpressionBuilder GetExpressionBuilder(string expressionPrefix, VirtualPath virtualPath) {
return GetExpressionBuilder(expressionPrefix, virtualPath, null);
}
internal static ExpressionBuilder GetExpressionBuilder(string expressionPrefix, VirtualPath virtualPath, IDesignerHost host) {
// If there is no expressionPrefix, it's a v1 style databinding expression
if (expressionPrefix.Length == 0) {
if (dataBindingExpressionBuilder == null) {
dataBindingExpressionBuilder = new DataBindingExpressionBuilder();
}
return dataBindingExpressionBuilder;
}
CompilationSection config = null;
// If we are in the designer, we need to access IWebApplication config instead
#if !FEATURE_PAL // FEATURE_PAL does not support designer-based features
if (host != null) {
IWebApplication webapp = (IWebApplication)host.GetService(typeof(IWebApplication));
if (webapp != null) {
config = webapp.OpenWebConfiguration(true).GetSection("system.web/compilation") as CompilationSection;
}
}
#endif // !FEATURE_PAL
// If we failed to get config from the designer, fall back on runtime config always
if (config == null) {
config = MTConfigUtil.GetCompilationConfig(virtualPath);
}
System.Web.Configuration.ExpressionBuilder builder = config.ExpressionBuilders[expressionPrefix];
if (builder == null) {
throw new HttpParseException(SR.GetString(SR.InvalidExpressionPrefix, expressionPrefix));
}
Type expressionBuilderType = null;
if (host != null) {
// If we are in the designer, we have to use the type resolution service
ITypeResolutionService ts = (ITypeResolutionService)host.GetService(typeof(ITypeResolutionService));
if (ts != null) {
expressionBuilderType = ts.GetType(builder.Type);
}
}
if (expressionBuilderType == null) {
expressionBuilderType = builder.TypeInternal;
}
Debug.Assert(expressionBuilderType != null, "expressionBuilderType should not be null");
if (!typeof(ExpressionBuilder).IsAssignableFrom(expressionBuilderType)) {
throw new HttpParseException(SR.GetString(SR.ExpressionBuilder_InvalidType, expressionBuilderType.FullName));
}
ExpressionBuilder expressionBuilder = (ExpressionBuilder)HttpRuntime.FastCreatePublicInstance(expressionBuilderType);
return expressionBuilder;
}
//
// Public API
//
public virtual bool SupportsEvaluate {
get {
return false;
}
}
public virtual object ParseExpression(string expression, Type propertyType, ExpressionBuilderContext context) {
return null;
}
public abstract CodeExpression GetCodeExpression(BoundPropertyEntry entry,
object parsedData, ExpressionBuilderContext context);
public virtual object EvaluateExpression(object target, BoundPropertyEntry entry,
object parsedData, ExpressionBuilderContext context) {
return null;
}
}
}
|
