linux-packaging-mono/mcs/class/referencesource/System.Web/UI/PartialCachingControl.cs

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

namespace System.Web.UI {

    using System;
    using System.IO;
    using System.Text;
    using System.Collections;
    using System.Collections.Specialized;
    using System.ComponentModel;
    using System.ComponentModel.Design;
    using System.Globalization;
    using System.Web;
    using System.Web.Util;
    using System.Web.UI.HtmlControls;
    using System.Web.UI.WebControls;
    using System.Web.Caching;
    using System.Web.Compilation;
    using System.Web.Configuration;
    using System.Security.Permissions;


    // Keeps track of one call to Page Register* API
    // The semantics of the fields depends to the call type
    [Serializable]
internal class RegisterCallData {
    internal ClientAPIRegisterType Type;
    internal ScriptKey Key;
    internal string StringParam1;
    internal string StringParam2;
    internal string StringParam3;
}

// Data that we need to cache
[Serializable]
internal class PartialCachingCacheEntry {
    internal    Guid                      _cachedVaryId;
    internal    string                    _dependenciesKey;
    internal    string[]                  _dependencies; // file dependencies

    internal string OutputString;
    internal string CssStyleString;
    internal ArrayList RegisteredClientCalls;
}

/// <devdoc>
///    <para>[To be supplied.]</para>
/// </devdoc>
[
ToolboxItem(false)
]
public abstract class BasePartialCachingControl : Control {

    internal Control _cachedCtrl;
    private long _nonVaryHashCode;
    internal string _ctrlID;
    internal string _guid;
    internal DateTime _utcExpirationTime;
    internal bool _useSlidingExpiration;
    internal HttpCacheVaryByParams _varyByParamsCollection;
    internal string[] _varyByControlsCollection;
    internal string _varyByCustom;
    internal string _sqlDependency;
    internal string _provider;
    internal bool _cachingDisabled;
    private string _outputString;
    private string _cssStyleString;
    private string _cacheKey;
    private CacheDependency _cacheDependency;
    private PartialCachingCacheEntry _cacheEntry;
    private ControlCachePolicy _cachePolicy;
    private ArrayList _registeredCallDataForEventValidation;
    private ArrayList _registeredStyleInfo = null;

    internal const char varySeparator = ';';
    internal const string varySeparatorString = ";";

