ObjectFactoryCodeDomTreeGenerator.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / FXUpdate3074 / FXUpdate3074 / 1.1 / untmp / whidbey / QFE / ndp / fx / src / xsp / System / Web / Compilation / ObjectFactoryCodeDomTreeGenerator.cs / 1 / ObjectFactoryCodeDomTreeGenerator.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

// 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 (
        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 ( 
        _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'. (
        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 (
        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 assertt 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; 
        }
    } 
} 

} 


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK