PageCodeDomTreeGenerator.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / whidbey / netfxsp / ndp / fx / src / xsp / System / Web / Compilation / PageCodeDomTreeGenerator.cs / 5 / PageCodeDomTreeGenerator.cs

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

namespace System.Web.Compilation { 
 
using System.Text;
using System.Runtime.Serialization.Formatters; 
using System.ComponentModel;
using System;
using System.Collections;
using System.Reflection; 
using System.IO;
using System.Web.Util; 
using System.Web.UI; 
using System.Web.SessionState;
using System.CodeDom; 
using System.EnterpriseServices;
using Util = System.Web.UI.Util;
using Debug=System.Web.Util.Debug;
 
internal class PageCodeDomTreeGenerator : TemplateControlCodeDomTreeGenerator {
 
    private PageParser _pageParser; 
    PageParser Parser { get { return _pageParser; } }
 
    private const string fileDependenciesName = "__fileDependencies";
    private const string dependenciesLocalName = "dependencies";
    private const string outputCacheSettingsLocalName = "outputCacheSettings";
    private const string _previousPagePropertyName = "PreviousPage"; 
    private const string _masterPropertyName = "Master";
    private const string _styleSheetThemePropertyName = "StyleSheetTheme"; 
    private const string outputCacheSettingsFieldName = "__outputCacheSettings"; 

    internal const int  DebugScriptTimeout = 30000000; 

    internal PageCodeDomTreeGenerator(PageParser pageParser) : base(pageParser) {
        _pageParser = pageParser;
    } 

    /* 
     * Generate the list of implemented interfaces 
     */
    protected override void GenerateInterfaces() { 

        base.GenerateInterfaces();

        if (Parser.FRequiresSessionState) { 
            _intermediateClass.BaseTypes.Add(new CodeTypeReference(typeof(IRequiresSessionState)));
        } 
        if (Parser.FReadOnlySessionState) { 
            _intermediateClass.BaseTypes.Add(new CodeTypeReference(typeof(IReadOnlySessionState)));
        } 

        // Skip if we're only generating the intermediate class
        if (!_designerMode && _sourceDataClass != null && (Parser.AspCompatMode || Parser.AsyncMode)) {
            _sourceDataClass.BaseTypes.Add(new CodeTypeReference(typeof(IHttpAsyncHandler))); 
        }
    } 
 
    /*
     * Build first-time intialization statements 
     */
    protected override void BuildInitStatements(CodeStatementCollection trueStatements, CodeStatementCollection topLevelStatements) {

        base.BuildInitStatements(trueStatements, topLevelStatements); 

        // 
 

 
        CodeMemberField fileDependencies = new CodeMemberField(typeof(object), fileDependenciesName);
        fileDependencies.Attributes |= MemberAttributes.Static;
        _sourceDataClass.Members.Add(fileDependencies);
 
        // Note: it may look like this local variable declaration is redundant. However it is necessary
        // to make this init code re-entrant safe. This way, even if two threads enter the contructor 
        // at the same time, they will not add multiple dependencies. 

        // e.g. string[] dependencies; 
        CodeVariableDeclarationStatement dependencies = new CodeVariableDeclarationStatement();
        dependencies.Type = new CodeTypeReference(typeof(string[]));
        dependencies.Name = dependenciesLocalName;
        // Note: it is important to add all local variables at the top level for CodeDom Subset compliance. 
        topLevelStatements.Insert(0, dependencies);
 
        Debug.Assert(Parser.SourceDependencies != null); 

        StringSet virtualDependencies = new StringSet(); 
        virtualDependencies.AddCollection(Parser.SourceDependencies);

        // e.g. dependencies = new string[{{virtualDependencies.Count}}];;
        CodeAssignStatement assignDependencies = new CodeAssignStatement(); 
        assignDependencies.Left =
            new CodeVariableReferenceExpression(dependenciesLocalName); 
        assignDependencies.Right = 
            new CodeArrayCreateExpression(typeof(String), virtualDependencies.Count);
        trueStatements.Add(assignDependencies); 

        int i = 0;
        foreach (string virtualDependency in virtualDependencies) {
            // e.g. dependencies[i] = "~/sub/foo.aspx"; 
            CodeAssignStatement addFileDep = new CodeAssignStatement();
            addFileDep.Left = 
                new CodeArrayIndexerExpression( 
                    new CodeVariableReferenceExpression(dependenciesLocalName),
                    new CodeExpression[] {new CodePrimitiveExpression(i++)}); 
            string src = UrlPath.MakeVirtualPathAppRelative(virtualDependency);
            addFileDep.Right = new CodePrimitiveExpression(src);
            trueStatements.Add(addFileDep);
        } 

        // e.g. __fileDependencies = this.GetWrappedFileDependencies(dependencies); 
        CodeAssignStatement initFile = new CodeAssignStatement(); 
        initFile.Left = new CodeFieldReferenceExpression(_classTypeExpr, fileDependenciesName);
        CodeMethodInvokeExpression createWrap = new CodeMethodInvokeExpression(); 
        createWrap.Method.TargetObject = new CodeThisReferenceExpression();
        createWrap.Method.MethodName = "GetWrappedFileDependencies";
        createWrap.Parameters.Add(new CodeVariableReferenceExpression(dependenciesLocalName));
        initFile.Right = createWrap; 

#if DBG 
        AppendDebugComment(trueStatements); 
#endif
        trueStatements.Add(initFile); 
    }

    /*
     * Build the default constructor 
     */
    protected override void BuildDefaultConstructor() { 
 
        base.BuildDefaultConstructor();
 
        if (CompilParams.IncludeDebugInformation) {
            // If in debug mode, set the timeout to some huge value (ASURT 49427)
            //      Server.ScriptTimeout = 30000000;
            CodeAssignStatement setScriptTimeout = new CodeAssignStatement(); 
            setScriptTimeout.Left = new CodePropertyReferenceExpression(
                new CodePropertyReferenceExpression( 
                    new CodeThisReferenceExpression(), "Server"), 
                "ScriptTimeout");
            setScriptTimeout.Right = new CodePrimitiveExpression(DebugScriptTimeout); 
            _ctor.Statements.Add(setScriptTimeout);

        }
 
        if (Parser.TransactionMode != 0 /*TransactionOption.Disabled*/) {
            _ctor.Statements.Add(new CodeAssignStatement( 
                new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "TransactionMode"), 
                new CodePrimitiveExpression(Parser.TransactionMode)));
        } 

