mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
385 lines
18 KiB
C#
385 lines
18 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="CodeDomUtility.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.Compilation {
|
|
|
|
using System.Text;
|
|
using System.Runtime.Serialization.Formatters;
|
|
using System.ComponentModel;
|
|
using System.ComponentModel.Design.Serialization;
|
|
using System;
|
|
using System.Collections;
|
|
using System.Reflection;
|
|
using System.IO;
|
|
using System.Globalization;
|
|
using System.Web.Util;
|
|
using System.Web.UI;
|
|
using System.Web.Configuration;
|
|
using System.Diagnostics;
|
|
using Debug = System.Diagnostics.Debug;
|
|
using System.CodeDom;
|
|
using System.CodeDom.Compiler;
|
|
using Util = System.Web.UI.Util;
|
|
|
|
internal static class CodeDomUtility {
|
|
|
|
internal static BooleanSwitch WebFormsCompilation = new BooleanSwitch("WebFormsCompilation", "Outputs information about the WebForms compilation of ASPX templates");
|
|
|
|
internal /*public*/ static CodeExpression GenerateExpressionForValue(PropertyInfo propertyInfo, object value, Type valueType) {
|
|
#if DEBUG
|
|
if (WebFormsCompilation.Enabled) {
|
|
Debug.WriteLine("GenerateExpressionForValue() {");
|
|
Debug.Indent();
|
|
}
|
|
#endif // DEBUG
|
|
CodeExpression rightExpr = null;
|
|
|
|
if (valueType == null) {
|
|
throw new ArgumentNullException("valueType");
|
|
}
|
|
|
|
PropertyDescriptor pd = null;
|
|
if (propertyInfo != null) {
|
|
pd = TypeDescriptor.GetProperties(propertyInfo.ReflectedType)[propertyInfo.Name];
|
|
}
|
|
|
|
if (valueType == typeof(string) && value is string) {
|
|
if (WebFormsCompilation.Enabled) Debug.WriteLine("simple string");
|
|
rightExpr = new CodePrimitiveExpression((string)value);
|
|
}
|
|
else if (valueType.IsPrimitive) {
|
|
if (WebFormsCompilation.Enabled) Debug.WriteLine("primitive");
|
|
rightExpr = new CodePrimitiveExpression(value);
|
|
}
|
|
else if (propertyInfo == null && valueType == typeof(object) &&
|
|
(value == null || value.GetType().IsPrimitive)) {
|
|
|
|
// If the type is object, and the value is a primitive, simply use a
|
|
// CodePrimitiveExpression instead of trying to use a TypeConverter (VSWhidbey 518773)
|
|
if (WebFormsCompilation.Enabled) Debug.WriteLine("primitive to object");
|
|
rightExpr = new CodePrimitiveExpression(value);
|
|
}
|
|
else if (valueType.IsArray) {
|
|
if (WebFormsCompilation.Enabled) Debug.WriteLine("array");
|
|
Array array = (Array)value;
|
|
CodeArrayCreateExpression exp = new CodeArrayCreateExpression();
|
|
exp.CreateType = new CodeTypeReference(valueType.GetElementType());
|
|
if (array != null) {
|
|
foreach (object o in array) {
|
|
exp.Initializers.Add(GenerateExpressionForValue(null, o, valueType.GetElementType()));
|
|
}
|
|
}
|
|
rightExpr = exp;
|
|
}
|
|
else if (valueType == typeof(Type)) {
|
|
rightExpr = new CodeTypeOfExpression((Type) value);
|
|
}
|
|
else {
|
|
if (WebFormsCompilation.Enabled) Debug.WriteLine("other");
|
|
TypeConverter converter = null;
|
|
if (pd != null) {
|
|
converter = pd.Converter;
|
|
}
|
|
else {
|
|
converter = TypeDescriptor.GetConverter(valueType);
|
|
}
|
|
|
|
bool added = false;
|
|
|
|
if (converter != null) {
|
|
InstanceDescriptor desc = null;
|
|
|
|
if (converter.CanConvertTo(typeof(InstanceDescriptor))) {
|
|
desc = (InstanceDescriptor)converter.ConvertTo(value, typeof(InstanceDescriptor));
|
|
}
|
|
if (desc != null) {
|
|
if (WebFormsCompilation.Enabled) Debug.WriteLine("has converter with instance descriptor");
|
|
|
|
// static field ref...
|
|
//
|
|
if (desc.MemberInfo is FieldInfo) {
|
|
if (WebFormsCompilation.Enabled) Debug.WriteLine("persistinfo is a field ref");
|
|
CodeFieldReferenceExpression fieldRef = new CodeFieldReferenceExpression(BuildGlobalCodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name);
|
|
rightExpr = fieldRef;
|
|
added = true;
|
|
}
|
|
// static property ref
|
|
else if (desc.MemberInfo is PropertyInfo) {
|
|
if (WebFormsCompilation.Enabled) Debug.WriteLine("persistinfo is a property ref");
|
|
CodePropertyReferenceExpression propRef = new CodePropertyReferenceExpression(BuildGlobalCodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name);
|
|
rightExpr = propRef;
|
|
added = true;
|
|
}
|
|
|
|
// static method invoke
|
|
//
|
|
else {
|
|
object[] args = new object[desc.Arguments.Count];
|
|
desc.Arguments.CopyTo(args, 0);
|
|
CodeExpression[] expressions = new CodeExpression[args.Length];
|
|
|
|
if (desc.MemberInfo is MethodInfo) {
|
|
MethodInfo mi = (MethodInfo)desc.MemberInfo;
|
|
ParameterInfo[] parameters = mi.GetParameters();
|
|
|
|
for(int i = 0; i < args.Length; i++) {
|
|
expressions[i] = GenerateExpressionForValue(null, args[i], parameters[i].ParameterType);
|
|
}
|
|
|
|
if (WebFormsCompilation.Enabled) Debug.WriteLine("persistinfo is a method invoke");
|
|
CodeMethodInvokeExpression methCall = new CodeMethodInvokeExpression(BuildGlobalCodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name);
|
|
foreach (CodeExpression e in expressions) {
|
|
methCall.Parameters.Add(e);
|
|
}
|
|
rightExpr = new CodeCastExpression(valueType, methCall);
|
|
added = true;
|
|
}
|
|
else if (desc.MemberInfo is ConstructorInfo) {
|
|
ConstructorInfo ci = (ConstructorInfo)desc.MemberInfo;
|
|
ParameterInfo[] parameters = ci.GetParameters();
|
|
|
|
for(int i = 0; i < args.Length; i++) {
|
|
expressions[i] = GenerateExpressionForValue(null, args[i], parameters[i].ParameterType);
|
|
}
|
|
|
|
if (WebFormsCompilation.Enabled) Debug.WriteLine("persistinfo is a constructor call");
|
|
CodeObjectCreateExpression objectCreate = new CodeObjectCreateExpression(desc.MemberInfo.DeclaringType.FullName);
|
|
foreach (CodeExpression e in expressions) {
|
|
objectCreate.Parameters.Add(e);
|
|
}
|
|
rightExpr = objectCreate;
|
|
added = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!added) {
|
|
#if DEBUG
|
|
if (WebFormsCompilation.Enabled) {
|
|
Debug.WriteLine("unabled to determine type, attempting Parse");
|
|
Debug.Indent();
|
|
Debug.WriteLine("value.GetType == " + value.GetType().FullName);
|
|
Debug.WriteLine("value.ToString == " + value.ToString());
|
|
Debug.WriteLine("valueType == " + valueType.FullName);
|
|
if (propertyInfo != null) {
|
|
Debug.WriteLine("propertyInfo == " + propertyInfo.ReflectedType.FullName + "." + propertyInfo.Name + " : " + propertyInfo.PropertyType.FullName);
|
|
}
|
|
else {
|
|
Debug.WriteLine("propertyInfo == (null)");
|
|
}
|
|
|
|
Debug.Unindent();
|
|
}
|
|
#endif // DEBUG
|
|
|
|
|
|
// Not a known type: try calling Parse
|
|
|
|
// If possible, pass it an InvariantCulture (ASURT 79412)
|
|
if (valueType.GetMethod("Parse", new Type[] {typeof(string), typeof(CultureInfo)}) != null) {
|
|
CodeMethodInvokeExpression methCall = new CodeMethodInvokeExpression(BuildGlobalCodeTypeReferenceExpression(valueType.FullName), "Parse");
|
|
|
|
// Convert the object to a string.
|
|
// If we have a type converter, use it to convert to a string in a culture
|
|
// invariant way (ASURT 87094)
|
|
string s;
|
|
if (converter != null) {
|
|
s = converter.ConvertToInvariantString(value);
|
|
}
|
|
else {
|
|
s = value.ToString();
|
|
}
|
|
|
|
methCall.Parameters.Add(new CodePrimitiveExpression(s));
|
|
methCall.Parameters.Add(new CodePropertyReferenceExpression(BuildGlobalCodeTypeReferenceExpression(typeof(CultureInfo)), "InvariantCulture"));
|
|
rightExpr = methCall;
|
|
|
|
}
|
|
else if (valueType.GetMethod("Parse", new Type[] {typeof(string)}) != null) {
|
|
// Otherwise, settle for passing just the string
|
|
CodeMethodInvokeExpression methCall = new CodeMethodInvokeExpression(BuildGlobalCodeTypeReferenceExpression(valueType.FullName), "Parse");
|
|
methCall.Parameters.Add(new CodePrimitiveExpression(value.ToString()));
|
|
rightExpr = methCall;
|
|
|
|
}
|
|
else {
|
|
throw new HttpException(SR.GetString(SR.CantGenPropertySet, propertyInfo.Name, valueType.FullName));
|
|
}
|
|
}
|
|
}
|
|
|
|
#if DEBUG
|
|
if (WebFormsCompilation.Enabled) {
|
|
Debug.Unindent();
|
|
Debug.WriteLine("}");
|
|
}
|
|
#endif // DEBUG
|
|
return rightExpr;
|
|
}
|
|
|
|
// Adds a property assignment statement to "statements". This takes into account
|
|
// checking for nulls when the destination property type is a value type. This can
|
|
// also generate expressions that use IAttributeAccessor when desinationType is null.
|
|
internal static void CreatePropertySetStatements(CodeStatementCollection methodStatements, CodeStatementCollection statements,
|
|
CodeExpression target, string targetPropertyName, Type destinationType,
|
|
CodeExpression value,
|
|
CodeLinePragma linePragma) {
|
|
// Generates:
|
|
// If destination is property:
|
|
// If destination type is string:
|
|
// {{target}}.{{targetPropertyName}} = System.Convert.ToString( {{value}} );
|
|
// Else If destination type is reference type:
|
|
// {{target}}.{{targetPropertyName}} = ( {{destinationType}} ) {{value}};
|
|
// Else destination type is value type:
|
|
// {{target}}.{{targetPropertyName}} = ( {{destinationType}} ) ({value});
|
|
// Else use SetAttribute (expandos):
|
|
// ((IAttributeAccessor) {{target}} ).SetAttribute( {{targetPropertyName}} , System.Convert.ToString( {{value}} ));
|
|
|
|
bool useSetAttribute = false;
|
|
// This signifies it's using SetAttribute
|
|
if (destinationType == null) {
|
|
useSetAttribute = true;
|
|
}
|
|
|
|
if (useSetAttribute) {
|
|
// ((IAttributeAccessor) {{target}} ).SetAttribute( {{targetPropertyName}} , System.Convert.ToString( {{value}} ));
|
|
CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression();
|
|
CodeExpressionStatement setAttributeCall = new CodeExpressionStatement(methodInvoke);
|
|
setAttributeCall.LinePragma = linePragma;
|
|
|
|
// Dev11 128332: Ensure style attribute on html control is lowercase as required for xhtml validation
|
|
if (targetPropertyName.Equals("Style", StringComparison.Ordinal)) {
|
|
targetPropertyName = "style";
|
|
}
|
|
|
|
methodInvoke.Method.TargetObject = new CodeCastExpression(typeof(IAttributeAccessor), target);
|
|
methodInvoke.Method.MethodName = "SetAttribute";
|
|
methodInvoke.Parameters.Add(new CodePrimitiveExpression(targetPropertyName));
|
|
|
|
methodInvoke.Parameters.Add(GenerateConvertToString(value));
|
|
|
|
statements.Add(setAttributeCall);
|
|
}
|
|
else {
|
|
// Use the property setter. Must take into account that null cannot be
|
|
// cast to a value type, so we have to explicitly check for that in
|
|
// the code we generate.
|
|
|
|
if (destinationType.IsValueType) {
|
|
// {{target}}.{{targetPropertyName}} = ( {{destinationType}} ) ({value});
|
|
CodeAssignStatement assignStmt = new CodeAssignStatement(
|
|
BuildPropertyReferenceExpression(target, targetPropertyName),
|
|
new CodeCastExpression(destinationType, value));
|
|
assignStmt.LinePragma = linePragma;
|
|
statements.Add(assignStmt);
|
|
}
|
|
else {
|
|
CodeExpression rightSide;
|
|
|
|
if (destinationType == typeof(string)) {
|
|
// {{target}}.{{targetPropertyName}} = System.Convert.ToString( {{value}} );
|
|
rightSide = GenerateConvertToString(value);
|
|
}
|
|
else {
|
|
// {{target}}.{{targetPropertyName}} = ( {{destinationType}} ) {{value}};
|
|
rightSide = new CodeCastExpression(destinationType, value);
|
|
}
|
|
|
|
CodeAssignStatement assignStmt = new CodeAssignStatement(
|
|
BuildPropertyReferenceExpression(target, targetPropertyName),
|
|
rightSide);
|
|
assignStmt.LinePragma = linePragma;
|
|
statements.Add(assignStmt);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Generate a call to System.Convert.ToString(value, CultureInfo.CurrentCulture)
|
|
internal static CodeExpression GenerateConvertToString(CodeExpression value) {
|
|
|
|
CodeMethodInvokeExpression invokeExpr = new CodeMethodInvokeExpression();
|
|
invokeExpr.Method.TargetObject = BuildGlobalCodeTypeReferenceExpression(typeof(System.Convert));
|
|
invokeExpr.Method.MethodName = "ToString";
|
|
invokeExpr.Parameters.Add(value);
|
|
invokeExpr.Parameters.Add(new CodePropertyReferenceExpression(
|
|
BuildGlobalCodeTypeReferenceExpression(typeof(CultureInfo)), "CurrentCulture"));
|
|
|
|
return invokeExpr;
|
|
}
|
|
|
|
// Prepend a string TO the CompilerOptions string
|
|
internal static void PrependCompilerOption(
|
|
CompilerParameters compilParams, string compilerOptions) {
|
|
|
|
if (compilParams.CompilerOptions == null)
|
|
compilParams.CompilerOptions = compilerOptions;
|
|
else
|
|
compilParams.CompilerOptions = compilerOptions + " " + compilParams.CompilerOptions;
|
|
}
|
|
|
|
// Append a string to the CompilerOptions string
|
|
internal static void AppendCompilerOption(
|
|
CompilerParameters compilParams, string compilerOptions) {
|
|
|
|
if (compilParams.CompilerOptions == null)
|
|
compilParams.CompilerOptions = compilerOptions;
|
|
else
|
|
compilParams.CompilerOptions = compilParams.CompilerOptions + " " + compilerOptions;
|
|
}
|
|
|
|
internal static CodeExpression BuildPropertyReferenceExpression(
|
|
CodeExpression objRefExpr, string propName) {
|
|
|
|
// The name may contain several '.' separated properties, so we
|
|
// need to make sure we build the CodeDom accordingly (ASURT 91875, VSWhidbey 313018)
|
|
string[] parts = propName.Split('.');
|
|
CodeExpression ret = objRefExpr;
|
|
foreach (string part in parts)
|
|
ret = new CodePropertyReferenceExpression(ret, part);
|
|
|
|
return ret;
|
|
}
|
|
|
|
internal static CodeCastExpression BuildJSharpCastExpression(Type castType, CodeExpression expression) {
|
|
|
|
// VJ# does not support automatic boxing of value types, so passing a simple type, say a bool, into a method
|
|
// expecting an object will give a compiler error. We are working around this issue by adding special code for
|
|
// VJ# that will cast the expression for boxing. When the VJ# team adds implicit boxing of value types, we
|
|
// should remove this code. VSWhidbey 269028
|
|
CodeCastExpression castedExpression = new CodeCastExpression(castType, expression);
|
|
castedExpression.UserData.Add("CastIsBoxing", true);
|
|
return castedExpression;
|
|
}
|
|
|
|
internal static CodeTypeReference BuildGlobalCodeTypeReference(string typeName) {
|
|
return new CodeTypeReference(typeName, CodeTypeReferenceOptions.GlobalReference);
|
|
}
|
|
|
|
internal static CodeTypeReference BuildGlobalCodeTypeReference(Type type) {
|
|
return new CodeTypeReference(type, CodeTypeReferenceOptions.GlobalReference);
|
|
}
|
|
|
|
private static CodeTypeReferenceExpression BuildGlobalCodeTypeReferenceExpression(string typeName) {
|
|
// Returns an expression that resolves the type name from the root namespace,
|
|
// eg global::Namespace.TypeName
|
|
CodeTypeReference codeTypeReference = BuildGlobalCodeTypeReference(typeName);
|
|
CodeTypeReferenceExpression codeTypeReferenceExpression = new CodeTypeReferenceExpression(codeTypeReference);
|
|
return codeTypeReferenceExpression;
|
|
}
|
|
|
|
private static CodeTypeReferenceExpression BuildGlobalCodeTypeReferenceExpression(Type type) {
|
|
// Returns an expression that resolves the type name from the root namespace,
|
|
// eg global::Namespace.TypeName
|
|
CodeTypeReference codeTypeReference = BuildGlobalCodeTypeReference(type);
|
|
CodeTypeReferenceExpression codeTypeReferenceExpression = new CodeTypeReferenceExpression(codeTypeReference);
|
|
return codeTypeReferenceExpression;
|
|
}
|
|
|
|
}
|
|
}
|
|
|