    internal override void InitRecursive(Control namingContainer) {

        HashCodeCombiner combinedHashCode = new HashCodeCombiner();

        _cacheKey = ComputeNonVaryCacheKey(combinedHashCode);

        // Save the non-varying hash, so we don't need to recalculate it later
        _nonVaryHashCode = combinedHashCode.CombinedHash;

        PartialCachingCacheEntry cacheEntry = null;

        // Check if there is a cache entry for the non-varying key
        object tmpCacheEntry = OutputCache.GetFragment(_cacheKey, _provider);

        if (tmpCacheEntry != null) {
            ControlCachedVary cachedVary = tmpCacheEntry as ControlCachedVary;
            if (cachedVary != null) {
                string varyCachedKey = ComputeVaryCacheKey(combinedHashCode, cachedVary);

                // Check if there is a cache entry for the varying key
                cacheEntry = (PartialCachingCacheEntry) OutputCache.GetFragment(varyCachedKey, _provider);
                if (cacheEntry != null && cacheEntry._cachedVaryId != cachedVary.CachedVaryId) {
                    cacheEntry = null;
                    // explicitly remove the entry
                    OutputCache.RemoveFragment(varyCachedKey, _provider);
                }
            }
            else {
                // If it wasn't a ControlCachedVary, it must be a PartialCachingCacheEntry
                cacheEntry = (PartialCachingCacheEntry) tmpCacheEntry;
            }
        }

        // If it's a cache miss, create the control and make it our child
        if (cacheEntry == null) {

            // Cache miss

            _cacheEntry = new PartialCachingCacheEntry();

            _cachedCtrl = CreateCachedControl();
            Controls.Add(_cachedCtrl);

            // Make sure the Page knows about us while the control's OnInit is called
            Page.PushCachingControl(this);
            base.InitRecursive(namingContainer);
            Page.PopCachingControl();
        }
        else {

            // Cache hit

            _outputString = cacheEntry.OutputString;
            _cssStyleString = cacheEntry.CssStyleString;

            // If any calls to Register* API's were made when the control was run,
            // make them now to restore correct behavior (VSWhidbey 80907)
            if (cacheEntry.RegisteredClientCalls != null) {
                foreach (RegisterCallData registerCallData in cacheEntry.RegisteredClientCalls) {
                    switch (registerCallData.Type) {

                        case ClientAPIRegisterType.WebFormsScript:
                            Page.RegisterWebFormsScript();
                            break;

                        case ClientAPIRegisterType.PostBackScript:
                            Page.RegisterPostBackScript();
                            break;

                        case ClientAPIRegisterType.FocusScript:
                            Page.RegisterFocusScript();
                            break;

                        case ClientAPIRegisterType.ClientScriptBlocks:
                        case ClientAPIRegisterType.ClientScriptBlocksWithoutTags:
                        case ClientAPIRegisterType.ClientStartupScripts:
                        case ClientAPIRegisterType.ClientStartupScriptsWithoutTags:
                            Page.ClientScript.RegisterScriptBlock(registerCallData.Key,
                                registerCallData.StringParam2, registerCallData.Type);
                            break;

                        case ClientAPIRegisterType.OnSubmitStatement:
                            Page.ClientScript.RegisterOnSubmitStatementInternal(registerCallData.Key,
                                registerCallData.StringParam2);
                            break;

                        case ClientAPIRegisterType.ArrayDeclaration:
                            Page.ClientScript.RegisterArrayDeclaration(registerCallData.StringParam1,
                                registerCallData.StringParam2);
                            break;

                        case ClientAPIRegisterType.HiddenField:
                            Page.ClientScript.RegisterHiddenField(registerCallData.StringParam1,
                                registerCallData.StringParam2);
                            break;

                        case ClientAPIRegisterType.ExpandoAttribute:
                            Page.ClientScript.RegisterExpandoAttribute(registerCallData.StringParam1,
                                registerCallData.StringParam2, registerCallData.StringParam3, false);
                            break;

                        case ClientAPIRegisterType.EventValidation:
                            if (_registeredCallDataForEventValidation == null) {
                                _registeredCallDataForEventValidation = new ArrayList();
                            }

                            _registeredCallDataForEventValidation.Add(registerCallData);
                            break;
                        default:
                            Debug.Assert(false);
                            break;
                    }
                }
            }

            base.InitRecursive(namingContainer);
        }
    }

    internal override void LoadRecursive() {

        // If we're in a cache hit, don't do anything special
        if (_outputString != null) {
            base.LoadRecursive();
            return;
        }

        // Make sure the Page knows about us while the control's OnLoad is called
        Page.PushCachingControl(this);
        base.LoadRecursive();
        Page.PopCachingControl();
    }

    internal override void PreRenderRecursiveInternal() {

        // If we're in a cache hit, don't do anything special
        if (_outputString != null) {
            base.PreRenderRecursiveInternal();

            // register the cached styles on the Header control.
            if (_cssStyleString != null && Page.Header != null) {
                Page.Header.RegisterCssStyleString(_cssStyleString);
            }

            return;
        }

        // Make sure the Page knows about us while the control's OnPreRender is called
        Page.PushCachingControl(this);
        base.PreRenderRecursiveInternal();
        Page.PopCachingControl();
    }


    /// <internalonly/>
    public override void Dispose() {
        if (_cacheDependency != null) {
            _cacheDependency.Dispose();
            _cacheDependency = null;
        }

        base.Dispose();
    }

    internal abstract Control CreateCachedControl();


    /// <devdoc>
    ///    <para> Gets or sets the CacheDependency used to cache the control output.</para>
    /// </devdoc>
    public CacheDependency Dependency {
        get { return _cacheDependency; }
        set { _cacheDependency = value; }
    }


    public ControlCachePolicy CachePolicy {
        get {
            // Create the ControlCachePolicy object on demand
            if (_cachePolicy == null)
                _cachePolicy = new ControlCachePolicy(this);

            return _cachePolicy;
        }
    }