        if (Parser.AspCompatMode) {
            _ctor.Statements.Add(new CodeAssignStatement(
                new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "AspCompatMode"), 
                new CodePrimitiveExpression(Parser.AspCompatMode)));
        } 
 
        if (Parser.AsyncMode) {
            _ctor.Statements.Add(new CodeAssignStatement( 
                new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "AsyncMode"),
                new CodePrimitiveExpression(Parser.AsyncMode)));
        }
 
        if (Parser.OutputCacheParameters != null) {
            OutputCacheParameters cacheSettings = Parser.OutputCacheParameters; 
            if ((cacheSettings.CacheProfile != null && cacheSettings.CacheProfile.Length != 0) || 
                cacheSettings.Duration != 0 ||
                cacheSettings.Location == OutputCacheLocation.None) { 

                // Add the following code snippet as a static on the class:
                //
                // private static OutputCacheParameters __outputCacheSettings = null; 
                //
                CodeMemberField outputCacheSettingsField = new CodeMemberField(typeof(OutputCacheParameters), outputCacheSettingsFieldName); 
                outputCacheSettingsField.Attributes |= MemberAttributes.Static; 
                outputCacheSettingsField.InitExpression = new CodePrimitiveExpression(null);
                _sourceDataClass.Members.Add(outputCacheSettingsField); 

                // Then, add the following code to the default constructor:
                //
                // if (__outputCacheSettings == null) 
                //     __outputCacheSettings = new OutputCacheParameters(.....)
                // 
 
                // This is the "if (__outputCacheSettings == null)" part
                CodeConditionStatement outputCacheSettingsCondition = new CodeConditionStatement(); 
                outputCacheSettingsCondition.Condition = new CodeBinaryOperatorExpression(
                                                        new CodeFieldReferenceExpression(
                                                            _classTypeExpr,
                                                            outputCacheSettingsFieldName), 
                                                        CodeBinaryOperatorType.IdentityEquality,
                                                        new CodePrimitiveExpression(null)); 
 
                // This is the "__outputCacheSettings = new OutputCacheParameters()" part
 

                // e.g. declare local variable: OutputCacheParameters outputCacheSettings;
                CodeVariableDeclarationStatement outputCacheSettingsDeclaration = new CodeVariableDeclarationStatement();
                outputCacheSettingsDeclaration.Type = new CodeTypeReference(typeof(OutputCacheParameters)); 
                outputCacheSettingsDeclaration.Name = outputCacheSettingsLocalName;
                outputCacheSettingsCondition.TrueStatements.Insert(0, outputCacheSettingsDeclaration); 
 
                // e.g. outputCacheSettings = new outputCacheParameters;
                CodeObjectCreateExpression cacheSettingsObject = new CodeObjectCreateExpression(); 
                cacheSettingsObject.CreateType = new CodeTypeReference(typeof(OutputCacheParameters));

                CodeVariableReferenceExpression outputCacheSettings =
                    new CodeVariableReferenceExpression(outputCacheSettingsLocalName); 

                CodeAssignStatement setOutputCacheObject = 
                    new CodeAssignStatement(outputCacheSettings, cacheSettingsObject); 

                // Add the statement to the "true" clause 
                outputCacheSettingsCondition.TrueStatements.Add(setOutputCacheObject);

                if (cacheSettings.IsParameterSet(OutputCacheParameter.CacheProfile)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement( 
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "CacheProfile"),
                                                                   new CodePrimitiveExpression(cacheSettings.CacheProfile)); 
 
                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
                } 

                if (cacheSettings.IsParameterSet(OutputCacheParameter.Duration)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "Duration"), 
                                                                   new CodePrimitiveExpression(cacheSettings.Duration));
 
                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement); 
                }
 
                if (cacheSettings.IsParameterSet(OutputCacheParameter.Enabled)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "Enabled"),
                                                                   new CodePrimitiveExpression(cacheSettings.Enabled)); 

                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement); 
                } 

                if (cacheSettings.IsParameterSet(OutputCacheParameter.Location)) { 
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "Location"),
                                                                   new CodeFieldReferenceExpression(
                                                                        new CodeTypeReferenceExpression(typeof(OutputCacheLocation)), 
                                                                        cacheSettings.Location.ToString()));
 
                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement); 
                }
 
                if (cacheSettings.IsParameterSet(OutputCacheParameter.NoStore)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "NoStore"),
                                                                   new CodePrimitiveExpression(cacheSettings.NoStore)); 

                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement); 
                } 

                if (cacheSettings.IsParameterSet(OutputCacheParameter.SqlDependency)) { 
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "SqlDependency"),
                                                                   new CodePrimitiveExpression(cacheSettings.SqlDependency));
 
                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
                } 
 
                if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByControl)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement( 
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "VaryByControl"),
                                                                   new CodePrimitiveExpression(cacheSettings.VaryByControl));

                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement); 
                }
 
                if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByCustom)) { 
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "VaryByCustom"), 
                                                                   new CodePrimitiveExpression(cacheSettings.VaryByCustom));

                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
                } 

                if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByContentEncoding)) { 
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement( 
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "VaryByContentEncoding"),
                                                                   new CodePrimitiveExpression(cacheSettings.VaryByContentEncoding)); 

                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
                }
                if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByHeader)) { 
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "VaryByHeader"), 
                                                                   new CodePrimitiveExpression(cacheSettings.VaryByHeader)); 

                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement); 
                }

                if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByParam)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement( 
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "VaryByParam"),
                                                                   new CodePrimitiveExpression(cacheSettings.VaryByParam)); 
 
                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
                } 

                // e.g. __outputCacheSettings = outputCacheSettings;
                CodeFieldReferenceExpression staticOutputCacheSettings =
                    new CodeFieldReferenceExpression(_classTypeExpr, outputCacheSettingsFieldName); 
                CodeAssignStatement assignOutputCacheSettings =
                    new CodeAssignStatement(staticOutputCacheSettings, outputCacheSettings); 
                // Add the statement to the "true" clause 
                outputCacheSettingsCondition.TrueStatements.Add(assignOutputCacheSettings);
 
                _ctor.Statements.Add(outputCacheSettingsCondition);
            }
        }
    } 

    /* 
     * Build various properties, fields, methods 
     */
    protected override void BuildMiscClassMembers() { 
        base.BuildMiscClassMembers();

        // The following method should not be built in designer mode, and should only be built
        // when we're generating the full class (as opposed to the partial stub) 
        if (!_designerMode && _sourceDataClass != null) {
            BuildGetTypeHashCodeMethod(); 
 
            if (Parser.AspCompatMode)
                BuildAspCompatMethods(); 

            if (Parser.AsyncMode)
                BuildAsyncPageMethods();
 
            BuildProcessRequestOverride();
        } 
 
        if (Parser.PreviousPageType != null)
            BuildStronglyTypedProperty(_previousPagePropertyName, Parser.PreviousPageType); 

        if (Parser.MasterPageType != null)
            BuildStronglyTypedProperty(_masterPropertyName, Parser.MasterPageType);
 

    } 
 
    /*
     * Build the data tree for the GetTypeHashCode method 
     */
    private void BuildGetTypeHashCodeMethod() {

        CodeMemberMethod method = new CodeMemberMethod(); 
        AddDebuggerNonUserCodeAttribute(method);
        method.Name = "GetTypeHashCode"; 
        method.ReturnType = new CodeTypeReference(typeof(int)); 
        method.Attributes &= ~MemberAttributes.AccessMask;
        method.Attributes &= ~MemberAttributes.ScopeMask; 
        method.Attributes |= MemberAttributes.Override | MemberAttributes.Public;

        _sourceDataClass.Members.Add(method);
 
#if DBG
        AppendDebugComment(method.Statements); 
#endif 
        method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(Parser.TypeHashCode)));
    } 

    internal override CodeExpression BuildPagePropertyReferenceExpression() {
        return new CodeThisReferenceExpression();
    } 

    /* 
     * Build the contents of the FrameworkInitialize method 
     */
    protected override void BuildFrameworkInitializeMethodContents(CodeMemberMethod method) { 

        // Generate code to apply stylesheet before calling base.FrameworkInitialize();
        if (Parser.StyleSheetTheme != null) {
            CodeExpression rightExpr = new CodePrimitiveExpression(Parser.StyleSheetTheme); 
            CodeExpression leftExpr = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), _styleSheetThemePropertyName);
            CodeAssignStatement setStatment = new CodeAssignStatement(leftExpr, rightExpr); 
            method.Statements.Add(setStatment); 
        }
 
        base.BuildFrameworkInitializeMethodContents(method);

        CodeMethodInvokeExpression addDeps = new CodeMethodInvokeExpression();
        addDeps.Method.TargetObject = new CodeThisReferenceExpression(); 
        addDeps.Method.MethodName = "AddWrappedFileDependencies";
        addDeps.Parameters.Add(new CodeFieldReferenceExpression(_classTypeExpr, fileDependenciesName)); 
        method.Statements.Add(addDeps); 

        if (Parser.OutputCacheParameters != null) { 
            OutputCacheParameters cacheSettings = Parser.OutputCacheParameters;
            if ((cacheSettings.CacheProfile != null && cacheSettings.CacheProfile.Length != 0) ||
                cacheSettings.Duration != 0 ||
                cacheSettings.Location == OutputCacheLocation.None) { 

                CodeMethodInvokeExpression call = new CodeMethodInvokeExpression(); 
                call.Method.TargetObject = new CodeThisReferenceExpression(); 
                call.Method.MethodName = "InitOutputCache";
                call.Parameters.Add(new CodeFieldReferenceExpression( 
                                    _classTypeExpr,
                                    outputCacheSettingsFieldName));

                method.Statements.Add(call); 
            }
        } 
 
        if (Parser.TraceEnabled != TraceEnable.Default) {
            method.Statements.Add(new CodeAssignStatement( 
                new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "TraceEnabled"),
                new CodePrimitiveExpression(Parser.TraceEnabled == TraceEnable.Enable)));
        }
 
        if (Parser.TraceMode != TraceMode.Default) {
            method.Statements.Add(new CodeAssignStatement( 
                new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "TraceModeValue"), 
                new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(TraceMode)), Parser.TraceMode.ToString())));
        } 

        if (Parser.ValidateRequest) {
            // e.g. Request.ValidateInput();
            CodeMethodInvokeExpression invokeExpr = new CodeMethodInvokeExpression(); 
            invokeExpr.Method.TargetObject = new CodePropertyReferenceExpression(
                new CodeThisReferenceExpression(), "Request"); 
            invokeExpr.Method.MethodName = "ValidateInput"; 
            method.Statements.Add(new CodeExpressionStatement(invokeExpr));
        } 
    }

    /*
     * Build the data tree for the AspCompat implementation for IHttpAsyncHandler: 
     */
    private void BuildAspCompatMethods() { 
        CodeMemberMethod method; 
        CodeMethodInvokeExpression call;
 
        //  public IAsyncResult BeginProcessRequest(HttpContext context, Async'back cb, Object extraData) {
        //      IAsyncResult ar;
        //      ar = this.AspCompatBeginProcessRequest(context, cb, extraData);
        //      return ar; 
        //  }
 
        method = new CodeMemberMethod(); 
        AddDebuggerNonUserCodeAttribute(method);
        method.Name = "BeginProcessRequest"; 
        method.Attributes &= ~MemberAttributes.AccessMask;
        method.Attributes &= ~MemberAttributes.ScopeMask;
        method.Attributes |= MemberAttributes.Public;
        method.ImplementationTypes.Add(new CodeTypeReference(typeof(IHttpAsyncHandler))); 
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(HttpContext),   "context"));
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(AsyncCallback), "cb")); 
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Object),        "data")); 
        method.ReturnType = new CodeTypeReference(typeof(IAsyncResult));
 
        CodeMethodInvokeExpression invokeExpr = new CodeMethodInvokeExpression();
        invokeExpr.Method.TargetObject = new CodeThisReferenceExpression();
        invokeExpr.Method.MethodName = "AspCompatBeginProcessRequest";
        invokeExpr.Parameters.Add(new CodeArgumentReferenceExpression("context")); 
        invokeExpr.Parameters.Add(new CodeArgumentReferenceExpression("cb"));
        invokeExpr.Parameters.Add(new CodeArgumentReferenceExpression("data")); 
 
        method.Statements.Add(new CodeMethodReturnStatement(invokeExpr));
 
        _sourceDataClass.Members.Add(method);

        //  public void EndProcessRequest(IAsyncResult ar) {
        //      this.AspCompatEndProcessRequest(ar); 
        //  }
 
        method = new CodeMemberMethod(); 
        AddDebuggerNonUserCodeAttribute(method);
        method.Name = "EndProcessRequest"; 
        method.Attributes &= ~MemberAttributes.AccessMask;
        method.Attributes &= ~MemberAttributes.ScopeMask;
        method.Attributes |= MemberAttributes.Public;
        method.ImplementationTypes.Add(typeof(IHttpAsyncHandler)); 
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(IAsyncResult), "ar"));
 
        call = new CodeMethodInvokeExpression(); 
        call.Method.TargetObject = new CodeThisReferenceExpression();
        call.Method.MethodName = "AspCompatEndProcessRequest"; 
        call.Parameters.Add(new CodeArgumentReferenceExpression("ar"));
        method.Statements.Add(call);

        _sourceDataClass.Members.Add(method); 
    }
 
    /* 
     * Build the data tree for the Async page implementation for IHttpAsyncHandler:
     */ 
    private void BuildAsyncPageMethods() {
        CodeMemberMethod method;
        CodeMethodInvokeExpression call;
 
        //  public IAsyncResult BeginProcessRequest(HttpContext context, Async'back cb, Object extraData) {
        //      IAsyncResult ar; 
        //      ar = this.AsyncPageBeginProcessRequest(context, cb, extraData); 
        //      return ar;
        //  } 

        method = new CodeMemberMethod();
        AddDebuggerNonUserCodeAttribute(method);
        method.Name = "BeginProcessRequest"; 
        method.Attributes &= ~MemberAttributes.AccessMask;
        method.Attributes &= ~MemberAttributes.ScopeMask; 
        method.Attributes |= MemberAttributes.Public; 
        method.ImplementationTypes.Add(new CodeTypeReference(typeof(IHttpAsyncHandler)));
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(HttpContext),   "context")); 
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(AsyncCallback), "cb"));
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Object),        "data"));
        method.ReturnType = new CodeTypeReference(typeof(IAsyncResult));
 
        CodeMethodInvokeExpression invokeExpr = new CodeMethodInvokeExpression();
        invokeExpr.Method.TargetObject = new CodeThisReferenceExpression(); 
        invokeExpr.Method.MethodName = "AsyncPageBeginProcessRequest"; 
        invokeExpr.Parameters.Add(new CodeArgumentReferenceExpression("context"));
        invokeExpr.Parameters.Add(new CodeArgumentReferenceExpression("cb")); 
        invokeExpr.Parameters.Add(new CodeArgumentReferenceExpression("data"));

        method.Statements.Add(new CodeMethodReturnStatement(invokeExpr));
 
        _sourceDataClass.Members.Add(method);
 
        //  public void EndProcessRequest(IAsyncResult ar) { 
        //      this.AsyncPageEndProcessRequest(ar);
        //  } 

        method = new CodeMemberMethod();
        AddDebuggerNonUserCodeAttribute(method);
        method.Name = "EndProcessRequest"; 
        method.Attributes &= ~MemberAttributes.AccessMask;
        method.Attributes &= ~MemberAttributes.ScopeMask; 
        method.Attributes |= MemberAttributes.Public; 
        method.ImplementationTypes.Add(typeof(IHttpAsyncHandler));
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(IAsyncResult), "ar")); 

        call = new CodeMethodInvokeExpression();
        call.Method.TargetObject = new CodeThisReferenceExpression();
        call.Method.MethodName = "AsyncPageEndProcessRequest"; 
        call.Parameters.Add(new CodeArgumentReferenceExpression("ar"));
        method.Statements.Add(call); 
 
        _sourceDataClass.Members.Add(method);
    } 

    /*
     * Build a ProcessRequest override which just calls the base.  This is used to make sure
     * there is user code on the stack when requests are executed (VSWhidbey 499386) 
     */
    private void BuildProcessRequestOverride() { 
 
        //  public override void ProcessRequest(HttpContext context) {
        //      base.ProcessRequest(context); 
        //  }

        CodeMemberMethod method = new CodeMemberMethod();
        AddDebuggerNonUserCodeAttribute(method); 
        method.Name = "ProcessRequest";
        method.Attributes &= ~MemberAttributes.AccessMask; 
        method.Attributes &= ~MemberAttributes.ScopeMask; 

        // If the base type is non-default (i.e. not Page) we have to be careful overriding 
        // ProcessRequest, because if the base has its own IHttpHandler.ProcessRequest implementation
        // and it's not overridable, we would fail to compile.  So when we detect this situation,
        // we instead generate it as a new IHttpHandler.ProcessRequest implementation instead of an
        // override.  In theory, we could *always* do this, but it's safer to limit it to this 
        // constrained scenario (VSWhidbey 517240)
        MethodInfo methodInfo = null; 
        if (Parser.BaseType != typeof(Page)) { 
            methodInfo = Parser.BaseType.GetMethod("ProcessRequest",
                BindingFlags.Public | BindingFlags.Instance, 
                null, new Type[] { typeof(HttpContext) }, null);
            Debug.Assert(methodInfo != null);
        }
 
        _sourceDataClass.BaseTypes.Add(new CodeTypeReference(typeof(IHttpHandler)));
 
        if (methodInfo != null && methodInfo.DeclaringType != typeof(Page)) { 
            method.Attributes |= MemberAttributes.New | MemberAttributes.Public;
        } 
        else {
            method.Attributes |= MemberAttributes.Override | MemberAttributes.Public;
        }
 
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(HttpContext), "context"));
 
        CodeMethodInvokeExpression invokeExpr = new CodeMethodInvokeExpression(); 
        invokeExpr.Method.TargetObject = new CodeBaseReferenceExpression();
        invokeExpr.Method.MethodName = "ProcessRequest"; 
        invokeExpr.Parameters.Add(new CodeArgumentReferenceExpression("context"));

        method.Statements.Add(invokeExpr);
 
        _sourceDataClass.Members.Add(method);
    } 
 
}
 
}

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

