linux-packaging-mono/external/referencesource/System.Web/UI/TemplateControl.cs

//------------------------------------------------------------------------------
// <copyright file="TemplateControl.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

/*
 * Page class definition
 *
 * Copyright (c) 1998 Microsoft Corporation
 */

namespace System.Web.UI {
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Collections.Specialized;
    using System.ComponentModel;
    using System.Configuration;
    using System.Diagnostics;
    using System.Diagnostics.CodeAnalysis;
    using System.Globalization;
    using System.IO;
    using System.Reflection;
    using System.Resources;
    using System.Runtime.CompilerServices;
    using System.Security.Permissions;
    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    using System.Web;
    using System.Web.Caching;
    using System.Web.Compilation;
    using System.Web.Util;
    using System.Xml;
    using Debug = System.Web.Util.Debug;

/*
 * Base class for Pages and UserControls
 */

/// <devdoc>
/// <para>Provides the <see cref='System.Web.UI.Page'/> class and the <see cref='System.Web.UI.UserControl'/> class with a base set of functionality.</para>
/// </devdoc>
public abstract class TemplateControl : Control, INamingContainer, IFilterResolutionService {

    // Used for the literal string optimization (reading strings from resource)
    private IntPtr _stringResourcePointer;
    private int _maxResourceOffset;
    private static object _lockObject = new object();

    // Caches the list of auto-hookup methods for each compiled Type (Hashtable<Type,ListDictionary>).
    // We use a Hashtable instead of the central Cache for optimal performance (VSWhidbey 479476)
    private static Hashtable _eventListCache = new Hashtable();

    private static object _emptyEventSingleton = new EventList();

    private VirtualPath _virtualPath;

    private IResourceProvider _resourceProvider;

    private const string _pagePreInitEventName                = "Page_PreInit";
    private const string _pageInitEventName                   = "Page_Init";
    private const string _pageInitCompleteEventName           = "Page_InitComplete";
    private const string _pageLoadEventName                   = "Page_Load";
    private const string _pagePreLoadEventName                = "Page_PreLoad";
    private const string _pageLoadCompleteEventName           = "Page_LoadComplete";
    private const string _pagePreRenderCompleteEventName      = "Page_PreRenderComplete";
    private const string _pagePreRenderCompleteAsyncEventName = "Page_PreRenderCompleteAsync";
    private const string _pageDataBindEventName               = "Page_DataBind";
    private const string _pagePreRenderEventName              = "Page_PreRender";
    private const string _pageSaveStateCompleteEventName      = "Page_SaveStateComplete";
    private const string _pageUnloadEventName                 = "Page_Unload";
    private const string _pageErrorEventName                  = "Page_Error";
    private const string _pageAbortTransactionEventName       = "Page_AbortTransaction";
    private const string _onTransactionAbortEventName         = "OnTransactionAbort";
    private const string _pageCommitTransactionEventName      = "Page_CommitTransaction";
    private const string _onTransactionCommitEventName        = "OnTransactionCommit";

    private static IDictionary _eventObjects;

    // Used to implement no-compile pages/uc
    private BuildResultNoCompileTemplateControl _noCompileBuildResult;

    static TemplateControl() {
        _eventObjects = new Hashtable(16);
        _eventObjects.Add(_pagePreInitEventName, Page.EventPreInit);
        _eventObjects.Add(_pageInitEventName, EventInit);
        _eventObjects.Add(_pageInitCompleteEventName, Page.EventInitComplete);
        _eventObjects.Add(_pageLoadEventName, EventLoad);
        _eventObjects.Add(_pagePreLoadEventName, Page.EventPreLoad);
        _eventObjects.Add(_pageLoadCompleteEventName, Page.EventLoadComplete);
        _eventObjects.Add(_pagePreRenderCompleteEventName, Page.EventPreRenderComplete);
        _eventObjects.Add(_pageDataBindEventName, EventDataBinding);
        _eventObjects.Add(_pagePreRenderEventName, EventPreRender);
        _eventObjects.Add(_pageSaveStateCompleteEventName, Page.EventSaveStateComplete);
        _eventObjects.Add(_pageUnloadEventName, EventUnload);
        _eventObjects.Add(_pageErrorEventName, EventError);
        _eventObjects.Add(_pageAbortTransactionEventName, EventAbortTransaction);
        _eventObjects.Add(_onTransactionAbortEventName, EventAbortTransaction);
        _eventObjects.Add(_pageCommitTransactionEventName, EventCommitTransaction);
        _eventObjects.Add(_onTransactionCommitEventName, EventCommitTransaction);
    }


    protected TemplateControl() {
        Construct();
    }