    internal HttpCacheVaryByParams VaryByParams {
        get {
            if (_varyByParamsCollection == null) {
                _varyByParamsCollection = new HttpCacheVaryByParams();
                _varyByParamsCollection.IgnoreParams = true;
            }

            return _varyByParamsCollection;
        }
    }
    
    internal string VaryByControl {
        get {
            if (_varyByControlsCollection == null)
                return String.Empty;

            return String.Join(varySeparatorString, _varyByControlsCollection);
        }
        
        set {
            if (String.IsNullOrEmpty(value)) {
                _varyByControlsCollection = null;
            }
            else {
                _varyByControlsCollection = value.Split(varySeparator);
            }
        }
    }
    
    internal TimeSpan Duration {
        get {
            // Special case MaxValue
            if (_utcExpirationTime == DateTime.MaxValue)
                return TimeSpan.MaxValue;

            return _utcExpirationTime - DateTime.UtcNow;
        }
        
        set {
            if (value == TimeSpan.MaxValue) {
                // If it's the max timespan, just make it DateTime.MaxValue to avoid
                // an overflow when adding (VSWhidbey 273271)
                _utcExpirationTime = DateTime.MaxValue;
            }
            else {
                // Compute the expiration time
                _utcExpirationTime = DateTime.UtcNow.Add(value);
            }
        }
    }

    private void RegisterValidationEvents() {
        if (_registeredCallDataForEventValidation != null) {
            foreach (RegisterCallData registerCallData in _registeredCallDataForEventValidation) {
                Page.ClientScript.RegisterForEventValidation(registerCallData.StringParam1,
                    registerCallData.StringParam2);
            }
        }
    }

    internal void RegisterStyleInfo(SelectorStyleInfo selectorInfo) {
        if (_registeredStyleInfo == null) {
            _registeredStyleInfo = new ArrayList();
        }

        _registeredStyleInfo.Add(selectorInfo);
    }

    /// <internalonly/>
    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    /// </devdoc>
    protected internal override void Render(HtmlTextWriter output) {
        CacheDependency sqlCacheDep = null;

        // If the output is cached, use it and do nothing else
        if (_outputString != null) {
            output.Write(_outputString);
            RegisterValidationEvents();
            return;
        }

        // If caching was turned off, just render the control
        if (_cachingDisabled || !RuntimeConfig.GetAppConfig().OutputCache.EnableFragmentCache) {
            _cachedCtrl.RenderControl(output);
            return;
        }

        // Create SQL cache dependency before we render the page
        if (_sqlDependency != null) {
            sqlCacheDep = SqlCacheDependency.CreateOutputCacheDependency(_sqlDependency);
        }

        _cacheEntry.CssStyleString = GetCssStyleRenderString(output.GetType());

        // Create a new HtmlTextWriter, with the same type as the current one (see ASURT 118922)
        StringWriter tmpWriter = new StringWriter();
        HtmlTextWriter tmpHtmlWriter = Page.CreateHtmlTextWriterFromType(tmpWriter, output.GetType());
        CacheDependency cacheDep;
        TextWriter savedWriter = Context.Response.SwitchWriter(tmpWriter);

        try {
            // Make sure the Page knows about us while the control's OnPreRender is called
            Page.PushCachingControl(this);
            _cachedCtrl.RenderControl(tmpHtmlWriter);
            Page.PopCachingControl();
        }
        finally {
            Context.Response.SwitchWriter(savedWriter);
        }

        _cacheEntry.OutputString = tmpWriter.ToString();

        // Send the output to the response
        output.Write(_cacheEntry.OutputString);

        // Cache the output

        cacheDep = _cacheDependency;

        if (sqlCacheDep != null) {
            if (cacheDep == null) {
                cacheDep = sqlCacheDep;
            }
            else {
                AggregateCacheDependency aggr = new AggregateCacheDependency();

                aggr.Add(cacheDep);
                aggr.Add(sqlCacheDep);
                cacheDep = aggr;
            }
        }

        ControlCachedVary cachedVary = null;
        string realItemCacheKey;
        // If there are no varies, use the non-varying key
        if (_varyByParamsCollection == null && _varyByControlsCollection == null && _varyByCustom == null) {
            realItemCacheKey = _cacheKey;
        }
        else {
            string[] varyByParams = null;
                if (_varyByParamsCollection != null)
                    varyByParams = _varyByParamsCollection.GetParams();

            cachedVary = new ControlCachedVary(varyByParams, _varyByControlsCollection, _varyByCustom);

            HashCodeCombiner combinedHashCode = new HashCodeCombiner(_nonVaryHashCode);
            realItemCacheKey = ComputeVaryCacheKey(combinedHashCode, cachedVary);
        }

        // Compute the correct expiration, sliding or absolute
        DateTime utcExpirationTime;
        TimeSpan slidingExpiration;
        if (_useSlidingExpiration) {
            utcExpirationTime = Cache.NoAbsoluteExpiration;
            slidingExpiration = _utcExpirationTime - DateTime.UtcNow;
        }
        else {
            utcExpirationTime = _utcExpirationTime;
            slidingExpiration = Cache.NoSlidingExpiration;
        }
        
        try {
            OutputCache.InsertFragment(_cacheKey, cachedVary,
                                       realItemCacheKey, _cacheEntry,
                                       cacheDep /*dependencies*/,
                                       utcExpirationTime, slidingExpiration,
                                       _provider);
        }
        catch {
            if (cacheDep != null) {
                cacheDep.Dispose();
            }
            throw;
        }
    }

