Files
mono/mcs/class/referencesource/System.Web/Compilation/ObjectFactoryCodeDomTreeGenerator.cs
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
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
2016-05-03 00:07:37 +02:00

129 lines
4.9 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="ObjectFactoryCodeDomTreeGenerator.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
// This code is used to optimize the instantiation of generated types.
namespace System.Web.Compilation {
using System;
using System.Collections;
using System.Reflection;
using System.Security.Permissions;
using System.Globalization;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Web.Util;
using Util = System.Web.UI.Util;
internal delegate object InstantiateObject();
internal class ObjectFactoryCodeDomTreeGenerator {
private CodeCompileUnit _codeCompileUnit;
private CodeTypeDeclaration _factoryClass;
private const string factoryClassNameBase = "FastObjectFactory_";
private const string factoryFullClassNameBase = BaseCodeDomTreeGenerator.internalAspNamespace +
"." + factoryClassNameBase;
internal ObjectFactoryCodeDomTreeGenerator(string outputAssemblyName) {
_codeCompileUnit = new CodeCompileUnit();
CodeNamespace sourceDataNamespace = new CodeNamespace(
BaseCodeDomTreeGenerator.internalAspNamespace);
_codeCompileUnit.Namespaces.Add(sourceDataNamespace);
// Make the class name vary based on the assembly (VSWhidbey 363214)
string factoryClassName = factoryClassNameBase +
Util.MakeValidTypeNameFromString(outputAssemblyName).ToLower(CultureInfo.InvariantCulture);
// Create a single class, in which a method will be added for each
// type that needs to be fast created in this assembly
_factoryClass = new CodeTypeDeclaration(factoryClassName);
// Make the class internal (VSWhidbey 363214)
_factoryClass.TypeAttributes &= ~TypeAttributes.Public;
// We generate a dummy line pragma, just so it will end with a '#line hidden'
// and prevent the following generated code from ever being treated as user
// code. We need to use this hack because CodeDOM doesn't allow simply generating
// a '#line hidden'. (VSWhidbey 199384)
CodeSnippetTypeMember dummySnippet = new CodeSnippetTypeMember(String.Empty);
#if !PLATFORM_UNIX /// Unix file system
// CORIOLISTODO: Unix file system
dummySnippet.LinePragma = new CodeLinePragma(@"c:\\dummy.txt", 1);
#else // !PLATFORM_UNIX
dummySnippet.LinePragma = new CodeLinePragma(@"/dummy.txt", 1);
#endif // !PLATFORM_UNIX
_factoryClass.Members.Add(dummySnippet);
// Add a private default ctor to make the class non-instantiatable (VSWhidbey 340829)
CodeConstructor ctor = new CodeConstructor();
ctor.Attributes |= MemberAttributes.Private;
_factoryClass.Members.Add(ctor);
sourceDataNamespace.Types.Add(_factoryClass);
}
internal void AddFactoryMethod(string typeToCreate) {
// Generate a simple factory method for this type. e.g.
// static object Create_Acme_Foo() {
// return new ASP.foo_aspx();
// }
CodeMemberMethod method = new CodeMemberMethod();
method.Name = GetCreateMethodNameForType(typeToCreate);
method.ReturnType = new CodeTypeReference(typeof(object));
method.Attributes = MemberAttributes.Static;
CodeMethodReturnStatement cmrs = new CodeMethodReturnStatement(
new CodeObjectCreateExpression(typeToCreate));
method.Statements.Add(cmrs);
_factoryClass.Members.Add(method);
}
private static string GetCreateMethodNameForType(string typeToCreate) {
return "Create_" + Util.MakeValidTypeNameFromString(typeToCreate);
}
internal CodeCompileUnit CodeCompileUnit {
get { return _codeCompileUnit; }
}
// Get the factory delegate for this type
// Could be called with user code on the stack, so need to assert here
// e.g. This can happen during a Server.Transfer, or a LoadControl.
[ReflectionPermission(SecurityAction.Assert, Flags = ReflectionPermissionFlag.MemberAccess)]
internal static InstantiateObject GetFastObjectCreationDelegate(Type t) {
// Look for the factory class in the same assembly
Assembly a = t.Assembly;
string shortAssemblyName = Util.GetAssemblyShortName(t.Assembly);
shortAssemblyName = shortAssemblyName.ToLower(CultureInfo.InvariantCulture);
Type factoryType = a.GetType(factoryFullClassNameBase + Util.MakeValidTypeNameFromString(shortAssemblyName));
if (factoryType == null)
return null;
string methodName = GetCreateMethodNameForType(t.FullName);
try {
return (InstantiateObject) Delegate.CreateDelegate(
typeof(InstantiateObject), factoryType, methodName);
}
catch {
return null;
}
}
}
}