    /// <devdoc>
    /// <para>Do construction time logic (ASURT 66166)</para>
    /// </devdoc>
    protected virtual void Construct() {}


    private static readonly object EventCommitTransaction = new object();


    /// <devdoc>
    ///    <para>Occurs when a user initiates a transaction.</para>
    /// </devdoc>
    [
    WebSysDescription(SR.Page_OnCommitTransaction)
    ]
    public event EventHandler CommitTransaction {
        add {
            Events.AddHandler(EventCommitTransaction, value);
        }
        remove {
            Events.RemoveHandler(EventCommitTransaction, value);
        }
    }

    /// <devdoc>
    ///    <para>Gets and sets a value indicating whether theme is enabled.</para>
    /// </devdoc>
    [
    Browsable(true)
    ]
    public override bool EnableTheming {
        get {
            return base.EnableTheming;
        }
        set {
            base.EnableTheming = value;
        }
    }


    /// <devdoc>
    /// <para>Raises the <see langword='CommitTransaction'/> event. You can use this method
    ///    for any transaction processing logic in which your page or user control
    ///    participates.</para>
    /// </devdoc>
    protected virtual void OnCommitTransaction(EventArgs e) {
        EventHandler handler = (EventHandler)Events[EventCommitTransaction];
        if (handler != null) handler(this, e);
    }

    private static readonly object EventAbortTransaction = new object();


    /// <devdoc>
    ///    <para>Occurs when a user aborts a transaction.</para>
    /// </devdoc>
    [
    WebSysDescription(SR.Page_OnAbortTransaction)
    ]
    public event EventHandler AbortTransaction {
        add {
            Events.AddHandler(EventAbortTransaction, value);
        }
        remove {
            Events.RemoveHandler(EventAbortTransaction, value);
        }
    }


    /// <devdoc>
    /// <para>Raises the <see langword='AbortTransaction'/> event.</para>
    /// </devdoc>
    protected virtual void OnAbortTransaction(EventArgs e) {
        EventHandler handler = (EventHandler)Events[EventAbortTransaction];
        if (handler != null) handler(this, e);
    }

    // Page_Error related events/methods

    private static readonly object EventError = new object();


    /// <devdoc>
    ///    <para>Occurs when an uncaught exception is thrown.</para>
    /// </devdoc>
    [
    WebSysDescription(SR.Page_ErrorDescription)
    ]
    public event EventHandler Error {
        add {
            Events.AddHandler(EventError, value);
        }
        remove {
            Events.RemoveHandler(EventError, value);
        }
    }


    /// <devdoc>
    /// <para>Raises the <see langword='Error'/> event.
    ///    </para>
    /// </devdoc>
    protected virtual void OnError(EventArgs e) {
        EventHandler handler = (EventHandler)Events[EventError];
        if (handler != null) handler(this, e);
    }

    /*
     * Receive a no-compile build result that we call during FrameworkInitialize
     */
    internal void SetNoCompileBuildResult(BuildResultNoCompileTemplateControl noCompileBuildResult) {
        _noCompileBuildResult = noCompileBuildResult;
    }

    internal bool NoCompile {
        get { return _noCompileBuildResult != null; }
    }

    /*
     * Method sometime overidden by the generated sub classes.  Users
     * should not override.
     */

    /// <internalonly/>
    /// <devdoc>
    ///    <para>Initializes the requested page. While this is sometimes
    ///       overridden when the page is generated at runtime, you should not explicitly override this method.</para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected virtual void FrameworkInitialize() {

        // If it's non-compiled, perform the FrameworkInitialize logic.
        if (NoCompile) {
            if (!HttpRuntime.DisableProcessRequestInApplicationTrust) {
                // If PermitOnly was disabled in config, we call PermitOnly from here so that at least
                // the control tree creation is protected, as it always is for compiled pages (VSWhidbey 449666)
                if (HttpRuntime.NamedPermissionSet != null && !HttpRuntime.ProcessRequestInApplicationTrust) {
                    HttpRuntime.NamedPermissionSet.PermitOnly();
                }
            }

            _noCompileBuildResult.FrameworkInitialize(this);
        }
    }

    /*
     * This property is overriden by the generated classes (hence it cannot be internal)
     * If false, we don't do the HookUpAutomaticHandlers() magic.
     */

    /// <internalonly/>
    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected virtual bool SupportAutoEvents  {
        get { return true; }
    }

    /*
     * Returns a pointer to the resource buffer, and the largest valid offset
     * in the buffer (for security reason)
     */
    internal IntPtr StringResourcePointer { get { return _stringResourcePointer; } }
    internal int MaxResourceOffset { get { return _maxResourceOffset; } }