    // Return the key used to cache the output
    private string ComputeNonVaryCacheKey(HashCodeCombiner combinedHashCode) {
        // Create a cache key by combining various elements

        // Start with the guid
        combinedHashCode.AddObject(_guid);

        // Make the key vary based on the type of the writer (ASURT 118922)
        HttpBrowserCapabilities browserCap = Context.Request.Browser;
        if (browserCap != null)
            combinedHashCode.AddObject(browserCap.TagWriter);

        return CacheInternal.PrefixPartialCachingControl + combinedHashCode.CombinedHashString;
    }

    private string ComputeVaryCacheKey(HashCodeCombiner combinedHashCode,
        ControlCachedVary cachedVary) {

        // Add something to the has to differentiate it from the non-vary hash.
        // This is needed in case this method doesn't add anything else to the hash (VSWhidbey 194199)
        combinedHashCode.AddInt(1);

        // Get the request value collection
        NameValueCollection reqValCollection;
        HttpRequest request = Page.Request;
        if (request != null && request.HttpVerb == HttpVerb.POST) {
            // Bug 6129: Partial cache key should include posted form values in postbacks.
            // Include both QueryString and Form values (but not Cookies or Server Variables like Request.Params does).
            // Per Request.Params behavior, add QueryString values before Form values
            reqValCollection = new NameValueCollection(request.QueryString);
            reqValCollection.Add(request.Form);
        }
        else {
            // Use the existing value if possible to avoid recreating a NameValueCollection
            reqValCollection = Page.RequestValueCollection;
            // If it's not set, get it based on the method
            if (reqValCollection == null) {
                reqValCollection = Page.GetCollectionBasedOnMethod(true /*dontReturnNull*/);
            }
        }

        if (cachedVary._varyByParams != null) {

            ICollection itemsToUseForHashCode;

            // If '*' was specified, use all the items in the request collection.
            // Otherwise, use only those specified.
            if (cachedVary._varyByParams.Length == 1 && cachedVary._varyByParams[0] == "*")
                itemsToUseForHashCode = reqValCollection;
            else
                itemsToUseForHashCode = cachedVary._varyByParams;

            // Add the items and their values to compute the hash code
            foreach (string varyByParam in itemsToUseForHashCode) {

                // Note: we use to ignore certain system fields here (like VIEWSTATE), but decided
                // not to for consistency with pahe output caching (VSWhidbey 196267, 479252)

                combinedHashCode.AddCaseInsensitiveString(varyByParam);
                string val = reqValCollection[varyByParam];
                if (val != null)
                    combinedHashCode.AddObject(val);
            }
        }

        if (cachedVary._varyByControls != null) {

            // Prepend them with a prefix to make them fully qualified
            string prefix;
            if (NamingContainer == Page) {
                // No prefix if it's the page
                prefix = String.Empty;
            }
            else {
                prefix = NamingContainer.UniqueID;
                Debug.Assert(!String.IsNullOrEmpty(prefix));
                prefix += IdSeparator;
            }

            prefix += _ctrlID + IdSeparator;

            // Add all the relative vary params and their values to the hash code
            foreach (string varyByParam in cachedVary._varyByControls) {

                string temp = prefix + varyByParam.Trim();
                combinedHashCode.AddCaseInsensitiveString(temp);
                string val = reqValCollection[temp];
                if (val != null)
                    combinedHashCode.AddObject(reqValCollection[temp]);
            }
        }

        if (cachedVary._varyByCustom != null) {
            string customString = Context.ApplicationInstance.GetVaryByCustomString(
                Context, cachedVary._varyByCustom);
            if (customString != null)
                combinedHashCode.AddObject(customString);
        }

        return CacheInternal.PrefixPartialCachingControl + combinedHashCode.CombinedHashString;
    }