namespace System.Web.Compilation { 
 
using System.Text;
using System.Runtime.Serialization.Formatters; 
using System.ComponentModel;
using System;
using System.Collections;
using System.Reflection; 
using System.IO;
using System.Web.Util; 
using System.Web.UI; 
using System.Web.SessionState;
using System.CodeDom; 
using System.EnterpriseServices;
using Util = System.Web.UI.Util;
using Debug=System.Web.Util.Debug;
 
internal class PageCodeDomTreeGenerator : TemplateControlCodeDomTreeGenerator {
 
    private PageParser _pageParser; 
    PageParser Parser { get { return _pageParser; } }
 
    private const string fileDependenciesName = "__fileDependencies";
    private const string dependenciesLocalName = "dependencies";
    private const string outputCacheSettingsLocalName = "outputCacheSettings";
    private const string _previousPagePropertyName = "PreviousPage"; 
    private const string _masterPropertyName = "Master";
    private const string _styleSheetThemePropertyName = "StyleSheetTheme"; 
    private const string outputCacheSettingsFieldName = "__outputCacheSettings"; 

    internal const int  DebugScriptTimeout = 30000000; 

    internal PageCodeDomTreeGenerator(PageParser pageParser) : base(pageParser) {
        _pageParser = pageParser;
    } 