    // This method is now obsolete.  Ideally, we should get rid of it altogether, but that
    // would be a breaking change (VSWhidbey 464430)
    // We now use the parameter-less override, which is simpler
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static object ReadStringResource(Type t) {
        return StringResourceManager.ReadSafeStringResource(t);
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    public object ReadStringResource() {
        return StringResourceManager.ReadSafeStringResource(GetType());
    }


    /// <internalonly/>
    /// <devdoc>
    ///    <para>This method is called by the generated classes (hence it cannot be internal)</para>
    /// </devdoc>
    protected LiteralControl CreateResourceBasedLiteralControl(int offset, int size, bool fAsciiOnly) {
        return new ResourceBasedLiteralControl(this, offset, size, fAsciiOnly);
    }


    /// <internalonly/>
    /// <devdoc>
    ///    <para>This method is called by the generated classes (hence it cannot be internal)</para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected void SetStringResourcePointer(object stringResourcePointer, int maxResourceOffset) {

        // Ignore the passed in maxResourceOffset, which cannot be trusted.  Instead, use
        // the resource size that we obtained from the resource (ASURT 122759)
        SafeStringResource ssr = (SafeStringResource) stringResourcePointer;
        _stringResourcePointer = ssr.StringResourcePointer;
        _maxResourceOffset = ssr.ResourceSize;
    }

    internal VirtualPath VirtualPath {
        get {
            return _virtualPath;
        }
    }

    [
    EditorBrowsable(EditorBrowsableState.Advanced),
    Browsable(false)
    ]
    public string AppRelativeVirtualPath {
        get {
            return VirtualPath.GetAppRelativeVirtualPathString(TemplateControlVirtualPath);
        }
        set {
            // Set the TemplateSourceDirectory based on the VirtualPath
            this.TemplateControlVirtualPath = VirtualPath.CreateNonRelative(value);
        }
    }

    internal VirtualPath TemplateControlVirtualPath {
        get {
            return _virtualPath;
        }
        set {
            _virtualPath = value;

            // Set the TemplateSourceDirectory based on the VirtualPath
            this.TemplateControlVirtualDirectory = _virtualPath.Parent;
        }
    }


    /// <devdoc>
    ///    <para>Tests if a device filter applies to this request</para>
    /// </devdoc>
    public virtual bool TestDeviceFilter(string filterName) {
        return(Context.Request.Browser.IsBrowser(filterName));
    }


    /// <internalonly/>
    /// <devdoc>
    ///    <para>This method is called by the generated classes (hence it cannot be internal)</para>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Never)]
    protected void WriteUTF8ResourceString(HtmlTextWriter output, int offset, int size, bool fAsciiOnly) {

        // Make sure we don't access invalid data
        checked {
            if (offset < 0 || size < 0 || offset + size > _maxResourceOffset)
                throw new ArgumentOutOfRangeException("offset");
        }

        output.WriteUTF8ResourceString(StringResourcePointer, offset, size, fAsciiOnly);
    }

    /*
     * This method is overriden by the generated classes (hence it cannot be internal)
     */

    /// <internalonly/>
    /// <devdoc>
    /// </devdoc>
    [EditorBrowsable(EditorBrowsableState.Never)]
    [Obsolete("Use of this property is not recommended because it is no longer useful. http://go.microsoft.com/fwlink/?linkid=14202")]
    protected virtual int AutoHandlers {
        get { return 0;}
        set {}
    }

    internal override TemplateControl GetTemplateControl() {
        return this;
    }