    private string GetCssStyleRenderString(Type htmlTextWriterType) {
        // Nothing to do if no styles are registered.
        if (_registeredStyleInfo == null) {
            return null;
        }

        // Create an empty cssStringWriter
        StringWriter cssStringWriter = new StringWriter(CultureInfo.CurrentCulture);

        // Create a new HtmlTextWriter, with the same type as the current one
        HtmlTextWriter cssHtmlTextWriter = 
            Page.CreateHtmlTextWriterFromType(cssStringWriter, htmlTextWriterType);

        CssTextWriter cssWriter = new CssTextWriter(cssHtmlTextWriter);

        foreach (SelectorStyleInfo si in _registeredStyleInfo) {
            HtmlHead.RenderCssRule(cssWriter, si.selector, si.style, si.urlResolver);
        }

        // Return the css style rendered string
        return cssStringWriter.ToString();
    }

    internal void SetVaryByParamsCollectionFromString(string varyByParams) {

        Debug.Assert(_varyByParamsCollection == null);

        if (varyByParams == null)
            return;

        string[] varyByParamsStrings = varyByParams.Split(varySeparator);
        _varyByParamsCollection = new HttpCacheVaryByParams();
        _varyByParamsCollection.SetParams(varyByParamsStrings);
    }

    internal void RegisterPostBackScript() {
        RegisterClientCall(ClientAPIRegisterType.PostBackScript, String.Empty, null);
    }

    internal void RegisterFocusScript() {
        RegisterClientCall(ClientAPIRegisterType.FocusScript, String.Empty, null);
    }

    internal void RegisterWebFormsScript() {
        RegisterClientCall(ClientAPIRegisterType.WebFormsScript, String.Empty, null);
    }

    private void RegisterClientCall(ClientAPIRegisterType type,
        ScriptKey scriptKey, string stringParam2) {

        // Keep track of the call, in order to be able to call it again when there is a cache hit.

        RegisterCallData registerCallData = new RegisterCallData();
        registerCallData.Type = type;
        registerCallData.Key = scriptKey;
        registerCallData.StringParam2 = stringParam2;

        if (_cacheEntry.RegisteredClientCalls == null)
            _cacheEntry.RegisteredClientCalls = new ArrayList();

        _cacheEntry.RegisteredClientCalls.Add(registerCallData);
    }

    private void RegisterClientCall(ClientAPIRegisterType type,
        string stringParam1, string stringParam2) {
        RegisterClientCall(type, stringParam1, stringParam2, null);
    }

    private void RegisterClientCall(ClientAPIRegisterType type,
        string stringParam1, string stringParam2, string stringParam3) {

        // Keep track of the call, in order to be able to call it again when there is a cache hit.

        RegisterCallData registerCallData = new RegisterCallData();
        registerCallData.Type = type;
        registerCallData.StringParam1 = stringParam1;
        registerCallData.StringParam2 = stringParam2;
        registerCallData.StringParam3 = stringParam3;

        if (_cacheEntry.RegisteredClientCalls == null)
            _cacheEntry.RegisteredClientCalls = new ArrayList();

        _cacheEntry.RegisteredClientCalls.Add(registerCallData);
    }