    /* 
     * Generate the list of implemented interfaces 
     */
    protected override void GenerateInterfaces() { 

        base.GenerateInterfaces();

        if (Parser.FRequiresSessionState) { 
            _intermediateClass.BaseTypes.Add(new CodeTypeReference(typeof(IRequiresSessionState)));
        } 
        if (Parser.FReadOnlySessionState) { 
            _intermediateClass.BaseTypes.Add(new CodeTypeReference(typeof(IReadOnlySessionState)));
        } 

        // Skip if we're only generating the intermediate class
        if (!_designerMode && _sourceDataClass != null && (Parser.AspCompatMode || Parser.AsyncMode)) {
            _sourceDataClass.BaseTypes.Add(new CodeTypeReference(typeof(IHttpAsyncHandler))); 
        }
    } 
 
    /*
     * Build first-time intialization statements 
     */
    protected override void BuildInitStatements(CodeStatementCollection trueStatements, CodeStatementCollection topLevelStatements) {

        base.BuildInitStatements(trueStatements, topLevelStatements); 

        // 
 

 
        CodeMemberField fileDependencies = new CodeMemberField(typeof(object), fileDependenciesName);
        fileDependencies.Attributes |= MemberAttributes.Static;
        _sourceDataClass.Members.Add(fileDependencies);
 
        // Note: it may look like this local variable declaration is redundant. However it is necessary
        // to make this init code re-entrant safe. This way, even if two threads enter the contructor 
        // at the same time, they will not add multiple dependencies. 

        // e.g. string[] dependencies; 
        CodeVariableDeclarationStatement dependencies = new CodeVariableDeclarationStatement();
        dependencies.Type = new CodeTypeReference(typeof(string[]));
        dependencies.Name = dependenciesLocalName;
        // Note: it is important to add all local variables at the top level for CodeDom Subset compliance. 
        topLevelStatements.Insert(0, dependencies);
 
        Debug.Assert(Parser.SourceDependencies != null); 

        StringSet virtualDependencies = new StringSet(); 
        virtualDependencies.AddCollection(Parser.SourceDependencies);

        // e.g. dependencies = new string[{{virtualDependencies.Count}}];;
        CodeAssignStatement assignDependencies = new CodeAssignStatement(); 
        assignDependencies.Left =
            new CodeVariableReferenceExpression(dependenciesLocalName); 
        assignDependencies.Right = 
            new CodeArrayCreateExpression(typeof(String), virtualDependencies.Count);
        trueStatements.Add(assignDependencies); 

        int i = 0;
        foreach (string virtualDependency in virtualDependencies) {
            // e.g. dependencies[i] = "~/sub/foo.aspx"; 
            CodeAssignStatement addFileDep = new CodeAssignStatement();
            addFileDep.Left = 
                new CodeArrayIndexerExpression( 
                    new CodeVariableReferenceExpression(dependenciesLocalName),
                    new CodeExpression[] {new CodePrimitiveExpression(i++)}); 
            string src = UrlPath.MakeVirtualPathAppRelative(virtualDependency);
            addFileDep.Right = new CodePrimitiveExpression(src);
            trueStatements.Add(addFileDep);
        } 

        // e.g. __fileDependencies = this.GetWrappedFileDependencies(dependencies); 
        CodeAssignStatement initFile = new CodeAssignStatement(); 
        initFile.Left = new CodeFieldReferenceExpression(_classTypeExpr, fileDependenciesName);
        CodeMethodInvokeExpression createWrap = new CodeMethodInvokeExpression(); 
        createWrap.Method.TargetObject = new CodeThisReferenceExpression();
        createWrap.Method.MethodName = "GetWrappedFileDependencies";
        createWrap.Parameters.Add(new CodeVariableReferenceExpression(dependenciesLocalName));
        initFile.Right = createWrap; 

#if DBG 
        AppendDebugComment(trueStatements); 
#endif
        trueStatements.Add(initFile); 
    }