    [SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification = "See comment on GetDelegateInformationWithAssert.")]
    internal void HookUpAutomaticHandlers() {
        // Do nothing if auto-events are not supported
        if (!SupportAutoEvents) {
            return;
        }

        // Get the event list for this Type from our cache, if possible
        object o = _eventListCache[GetType()];
        EventList eventList;

        // Try to find what handlers are implemented if not tried before
        if (o == null) {
            lock (_lockObject) {

                // Try the cache again, in case another thread took care of it
                o = (EventList)_eventListCache[GetType()];

                if (o == null) {
                    eventList = new EventList();

                    GetDelegateInformation(eventList);

                    // Cannot find any known handlers.
                    if (eventList.IsEmpty) {
                        o = _emptyEventSingleton;
                    }
                    else {
                        o = eventList;
                    }

                    // Cache it for next time
                    _eventListCache[GetType()] = o;
                }
            }
        }

        // Don't do any thing if no known handlers are found.
        if (o == _emptyEventSingleton) {
            return;
        }

        eventList = (EventList)o;
        IDictionary<string, SyncEventMethodInfo> syncEvents = eventList.SyncEvents;

        // Hook up synchronous events
        foreach (var entry in syncEvents) {
            string key = entry.Key;
            SyncEventMethodInfo info = entry.Value;

            Debug.Assert(_eventObjects[key] != null);

            bool eventExists = false;
            MethodInfo methodInfo = info.MethodInfo;

            Delegate eventDelegates = Events[_eventObjects[key]];
            if (eventDelegates != null) {
                foreach (Delegate eventDelegate in eventDelegates.GetInvocationList()) {
                    // Ignore if this method is already added to the events list.
                    if (eventDelegate.Method.Equals(methodInfo)) {
                        eventExists = true;
                        break;
                    }
                }
            }

            if (!eventExists) {
                // Create a new Calli delegate proxy
                IntPtr functionPtr = methodInfo.MethodHandle.GetFunctionPointer();
                EventHandler handler = (new CalliEventHandlerDelegateProxy(this, functionPtr, info.IsArgless)).Handler;

                // Adds the delegate to events list.
                Events.AddHandler(_eventObjects[key], handler);
            }
        }

        // Hook up asynchronous events
        IDictionary<string, AsyncEventMethodInfo> asyncEvents = eventList.AsyncEvents;

        AsyncEventMethodInfo preRenderCompleteAsyncEvent;
        if (asyncEvents.TryGetValue(_pagePreRenderCompleteAsyncEventName, out preRenderCompleteAsyncEvent)) {
            Page page = (Page)this; // this event handler only exists for the Page type
            if (preRenderCompleteAsyncEvent.RequiresCancellationToken) {
                var handler = FastDelegateCreator<Func<CancellationToken, Task>>.BindTo(this, preRenderCompleteAsyncEvent.MethodInfo);
                page.RegisterAsyncTask(new PageAsyncTask(handler));
            }
            else {
                var handler = FastDelegateCreator<Func<Task>>.BindTo(this, preRenderCompleteAsyncEvent.MethodInfo);
                page.RegisterAsyncTask(new PageAsyncTask(handler));
            }
        }
    }

    private void GetDelegateInformation(EventList eventList) {
        if (HttpRuntime.IsFullTrust) {
            GetDelegateInformationWithNoAssert(eventList);
        }
        else {
            GetDelegateInformationWithAssert(eventList);
        }
    }

    // Make sure we have reflection permission to discover the handlers (ASURT 105965)
    // Using this permission is bad practice; we should use RMA instead of full MemberAccess,
    // or we should force the instance methods to be public. But this is a legacy behavior
    // and we can't change it without breaking the world.
    [ReflectionPermission(SecurityAction.Assert, Flags = ReflectionPermissionFlag.MemberAccess)]
    [SuppressMessage("Microsoft.Security", "CA2106:SecureAsserts", Justification = "See comment above.")]
    private void GetDelegateInformationWithAssert(EventList eventList) {
        GetDelegateInformationWithNoAssert(eventList);
    }

    private void GetDelegateInformationWithNoAssert(EventList eventList) {
        IDictionary<string, SyncEventMethodInfo> syncEventDictionary = eventList.SyncEvents;
        IDictionary<string, AsyncEventMethodInfo> asyncEventDictionary = eventList.AsyncEvents;

        if (this is Page) {
            /* SYNCHRONOUS - Page */

            GetDelegateInformationFromSyncMethod(_pagePreInitEventName, syncEventDictionary);
            GetDelegateInformationFromSyncMethod(_pagePreLoadEventName, syncEventDictionary);
            GetDelegateInformationFromSyncMethod(_pageLoadCompleteEventName, syncEventDictionary);
            GetDelegateInformationFromSyncMethod(_pagePreRenderCompleteEventName, syncEventDictionary);
            GetDelegateInformationFromSyncMethod(_pageInitCompleteEventName, syncEventDictionary);
            GetDelegateInformationFromSyncMethod(_pageSaveStateCompleteEventName, syncEventDictionary);

            /* ASYNCHRONOUS - Page */

            GetDelegateInformationFromAsyncMethod(_pagePreRenderCompleteAsyncEventName, asyncEventDictionary);
        }

        /* SYNCHRONOUS - Control */

        GetDelegateInformationFromSyncMethod(_pageInitEventName, syncEventDictionary);
        GetDelegateInformationFromSyncMethod(_pageLoadEventName, syncEventDictionary);
        GetDelegateInformationFromSyncMethod(_pageDataBindEventName, syncEventDictionary);
        GetDelegateInformationFromSyncMethod(_pagePreRenderEventName, syncEventDictionary);
        GetDelegateInformationFromSyncMethod(_pageUnloadEventName, syncEventDictionary);
        GetDelegateInformationFromSyncMethod(_pageErrorEventName, syncEventDictionary);

        if (!GetDelegateInformationFromSyncMethod(_pageAbortTransactionEventName, syncEventDictionary)) {
            GetDelegateInformationFromSyncMethod(_onTransactionAbortEventName, syncEventDictionary);
        }

        if (!GetDelegateInformationFromSyncMethod(_pageCommitTransactionEventName, syncEventDictionary)) {
            GetDelegateInformationFromSyncMethod(_onTransactionCommitEventName, syncEventDictionary);
        }

        /* ASYNCHRONOUS - Control */

    }

    private bool GetDelegateInformationFromAsyncMethod(string methodName, IDictionary<string, AsyncEventMethodInfo> dictionary) {
        // First, try to get a delegate to the single-parameter handler
        MethodInfo parameterfulMethod = GetInstanceMethodInfo(typeof(Func<CancellationToken, Task>), methodName);
        if (parameterfulMethod != null) {
            dictionary[methodName] = new AsyncEventMethodInfo(parameterfulMethod, requiresCancellationToken: true);
            return true;
        }

        // If there isn't one, try the argless one
        MethodInfo parameterlessMethod = GetInstanceMethodInfo(typeof(Func<Task>), methodName);
        if (parameterlessMethod != null) {
            dictionary[methodName] = new AsyncEventMethodInfo(parameterlessMethod, requiresCancellationToken: false);
            return true;
        }

        return false;
    }

    private bool GetDelegateInformationFromSyncMethod(string methodName, IDictionary<string, SyncEventMethodInfo> dictionary) {
        // First, try to get a delegate to the two parameter handler
        MethodInfo parameterfulMethod = GetInstanceMethodInfo(typeof(EventHandler), methodName);
        if (parameterfulMethod != null) {
            dictionary[methodName] = new SyncEventMethodInfo(parameterfulMethod, isArgless: false);
            return true;
        }

        // If there isn't one, try the argless one
        MethodInfo parameterlessMethod = GetInstanceMethodInfo(typeof(VoidMethod), methodName);
        if (parameterlessMethod != null) {
            dictionary[methodName] = new SyncEventMethodInfo(parameterlessMethod, isArgless: true);
            return true;
        }

        return false;
    }

    private MethodInfo GetInstanceMethodInfo(Type delegateType, string methodName) {
        Delegate del = Delegate.CreateDelegate(
            type: delegateType,
            target: this,
            method: methodName,
            ignoreCase: true,
            throwOnBindFailure: false);

        return (del != null) ? del.Method : null;
    }


    /// <devdoc>
    /// <para>Obtains a <see cref='System.Web.UI.UserControl'/> object from a user control file.</para>
    /// </devdoc>
    public Control LoadControl(string virtualPath) {

        return LoadControl(VirtualPath.Create(virtualPath));
    }

    internal Control LoadControl(VirtualPath virtualPath) {

        // If it's relative, make it *app* relative.  Treat is as relative to this
        // user control (ASURT 55513)
        virtualPath = VirtualPath.Combine(this.TemplateControlVirtualDirectory, virtualPath);

        // Process the user control and get its BuildResult
        BuildResult result = BuildManager.GetVPathBuildResult(Context, virtualPath);

        return LoadControl((IWebObjectFactory)result, virtualPath, null /*Type*/, null /*parameters*/);
    }

    // Make sure we have reflection permission to use GetMethod below (ASURT 106196)
    [ReflectionPermission(SecurityAction.Assert, Flags=ReflectionPermissionFlag.MemberAccess)]
    private void AddStackContextToHashCode(HashCodeCombiner combinedHashCode) {

        StackTrace st = new StackTrace();

        // First, skip all the stack frames that are in the TemplateControl class, as
        // they are irrelevant to the hash.  Start the search at 2 since we know for sure
        // that this method and its caller are in TemplateControl.
        int startingUserFrame = 2;
        for (; ; startingUserFrame++) {
            StackFrame f = st.GetFrame(startingUserFrame);
            if (f.GetMethod().DeclaringType != typeof(TemplateControl)) {
                break;
            }
        }

        // Get a cache key based on the top two items of the caller's stack.
        // It's not guaranteed unique, but for all common cases, it will be
        for (int i = startingUserFrame; i < startingUserFrame + 2; i++) {
            StackFrame f = st.GetFrame(i);

            MethodBase m = f.GetMethod();
            combinedHashCode.AddObject(m.DeclaringType.AssemblyQualifiedName);
            combinedHashCode.AddObject(m.Name);
            combinedHashCode.AddObject(f.GetNativeOffset());
        }
    }


    public Control LoadControl(Type t, object[] parameters) {

        return LoadControl(null /*IWebObjectFactory*/, null /*virtualPath*/, t, parameters);
    }


    private Control LoadControl(IWebObjectFactory objectFactory, VirtualPath virtualPath, Type t, object[] parameters) {

        // Make sure we get an object factory or a type, but not both
        Debug.Assert((objectFactory == null) != (t == null));

        BuildResultCompiledType compiledUCResult = null;
        BuildResultNoCompileUserControl noCompileUCResult = null;

        if (objectFactory != null) {
            // It can be a compiled or no-compile user control
            compiledUCResult = objectFactory as BuildResultCompiledType;
            if (compiledUCResult != null) {
                t = compiledUCResult.ResultType;
                Debug.Assert(t != null);

                // Make sure it's a user control (VSWhidbey 428718)
                Util.CheckAssignableType(typeof(UserControl), t);
            }
            else {
                noCompileUCResult = (BuildResultNoCompileUserControl)objectFactory;
                Debug.Assert(noCompileUCResult != null);
            }
        }
        else {
            // Make sure the type has the correct base class (ASURT 123677)
            if (t != null)
                Util.CheckAssignableType(typeof(Control), t);
        }

        PartialCachingAttribute cacheAttrib;

        // Check if the user control has a PartialCachingAttribute attribute
        if (t != null) {
            cacheAttrib = (PartialCachingAttribute)
                TypeDescriptor.GetAttributes(t)[typeof(PartialCachingAttribute)];
        }
        else {
            cacheAttrib = noCompileUCResult.CachingAttribute;
        }

        if (cacheAttrib == null) {
            // The control is not cached.  Just create it.
            Control c;
            if (objectFactory != null) {
                c = (Control) objectFactory.CreateInstance();
            }
            else {
                c = (Control) HttpRuntime.CreatePublicInstance(t, parameters);
            }

            // If it's a user control, do some extra initialization
            UserControl uc = c as UserControl;
            if (uc != null) {
                Debug.Assert(virtualPath != null);
                if (virtualPath != null)
                    uc.TemplateControlVirtualPath = virtualPath;
                uc.InitializeAsUserControl(Page);
            }

            return c;
        }

        HashCodeCombiner combinedHashCode = new HashCodeCombiner();

        // Start by adding the type or object factory of the user control to the hash.
        // This guarantees that two unrelated user controls don't share the same cached data.
        if (objectFactory != null) {
            combinedHashCode.AddObject(objectFactory);
        }
        else {
            combinedHashCode.AddObject(t);
        }

        // If it's not shared, add some stack frames to the hash
        if (!cacheAttrib.Shared) {
            AddStackContextToHashCode(combinedHashCode);
        }

        string cacheKey = combinedHashCode.CombinedHashString;

        // Wrap it to allow it to be cached
        return new PartialCachingControl(objectFactory, t, cacheAttrib, "_" + cacheKey, parameters);
    }

    // Class that implements the templates returned by LoadTemplate (ASURT 94138)
    internal class SimpleTemplate : ITemplate {
        private IWebObjectFactory _objectFactory;

        internal SimpleTemplate(ITypedWebObjectFactory objectFactory) {

            // Make sure it's a user control (VSWhidbey 428718)
            Util.CheckAssignableType(typeof(UserControl), objectFactory.InstantiatedType);

            _objectFactory = objectFactory;
        }

        public virtual void InstantiateIn(Control control) {
            UserControl uc = (UserControl)_objectFactory.CreateInstance();

            uc.InitializeAsUserControl(control.Page);

            control.Controls.Add(uc);
        }
    }


    /// <devdoc>
    ///    <para>
    ///       Obtains an instance of the <see langword='ITemplate'/> interface from an
    ///       external file.
    ///    </para>
    /// </devdoc>
    public ITemplate LoadTemplate(string virtualPath) {
        return LoadTemplate(VirtualPath.Create(virtualPath));
    }

    internal ITemplate LoadTemplate(VirtualPath virtualPath) {

        // If it's relative, make it *app* relative.  Treat is as relative to this
        // user control (ASURT 55513)
        virtualPath = VirtualPath.Combine(TemplateControlVirtualDirectory, virtualPath);

        // Compile the declarative template and get its object factory
        ITypedWebObjectFactory objectFactory = (ITypedWebObjectFactory)BuildManager.GetVPathBuildResult(
            Context, virtualPath);

        return new SimpleTemplate(objectFactory);
    }


    /// <devdoc>
    ///    <para> Parse the input string into a Control.  Looks for the first control
    ///    in the input.  Returns null if none is found.</para>
    /// </devdoc>
    public Control ParseControl(string content) {
        return ParseControl(content, true);
    }

    public Control ParseControl(string content, bool ignoreParserFilter) {
        return TemplateParser.ParseControl(content, VirtualPath.Create(AppRelativeVirtualPath), ignoreParserFilter);
    }