    internal void RegisterScriptBlock(ClientAPIRegisterType type, ScriptKey key, string script) {
        RegisterClientCall(type, key, script);
    }

    internal void RegisterOnSubmitStatement(ScriptKey key, string script) {
        RegisterClientCall(ClientAPIRegisterType.OnSubmitStatement, key, script);
    }

    internal void RegisterArrayDeclaration(string arrayName, string arrayValue) {
        RegisterClientCall(ClientAPIRegisterType.ArrayDeclaration,
            arrayName, arrayValue);
    }

    internal void RegisterHiddenField(string hiddenFieldName, string hiddenFieldInitialValue) {
        RegisterClientCall(ClientAPIRegisterType.HiddenField,
            hiddenFieldName, hiddenFieldInitialValue);
    }

    internal void RegisterExpandoAttribute(string controlID, string attributeName, string attributeValue) {
        RegisterClientCall(ClientAPIRegisterType.ExpandoAttribute, controlID, attributeName, attributeValue);
    }

    internal void RegisterForEventValidation(string uniqueID, string argument) {
        RegisterClientCall(ClientAPIRegisterType.EventValidation, uniqueID, argument);
    }
}


/// <devdoc>
///    <para>[To be supplied.]</para>
/// </devdoc>
public class StaticPartialCachingControl : BasePartialCachingControl {

    private BuildMethod _buildMethod;


    /// <internalonly/>
    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    /// </devdoc>
    public StaticPartialCachingControl(string ctrlID, string guid, int duration,
        string varyByParams, string varyByControls, string varyByCustom,
        BuildMethod buildMethod)
        :this(ctrlID, guid, duration, varyByParams, varyByControls,
            varyByCustom, null, buildMethod, null)
    {
    }


    /// <internalonly/>
    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    /// </devdoc>
    public StaticPartialCachingControl(string ctrlID, string guid, int duration,
        string varyByParams, string varyByControls, string varyByCustom, string sqlDependency,
        BuildMethod buildMethod)
        :this(ctrlID, guid, duration, varyByParams, varyByControls,
            varyByCustom, sqlDependency, buildMethod, null)
    {
    }

    public StaticPartialCachingControl(string ctrlID, string guid, int duration,
        string varyByParams, string varyByControls, string varyByCustom, string sqlDependency, 
        BuildMethod buildMethod, string providerName) {
        _ctrlID = ctrlID;
        Duration = new TimeSpan(0 /*hours*/, 0 /*mins*/, duration /*seconds*/);

        SetVaryByParamsCollectionFromString(varyByParams);

        if (varyByControls != null)
            _varyByControlsCollection = varyByControls.Split(varySeparator);
        _varyByCustom = varyByCustom;
        _guid = guid;
        _buildMethod = buildMethod;
        _sqlDependency = sqlDependency;
        _provider = providerName;
    }

    internal override Control CreateCachedControl() {
        return _buildMethod();
    }

    /*
     * Called by generated code (hence must be public).
     * Create a StaticPartialCachingControl and add it as a child
     */

    /// <internalonly/>
    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    /// </devdoc>
    static public void BuildCachedControl(Control parent, string ctrlID, string guid,
        int duration, string varyByParams, string varyByControls, string varyByCustom,
        BuildMethod buildMethod) {
        BuildCachedControl(parent, ctrlID, guid, duration, varyByParams,
            varyByControls, varyByCustom, null, buildMethod, null);
    }


    /// <internalonly/>
    /// <devdoc>
    ///    <para>[To be supplied.]</para>
    /// </devdoc>
    static public void BuildCachedControl(Control parent, string ctrlID, string guid,
        int duration, string varyByParams, string varyByControls, string varyByCustom, string sqlDependency,
        BuildMethod buildMethod) {
        BuildCachedControl(parent, ctrlID, guid, duration, varyByParams,
            varyByControls, varyByCustom, sqlDependency, buildMethod, null);
    }