    /*
     * Build the default constructor 
     */
    protected override void BuildDefaultConstructor() { 
 
        base.BuildDefaultConstructor();
 
        if (CompilParams.IncludeDebugInformation) {
            // If in debug mode, set the timeout to some huge value (ASURT 49427)
            //      Server.ScriptTimeout = 30000000;
            CodeAssignStatement setScriptTimeout = new CodeAssignStatement(); 
            setScriptTimeout.Left = new CodePropertyReferenceExpression(
                new CodePropertyReferenceExpression( 
                    new CodeThisReferenceExpression(), "Server"), 
                "ScriptTimeout");
            setScriptTimeout.Right = new CodePrimitiveExpression(DebugScriptTimeout); 
            _ctor.Statements.Add(setScriptTimeout);

        }
 
        if (Parser.TransactionMode != 0 /*TransactionOption.Disabled*/) {
            _ctor.Statements.Add(new CodeAssignStatement( 
                new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "TransactionMode"), 
                new CodePrimitiveExpression(Parser.TransactionMode)));
        } 

        if (Parser.AspCompatMode) {
            _ctor.Statements.Add(new CodeAssignStatement(
                new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "AspCompatMode"), 
                new CodePrimitiveExpression(Parser.AspCompatMode)));
        } 
 
        if (Parser.AsyncMode) {
            _ctor.Statements.Add(new CodeAssignStatement( 
                new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "AsyncMode"),
                new CodePrimitiveExpression(Parser.AsyncMode)));
        }
 
        if (Parser.OutputCacheParameters != null) {
            OutputCacheParameters cacheSettings = Parser.OutputCacheParameters; 
            if ((cacheSettings.CacheProfile != null && cacheSettings.CacheProfile.Length != 0) || 
                cacheSettings.Duration != 0 ||
                cacheSettings.Location == OutputCacheLocation.None) { 

                // Add the following code snippet as a static on the class:
                //
                // private static OutputCacheParameters __outputCacheSettings = null; 
                //
                CodeMemberField outputCacheSettingsField = new CodeMemberField(typeof(OutputCacheParameters), outputCacheSettingsFieldName); 
                outputCacheSettingsField.Attributes |= MemberAttributes.Static; 
                outputCacheSettingsField.InitExpression = new CodePrimitiveExpression(null);
                _sourceDataClass.Members.Add(outputCacheSettingsField); 

                // Then, add the following code to the default constructor:
                //
                // if (__outputCacheSettings == null) 
                //     __outputCacheSettings = new OutputCacheParameters(.....)
                // 
 
                // This is the "if (__outputCacheSettings == null)" part
                CodeConditionStatement outputCacheSettingsCondition = new CodeConditionStatement(); 
                outputCacheSettingsCondition.Condition = new CodeBinaryOperatorExpression(
                                                        new CodeFieldReferenceExpression(
                                                            _classTypeExpr,
                                                            outputCacheSettingsFieldName), 
                                                        CodeBinaryOperatorType.IdentityEquality,
                                                        new CodePrimitiveExpression(null)); 
 
                // This is the "__outputCacheSettings = new OutputCacheParameters()" part
 

                // e.g. declare local variable: OutputCacheParameters outputCacheSettings;
                CodeVariableDeclarationStatement outputCacheSettingsDeclaration = new CodeVariableDeclarationStatement();
                outputCacheSettingsDeclaration.Type = new CodeTypeReference(typeof(OutputCacheParameters)); 
                outputCacheSettingsDeclaration.Name = outputCacheSettingsLocalName;
                outputCacheSettingsCondition.TrueStatements.Insert(0, outputCacheSettingsDeclaration); 
 
                // e.g. outputCacheSettings = new outputCacheParameters;
                CodeObjectCreateExpression cacheSettingsObject = new CodeObjectCreateExpression(); 
                cacheSettingsObject.CreateType = new CodeTypeReference(typeof(OutputCacheParameters));

                CodeVariableReferenceExpression outputCacheSettings =
                    new CodeVariableReferenceExpression(outputCacheSettingsLocalName); 

                CodeAssignStatement setOutputCacheObject = 
                    new CodeAssignStatement(outputCacheSettings, cacheSettingsObject); 

                // Add the statement to the "true" clause 
                outputCacheSettingsCondition.TrueStatements.Add(setOutputCacheObject);

                if (cacheSettings.IsParameterSet(OutputCacheParameter.CacheProfile)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement( 
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "CacheProfile"),
                                                                   new CodePrimitiveExpression(cacheSettings.CacheProfile)); 
 
                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
                } 

                if (cacheSettings.IsParameterSet(OutputCacheParameter.Duration)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "Duration"), 
                                                                   new CodePrimitiveExpression(cacheSettings.Duration));
 
                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement); 
                }
 
                if (cacheSettings.IsParameterSet(OutputCacheParameter.Enabled)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "Enabled"),
                                                                   new CodePrimitiveExpression(cacheSettings.Enabled)); 

                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement); 
                } 

                if (cacheSettings.IsParameterSet(OutputCacheParameter.Location)) { 
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "Location"),
                                                                   new CodeFieldReferenceExpression(
                                                                        new CodeTypeReferenceExpression(typeof(OutputCacheLocation)), 
                                                                        cacheSettings.Location.ToString()));
 
                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement); 
                }
 
                if (cacheSettings.IsParameterSet(OutputCacheParameter.NoStore)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "NoStore"),
                                                                   new CodePrimitiveExpression(cacheSettings.NoStore)); 

                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement); 
                } 

                if (cacheSettings.IsParameterSet(OutputCacheParameter.SqlDependency)) { 
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "SqlDependency"),
                                                                   new CodePrimitiveExpression(cacheSettings.SqlDependency));
 
                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
                } 
 
                if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByControl)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement( 
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "VaryByControl"),
                                                                   new CodePrimitiveExpression(cacheSettings.VaryByControl));

                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement); 
                }
 
                if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByCustom)) { 
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "VaryByCustom"), 
                                                                   new CodePrimitiveExpression(cacheSettings.VaryByCustom));

                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
                } 

                if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByContentEncoding)) { 
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement( 
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "VaryByContentEncoding"),
                                                                   new CodePrimitiveExpression(cacheSettings.VaryByContentEncoding)); 

                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
                }
                if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByHeader)) { 
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement(
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "VaryByHeader"), 
                                                                   new CodePrimitiveExpression(cacheSettings.VaryByHeader)); 

                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement); 
                }

                if (cacheSettings.IsParameterSet(OutputCacheParameter.VaryByParam)) {
                    CodeAssignStatement setPropertyStatement = new CodeAssignStatement( 
                                                                   new CodePropertyReferenceExpression(outputCacheSettings, "VaryByParam"),
                                                                   new CodePrimitiveExpression(cacheSettings.VaryByParam)); 
 
                    outputCacheSettingsCondition.TrueStatements.Add(setPropertyStatement);
                } 

                // e.g. __outputCacheSettings = outputCacheSettings;
                CodeFieldReferenceExpression staticOutputCacheSettings =
                    new CodeFieldReferenceExpression(_classTypeExpr, outputCacheSettingsFieldName); 
                CodeAssignStatement assignOutputCacheSettings =
                    new CodeAssignStatement(staticOutputCacheSettings, outputCacheSettings); 
                // Add the statement to the "true" clause 
                outputCacheSettingsCondition.TrueStatements.Add(assignOutputCacheSettings);
 
                _ctor.Statements.Add(outputCacheSettingsCondition);
            }
        }
    } 

    /* 
     * Build various properties, fields, methods 
     */
    protected override void BuildMiscClassMembers() { 
        base.BuildMiscClassMembers();

        // The following method should not be built in designer mode, and should only be built
        // when we're generating the full class (as opposed to the partial stub) 
        if (!_designerMode && _sourceDataClass != null) {
            BuildGetTypeHashCodeMethod(); 
 
            if (Parser.AspCompatMode)
                BuildAspCompatMethods(); 

            if (Parser.AsyncMode)
                BuildAsyncPageMethods();
 
            BuildProcessRequestOverride();
        } 
 
        if (Parser.PreviousPageType != null)
            BuildStronglyTypedProperty(_previousPagePropertyName, Parser.PreviousPageType); 

        if (Parser.MasterPageType != null)
            BuildStronglyTypedProperty(_masterPropertyName, Parser.MasterPageType);
 

    } 
 
    /*
     * Build the data tree for the GetTypeHashCode method 
     */
    private void BuildGetTypeHashCodeMethod() {

        CodeMemberMethod method = new CodeMemberMethod(); 
        AddDebuggerNonUserCodeAttribute(method);
        method.Name = "GetTypeHashCode"; 
        method.ReturnType = new CodeTypeReference(typeof(int)); 
        method.Attributes &= ~MemberAttributes.AccessMask;
        method.Attributes &= ~MemberAttributes.ScopeMask; 
        method.Attributes |= MemberAttributes.Override | MemberAttributes.Public;

        _sourceDataClass.Members.Add(method);
 
#if DBG
        AppendDebugComment(method.Statements); 
#endif 
        method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(Parser.TypeHashCode)));
    } 

    internal override CodeExpression BuildPagePropertyReferenceExpression() {
        return new CodeThisReferenceExpression();
    } 

    /* 
     * Build the contents of the FrameworkInitialize method 
     */
    protected override void BuildFrameworkInitializeMethodContents(CodeMemberMethod method) { 

        // Generate code to apply stylesheet before calling base.FrameworkInitialize();
        if (Parser.StyleSheetTheme != null) {
            CodeExpression rightExpr = new CodePrimitiveExpression(Parser.StyleSheetTheme); 
            CodeExpression leftExpr = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), _styleSheetThemePropertyName);
            CodeAssignStatement setStatment = new CodeAssignStatement(leftExpr, rightExpr); 
            method.Statements.Add(setStatment); 
        }
 
        base.BuildFrameworkInitializeMethodContents(method);

        CodeMethodInvokeExpression addDeps = new CodeMethodInvokeExpression();
        addDeps.Method.TargetObject = new CodeThisReferenceExpression(); 
        addDeps.Method.MethodName = "AddWrappedFileDependencies";
        addDeps.Parameters.Add(new CodeFieldReferenceExpression(_classTypeExpr, fileDependenciesName)); 
        method.Statements.Add(addDeps); 

        if (Parser.OutputCacheParameters != null) { 
            OutputCacheParameters cacheSettings = Parser.OutputCacheParameters;
            if ((cacheSettings.CacheProfile != null && cacheSettings.CacheProfile.Length != 0) ||
                cacheSettings.Duration != 0 ||
                cacheSettings.Location == OutputCacheLocation.None) { 

                CodeMethodInvokeExpression call = new CodeMethodInvokeExpression(); 
                call.Method.TargetObject = new CodeThisReferenceExpression(); 
                call.Method.MethodName = "InitOutputCache";
                call.Parameters.Add(new CodeFieldReferenceExpression( 
                                    _classTypeExpr,
                                    outputCacheSettingsFieldName));

                method.Statements.Add(call); 
            }
        } 
 
        if (Parser.TraceEnabled != TraceEnable.Default) {
            method.Statements.Add(new CodeAssignStatement( 
                new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "TraceEnabled"),
                new CodePrimitiveExpression(Parser.TraceEnabled == TraceEnable.Enable)));
        }
 
        if (Parser.TraceMode != TraceMode.Default) {
            method.Statements.Add(new CodeAssignStatement( 
                new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "TraceModeValue"), 
                new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(TraceMode)), Parser.TraceMode.ToString())));
        } 

        if (Parser.ValidateRequest) {
            // e.g. Request.ValidateInput();
            CodeMethodInvokeExpression invokeExpr = new CodeMethodInvokeExpression(); 
            invokeExpr.Method.TargetObject = new CodePropertyReferenceExpression(
                new CodeThisReferenceExpression(), "Request"); 
            invokeExpr.Method.MethodName = "ValidateInput"; 
            method.Statements.Add(new CodeExpressionStatement(invokeExpr));
        } 
    }

    /*
     * Build the data tree for the AspCompat implementation for IHttpAsyncHandler: 
     */
    private void BuildAspCompatMethods() { 
        CodeMemberMethod method; 
        CodeMethodInvokeExpression call;
 
        //  public IAsyncResult BeginProcessRequest(HttpContext context, Async'back cb, Object extraData) {
        //      IAsyncResult ar;
        //      ar = this.AspCompatBeginProcessRequest(context, cb, extraData);
        //      return ar; 
        //  }
 
        method = new CodeMemberMethod(); 
        AddDebuggerNonUserCodeAttribute(method);
        method.Name = "BeginProcessRequest"; 
        method.Attributes &= ~MemberAttributes.AccessMask;
        method.Attributes &= ~MemberAttributes.ScopeMask;
        method.Attributes |= MemberAttributes.Public;
        method.ImplementationTypes.Add(new CodeTypeReference(typeof(IHttpAsyncHandler))); 
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(HttpContext),   "context"));
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(AsyncCallback), "cb")); 
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Object),        "data")); 
        method.ReturnType = new CodeTypeReference(typeof(IAsyncResult));
 
        CodeMethodInvokeExpression invokeExpr = new CodeMethodInvokeExpression();
        invokeExpr.Method.TargetObject = new CodeThisReferenceExpression();
        invokeExpr.Method.MethodName = "AspCompatBeginProcessRequest";
        invokeExpr.Parameters.Add(new CodeArgumentReferenceExpression("context")); 
        invokeExpr.Parameters.Add(new CodeArgumentReferenceExpression("cb"));
        invokeExpr.Parameters.Add(new CodeArgumentReferenceExpression("data")); 
 
        method.Statements.Add(new CodeMethodReturnStatement(invokeExpr));
 
        _sourceDataClass.Members.Add(method);

        //  public void EndProcessRequest(IAsyncResult ar) {
        //      this.AspCompatEndProcessRequest(ar); 
        //  }
 
        method = new CodeMemberMethod(); 
        AddDebuggerNonUserCodeAttribute(method);
        method.Name = "EndProcessRequest"; 
        method.Attributes &= ~MemberAttributes.AccessMask;
        method.Attributes &= ~MemberAttributes.ScopeMask;
        method.Attributes |= MemberAttributes.Public;
        method.ImplementationTypes.Add(typeof(IHttpAsyncHandler)); 
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(IAsyncResult), "ar"));
 
        call = new CodeMethodInvokeExpression(); 
        call.Method.TargetObject = new CodeThisReferenceExpression();
        call.Method.MethodName = "AspCompatEndProcessRequest"; 
        call.Parameters.Add(new CodeArgumentReferenceExpression("ar"));
        method.Statements.Add(call);

        _sourceDataClass.Members.Add(method); 
    }
 
    /* 
     * Build the data tree for the Async page implementation for IHttpAsyncHandler:
     */ 
    private void BuildAsyncPageMethods() {
        CodeMemberMethod method;
        CodeMethodInvokeExpression call;
 
        //  public IAsyncResult BeginProcessRequest(HttpContext context, Async'back cb, Object extraData) {
        //      IAsyncResult ar; 
        //      ar = this.AsyncPageBeginProcessRequest(context, cb, extraData); 
        //      return ar;
        //  } 

        method = new CodeMemberMethod();
        AddDebuggerNonUserCodeAttribute(method);
        method.Name = "BeginProcessRequest"; 
        method.Attributes &= ~MemberAttributes.AccessMask;
        method.Attributes &= ~MemberAttributes.ScopeMask; 
        method.Attributes |= MemberAttributes.Public; 
        method.ImplementationTypes.Add(new CodeTypeReference(typeof(IHttpAsyncHandler)));
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(HttpContext),   "context")); 
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(AsyncCallback), "cb"));
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Object),        "data"));
        method.ReturnType = new CodeTypeReference(typeof(IAsyncResult));
 
        CodeMethodInvokeExpression invokeExpr = new CodeMethodInvokeExpression();
        invokeExpr.Method.TargetObject = new CodeThisReferenceExpression(); 
        invokeExpr.Method.MethodName = "AsyncPageBeginProcessRequest"; 
        invokeExpr.Parameters.Add(new CodeArgumentReferenceExpression("context"));
        invokeExpr.Parameters.Add(new CodeArgumentReferenceExpression("cb")); 
        invokeExpr.Parameters.Add(new CodeArgumentReferenceExpression("data"));

        method.Statements.Add(new CodeMethodReturnStatement(invokeExpr));
 
        _sourceDataClass.Members.Add(method);
 
        //  public void EndProcessRequest(IAsyncResult ar) { 
        //      this.AsyncPageEndProcessRequest(ar);
        //  } 

        method = new CodeMemberMethod();
        AddDebuggerNonUserCodeAttribute(method);
        method.Name = "EndProcessRequest"; 
        method.Attributes &= ~MemberAttributes.AccessMask;
        method.Attributes &= ~MemberAttributes.ScopeMask; 
        method.Attributes |= MemberAttributes.Public; 
        method.ImplementationTypes.Add(typeof(IHttpAsyncHandler));
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(IAsyncResult), "ar")); 

        call = new CodeMethodInvokeExpression();
        call.Method.TargetObject = new CodeThisReferenceExpression();
        call.Method.MethodName = "AsyncPageEndProcessRequest"; 
        call.Parameters.Add(new CodeArgumentReferenceExpression("ar"));
        method.Statements.Add(call); 
 
        _sourceDataClass.Members.Add(method);
    } 

    /*
     * Build a ProcessRequest override which just calls the base.  This is used to make sure
     * there is user code on the stack when requests are executed (VSWhidbey 499386) 
     */
    private void BuildProcessRequestOverride() { 
 
        //  public override void ProcessRequest(HttpContext context) {
        //      base.ProcessRequest(context); 
        //  }

        CodeMemberMethod method = new CodeMemberMethod();
        AddDebuggerNonUserCodeAttribute(method); 
        method.Name = "ProcessRequest";
        method.Attributes &= ~MemberAttributes.AccessMask; 
        method.Attributes &= ~MemberAttributes.ScopeMask; 

        // If the base type is non-default (i.e. not Page) we have to be careful overriding 
        // ProcessRequest, because if the base has its own IHttpHandler.ProcessRequest implementation
        // and it's not overridable, we would fail to compile.  So when we detect this situation,
        // we instead generate it as a new IHttpHandler.ProcessRequest implementation instead of an
        // override.  In theory, we could *always* do this, but it's safer to limit it to this 
        // constrained scenario (VSWhidbey 517240)
        MethodInfo methodInfo = null; 
        if (Parser.BaseType != typeof(Page)) { 
            methodInfo = Parser.BaseType.GetMethod("ProcessRequest",
                BindingFlags.Public | BindingFlags.Instance, 
                null, new Type[] { typeof(HttpContext) }, null);
            Debug.Assert(methodInfo != null);
        }
 
        _sourceDataClass.BaseTypes.Add(new CodeTypeReference(typeof(IHttpHandler)));
 
        if (methodInfo != null && methodInfo.DeclaringType != typeof(Page)) { 
            method.Attributes |= MemberAttributes.New | MemberAttributes.Public;
        } 
        else {
            method.Attributes |= MemberAttributes.Override | MemberAttributes.Public;
        }
 
        method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(HttpContext), "context"));
 
        CodeMethodInvokeExpression invokeExpr = new CodeMethodInvokeExpression(); 
        invokeExpr.Method.TargetObject = new CodeBaseReferenceExpression();
        invokeExpr.Method.MethodName = "ProcessRequest"; 
        invokeExpr.Parameters.Add(new CodeArgumentReferenceExpression("context"));

        method.Statements.Add(invokeExpr);
 
        _sourceDataClass.Members.Add(method);
    } 
 
}
 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

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