#if NOTYET

    /// <devdoc>
    ///    <para> Parse the input string into an ITemplate.</para>
    /// </devdoc>
    internal ITemplate ParseTemplate(string content) {
        return TemplateParser.ParseTemplate(content, AppRelativeTemplateSourceDirectory);
    }
#endif

    /// <devdoc>
    /// Used by simplified databinding methods to ensure they can only be called when the control is on a page.
    /// </devdoc>
    private void CheckPageExists() {
        if (Page == null) {
            throw new InvalidOperationException(SR.GetString(SR.TemplateControl_DataBindingRequiresPage));
        }
    }


    /// <devdoc>
    /// Simplified databinding Eval() method. This method uses the current data item to evaluate an expression using DataBinder.Eval().
    /// The data item is retrieved using either the IDataItemContainer interface or by looking for a property called 'DataItem'.
    /// If the data item is not found, an exception is thrown.
    /// </devdoc>
    protected internal object Eval(string expression) {
        CheckPageExists();
        return DataBinder.Eval(Page.GetDataItem(), expression);
    }


    /// <devdoc>
    /// Simplified databinding Eval() method with a format expression. This method uses the current data item to evaluate an expression using DataBinder.Eval().
    /// The data item is retrieved using either the IDataItemContainer interface or by looking for a property called 'DataItem'.
    /// If the data item is not found, an exception is thrown.
    /// </devdoc>
    protected internal string Eval(string expression, string format) {
        CheckPageExists();
        return DataBinder.Eval(Page.GetDataItem(), expression, format);
    }


    /// <devdoc>
    /// Simplified databinding XPath() method. This method uses the current data item to evaluate an XPath expression using XPathBinder.Eval().
    /// The data item is retrieved using either the IDataItemContainer interface or by looking for a property called 'DataItem'.
    /// If the data item is not found, an exception is thrown.
    /// </devdoc>
    protected internal object XPath(string xPathExpression) {
        CheckPageExists();
        return XPathBinder.Eval(Page.GetDataItem(), xPathExpression);
    }

    /// <devdoc>
    /// Simplified databinding XPath() method. This method uses the current data item and a namespace resolver
    /// to evaluate an XPath expression using XPathBinder.Eval().
    /// The data item is retrieved using either the IDataItemContainer interface or by looking for a property called 'DataItem'.
    /// If the data item is not found, an exception is thrown.
    /// </devdoc>
    protected internal object XPath(string xPathExpression, IXmlNamespaceResolver resolver) {
        CheckPageExists();
        return XPathBinder.Eval(Page.GetDataItem(), xPathExpression, resolver);
    }
    

    /// <devdoc>
    /// Simplified databinding XPath() method with a format expression. This method uses the current data item to evaluate an XPath expression using XPathBinder.Eval().
    /// The data item is retrieved using either the IDataItemContainer interface or by looking for a property called 'DataItem'.
    /// If the data item is not found, an exception is thrown.
    /// </devdoc>
    protected internal string XPath(string xPathExpression, string format) {
        CheckPageExists();
        return XPathBinder.Eval(Page.GetDataItem(), xPathExpression, format);
    }

    /// <devdoc>
    /// Simplified databinding XPath() method with a format expression. This method uses the current data item and a namespace resolver
    /// to evaluate an XPath expression using XPathBinder.Eval().
    /// The data item is retrieved using either the IDataItemContainer interface or by looking for a property called 'DataItem'.
    /// If the data item is not found, an exception is thrown.
    /// </devdoc>
    protected internal string XPath(string xPathExpression, string format, IXmlNamespaceResolver resolver) {
        CheckPageExists();
        return XPathBinder.Eval(Page.GetDataItem(), xPathExpression, format, resolver);
    }
    

    /// <devdoc>
    /// Simplified databinding XPathSelect() method. This method uses the current data item to evaluate an XPath expression that returns a node list using XPathBinder.Select().
    /// The data item is retrieved using either the IDataItemContainer interface or by looking for a property called 'DataItem'.
    /// If the data item is not found, an exception is thrown.
    /// </devdoc>
    protected internal IEnumerable XPathSelect(string xPathExpression) {
        CheckPageExists();
        return XPathBinder.Select(Page.GetDataItem(), xPathExpression);
    }

    /// <devdoc>
    /// Simplified databinding XPathSelect() method. This method uses the current data item and a namespace resolver
    /// to evaluate an XPath expression that returns a node list using XPathBinder.Select().
    /// The data item is retrieved using either the IDataItemContainer interface or by looking for a property called 'DataItem'.
    /// If the data item is not found, an exception is thrown.
    /// </devdoc>
    protected internal IEnumerable XPathSelect(string xPathExpression, IXmlNamespaceResolver resolver) {
        CheckPageExists();
        return XPathBinder.Select(Page.GetDataItem(), xPathExpression, resolver);
    }


    /// <devdoc>
    /// Return a Page-level resource object
    /// </devdoc>
    protected object GetLocalResourceObject(string resourceKey) {

        // Cache the resource provider in the template control, so that if a Page needs to call
        // this multiple times, we don't need to call ResourceExpressionBuilder.GetLocalResourceProvider
        // every time.
        if (_resourceProvider == null)
            _resourceProvider = ResourceExpressionBuilder.GetLocalResourceProvider(this);

        return ResourceExpressionBuilder.GetResourceObject(_resourceProvider, resourceKey, null /*culture*/);
    }

    protected object GetLocalResourceObject(string resourceKey, Type objType, string propName) {

        // Cache the resource provider in the template control, so that if a Page needs to call
        // this multiple times, we don't need to call ResourceExpressionBuilder.GetLocalResourceProvider
        // every time.
        if (_resourceProvider == null)
            _resourceProvider = ResourceExpressionBuilder.GetLocalResourceProvider(this);

        return ResourceExpressionBuilder.GetResourceObject(_resourceProvider,
            resourceKey, null /*culture*/, objType, propName);
    }


    /// <devdoc>
    /// Return an App-level resource object
    /// </devdoc>
    protected object GetGlobalResourceObject(string className, string resourceKey) {
        return ResourceExpressionBuilder.GetGlobalResourceObject(className, resourceKey, null, null, null);
    }

    protected object GetGlobalResourceObject(string className, string resourceKey, Type objType, string propName) {
        return ResourceExpressionBuilder.GetGlobalResourceObject(className, resourceKey, objType, propName, null);
    }

    #region IFilterResolutionService

    /// <internalonly/>
    bool IFilterResolutionService.EvaluateFilter(string filterName) {
        return TestDeviceFilter(filterName);
    }


    /// <internalonly/>
    int IFilterResolutionService.CompareFilters(string filter1, string filter2) {
        return BrowserCapabilitiesCompiler.BrowserCapabilitiesFactory.CompareFilters(filter1, filter2);
    }
    #endregion

    private class EventList {
        internal readonly IDictionary<string, AsyncEventMethodInfo> AsyncEvents = new Dictionary<string, AsyncEventMethodInfo>(StringComparer.Ordinal);
        internal readonly IDictionary<string, SyncEventMethodInfo> SyncEvents = new Dictionary<string, SyncEventMethodInfo>(StringComparer.Ordinal);

        internal bool IsEmpty {
            get {
                return (AsyncEvents.Count == 0 && SyncEvents.Count == 0);
            }
        }
    }

    // Internal helper class for storing the event info
    private class SyncEventMethodInfo {
        internal SyncEventMethodInfo(MethodInfo methodInfo, bool isArgless){
            if (IsAsyncVoidMethod(methodInfo)) {
                SynchronizationContextUtil.ValidateModeForPageAsyncVoidMethods();
            }

            MethodInfo = methodInfo;
            IsArgless = isArgless;
        }

        internal bool IsArgless { get; private set; }
        internal MethodInfo MethodInfo { get; private set; }

        private static bool IsAsyncVoidMethod(MethodInfo methodInfo) {
            // When the C# / VB compilers generate an 'async void' method, they'll put
            // an [AsyncStateMachine] attribute on the entry point. This marker attribute
            // can be used to detect these methods. It's not 100% reliable, since it's
            // possible that a normal void method simply calls an async void method, and
            // the 'outer' method won't contain this attribute. But the heuristic is
            // good enough to help developers land in the pit of success re: async.

            return methodInfo.IsDefined(typeof(AsyncStateMachineAttribute), inherit: false);
        }
    }

    private class AsyncEventMethodInfo {
        internal AsyncEventMethodInfo(MethodInfo methodInfo, bool requiresCancellationToken) {
            MethodInfo = methodInfo;
            RequiresCancellationToken = requiresCancellationToken;
        }

        internal MethodInfo MethodInfo { get; private set; }
        internal bool RequiresCancellationToken { get; private set; }
    }
}
}