    static public void BuildCachedControl(Control parent, string ctrlID, string guid,
        int duration, string varyByParams, string varyByControls, string varyByCustom, string sqlDependency, 
        BuildMethod buildMethod, string providerName) {

        StaticPartialCachingControl pcc = new StaticPartialCachingControl(
            ctrlID, guid, duration, varyByParams, varyByControls, varyByCustom, sqlDependency,
            buildMethod, providerName);

        ((IParserAccessor)parent).AddParsedSubObject(pcc);
    }
}


/// <devdoc>
///    <para>[To be supplied.]</para>
/// </devdoc>
public class PartialCachingControl : BasePartialCachingControl {

    private IWebObjectFactory _objectFactory;
    private Type _createCachedControlType;
    private object[] _args;


    public Control CachedControl { get { return _cachedCtrl; } }

    internal PartialCachingControl(IWebObjectFactory objectFactory, Type createCachedControlType,
        PartialCachingAttribute cacheAttrib, string cacheKey, object[] args) {
        string providerName = cacheAttrib.ProviderName;
        _ctrlID = cacheKey;
        Duration = new TimeSpan(0 /*hours*/, 0 /*mins*/, cacheAttrib.Duration /*seconds*/);

        SetVaryByParamsCollectionFromString(cacheAttrib.VaryByParams);

        if (cacheAttrib.VaryByControls != null)
            _varyByControlsCollection = cacheAttrib.VaryByControls.Split(varySeparator);
        _varyByCustom = cacheAttrib.VaryByCustom;
        _sqlDependency = cacheAttrib.SqlDependency;
        if (providerName == OutputCache.ASPNET_INTERNAL_PROVIDER_NAME) {
            providerName = null;
        }
        _provider = providerName;
        _guid = cacheKey;
        _objectFactory = objectFactory;
        _createCachedControlType = createCachedControlType;
        _args = args;
    }

    internal override Control CreateCachedControl() {

        Control cachedControl;

        if (_objectFactory != null) {
            cachedControl = (Control) _objectFactory.CreateInstance();
        }
        else {
            // Instantiate the control
            cachedControl = (Control) HttpRuntime.CreatePublicInstance(_createCachedControlType, _args);
        }

        // If it's a user control, do some extra initialization
        UserControl uc = cachedControl as UserControl;
        if (uc != null)
            uc.InitializeAsUserControl(Page);

        cachedControl.ID = _ctrlID;

        return cachedControl;
    }
}

/*
 * Holds param names that this cached item varies by.
 */
[Serializable]
internal class ControlCachedVary {
    private           Guid      _cachedVaryId;
    internal readonly string[]  _varyByParams;
    internal readonly string    _varyByCustom;
    internal readonly string[]  _varyByControls;

    internal Guid CachedVaryId { get { return _cachedVaryId; } }

    internal ControlCachedVary(string[] varyByParams,
        string[] varyByControls, string varyByCustom) {
        _varyByParams = varyByParams;
        _varyByControls = varyByControls;
        _varyByCustom = varyByCustom;
        _cachedVaryId = Guid.NewGuid();
    }

    public override bool Equals (Object obj) {

        if (!(obj is ControlCachedVary))
            return false;

        ControlCachedVary cv = (ControlCachedVary) obj;

        return  _varyByCustom == cv._varyByCustom               &&
                StringUtil.StringArrayEquals(_varyByParams, cv._varyByParams) &&
                StringUtil.StringArrayEquals(_varyByControls, cv._varyByControls);
    }

    public override int GetHashCode () {
        HashCodeCombiner hashCodeCombiner = new HashCodeCombiner();
        
        // We need non-randomized hash code for _varyByCustom
        hashCodeCombiner.AddInt(StringUtil.GetNonRandomizedHashCode(_varyByCustom));
        
        hashCodeCombiner.AddArray(_varyByParams);
        hashCodeCombiner.AddArray(_varyByControls);
        return hashCodeCombiner.CombinedHash32;
    }
}

}