UserControl.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / UI / UserControl.cs / 1305376 / UserControl.cs
                        
                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

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

namespace System.Web.UI {
 
using System;
using System.ComponentModel; 
using System.ComponentModel.Design; 
using System.ComponentModel.Design.Serialization;
using System.Web.SessionState; 
using System.Web.Caching;
using System.Web.Util;

 
/// 
///   The ControlBuilder associated with a UserControl. If you want a custom ControlBuilder for your 
///     derived UserControl, you should derive it from UserControlControlBuilder. 
///   
///  
public class UserControlControlBuilder : ControlBuilder {

    private string _innerText;
 

    ///  
    public override object BuildObject() { 
        object o = base.BuildObject();
 
        if (InDesigner) {
            IUserControlDesignerAccessor designerAccessor = (IUserControlDesignerAccessor)o;

            designerAccessor.TagName = TagName; 
            if (_innerText != null) {
                designerAccessor.InnerText = _innerText; 
            } 
        }
        return o; 
    }


    ///  
    public override bool NeedsTagInnerText() {
        // in design-mode, we need to hang on to the inner text 
        return InDesigner; 
    }
 

    /// 
    public override void SetTagInnerText(string text) {
        Debug.Assert(InDesigner == true, "Should only be called in design-mode!"); 
        _innerText = text;
    } 
} 

 
/// 
///    Default ControlBuilder used to parse user controls files.
/// 
public class FileLevelUserControlBuilder: RootBuilder { 
}
 
 
/// 
///    This class is not marked as abstract, because the VS designer 
///          needs to instantiate it when opening .ascx files
/// 
[
ControlBuilder(typeof(UserControlControlBuilder)), 
DefaultEvent("Load"),
Designer("System.Web.UI.Design.UserControlDesigner, " + AssemblyRef.SystemDesign, typeof(IDesigner)), 
Designer("Microsoft.VisualStudio.Web.WebForms.WebFormDesigner, " + AssemblyRef.MicrosoftVisualStudioWeb, typeof(IRootDesigner)), 
DesignerCategory("ASPXCodeBehind"),
DesignerSerializer("Microsoft.VisualStudio.Web.WebForms.WebFormCodeDomSerializer, " + AssemblyRef.MicrosoftVisualStudioWeb, "System.ComponentModel.Design.Serialization.TypeCodeDomSerializer, " + AssemblyRef.SystemDesign), 
ParseChildren(true),
ToolboxItem(false)
]
public class UserControl : TemplateControl, IAttributeAccessor, INonBindingContainer, IUserControlDesignerAccessor { 

    private StateBag attributeStorage; 
    private AttributeCollection attributes; 

    private bool _fUserControlInitialized; 


    /// 
    ///    Gets the collection of attribute name/value pairs expressed on a UserControl but 
    ///       not supported by the control's strongly typed properties.
    ///  
    [ 
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) 
    ]
    public AttributeCollection Attributes {
        get {
            if (attributes == null) { 
                if (attributeStorage == null) {
                    attributeStorage = new StateBag(true); 
                    if (IsTrackingViewState) { 
                        attributeStorage.TrackViewState();
                    } 
                }
                attributes = new AttributeCollection(attributeStorage);
            }
            return attributes; 
        }
    } 
 
    // Delegate most things to the Page
 

    /// 
    /// Gets the  object provided by
    ///    the HTTP Runtime. 
    /// 
    [ 
    Browsable(false), 
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ] 
    public HttpApplicationState Application { get { return Page.Application;} }

    /*
     * Trace context for output of useful information to page during development 
     */
 
    ///  
    /// Indicates the  object for the current Web
    ///    request. Tracing tracks and presents the execution details about a Web request. 
    ///    For trace data to be visible in a rendered page, you must turn tracing on for
    ///    that page. This property is read-only.
    /// 
    [ 
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) 
    ] 
    public TraceContext Trace { get { return Page.Trace; } }
 

    /// 
    ///    
    ///       Gets the  object provided by the HTTP Runtime, which 
    ///       allows developers to access data from incoming HTTP requests.
    ///     
    ///  
    [
    Browsable(false), 
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public HttpRequest Request { get { return Page.Request; } }
 

    ///  
    /// Gets the object provided by the HTTP Runtime, which 
    ///    allows developers to send HTTP response data to a client browser.
    ///  
    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ] 
    public HttpResponse Response { get { return Page.Response; } }
 
 
    /// 
    /// Gets the ASP-compatible  object. 
    /// 
    [
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) 
    ]
    public HttpServerUtility Server { get { return Page.Server; } } 
 
    /*
     * Cache intrinsic 
     */

    /// 
    /// Retrieves a  
    /// object in which to store the user control's data for
    /// subsequent requests. This property is read-only. 
    ///  
    [
    Browsable(false), 
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ]
    public Cache Cache { get { return Page.Cache; } }
 

    [ 
    Browsable(false), 
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ] 
    public ControlCachePolicy CachePolicy {
        get {
            // Check if we're inside a PartialCachingControl
            BasePartialCachingControl pcc = Parent as BasePartialCachingControl; 

            // If so, return its CachePolicy 
            if (pcc != null) 
                return pcc.CachePolicy;
 
            // Otherwise, return a stub, which returns SupportsCaching==false and throws
            // on everything else.
            return ControlCachePolicy.GetCachePolicyStub();
        } 
    }
 
 
    /// 
    ///    Gets a value indicating whether the user control is being loaded in response to a 
    ///       client postback, or if it is being loaded and accessed for the first time.
    /// 
    [
    Browsable(false), 
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
    ] 
    public bool IsPostBack { get { return Page.IsPostBack; } } 

 
    /// 
    /// Gets the  object provided by the HTTP Runtime.
    /// 
    [ 
    Browsable(false),
    DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden) 
    ] 
    public HttpSessionState Session { get { return Page.Session; } }
 
    /*
     * Performs intialization of the control required by the designer.
     */
 
    /// 
    ///    Performs any initialization of the control that is required by RAD designers. 
    ///  
    [EditorBrowsable(EditorBrowsableState.Never)]
    public void DesignerInitialize() { 
        InitRecursive(null);
    }

 
    /// 
    ///    [To be supplied.] 
    ///  
    protected internal override void OnInit(EventArgs e) {
 
        // We want to avoid calling this when the user control is being used in the designer,
        // regardless of whether it is a top-level control (DesignMode == true),
        // or if its inside another control in design-mode (Page.Site.DesignMode == true)
 
        bool designTime = DesignMode;
        if (designTime == false) { 
            if ((Page != null) && (Page.Site != null)) { 
                designTime = Page.Site.DesignMode;
            } 
        }

        if (designTime == false) {
            InitializeAsUserControlInternal(); 
        }
 
        base.OnInit(e); 
    }
 
    /*
     * Called on declarative controls to initialize them correctly
     */
 
    /// 
    /// Initializes the  object. Since there are some 
    ///    differences between pages and user controls, this method makes sure that the 
    ///    user control is initialized properly.
    ///  
    [EditorBrowsable(EditorBrowsableState.Never)]
    public void InitializeAsUserControl(Page page) {

        _page = page; 

        InitializeAsUserControlInternal(); 
    } 

    internal void InitializeAsUserControlInternal() { 

        // Make sure we only do this once
        if (_fUserControlInitialized)
            return; 
        _fUserControlInitialized = true;
 
        // Hook up any automatic handler we may find (e.g. Page_Load) 
        HookUpAutomaticHandlers();
 
        // Initialize the object and instantiate all the controls defined in the ascx file
        FrameworkInitialize();
    }
 

    protected override void LoadViewState(object savedState) { 
        if (savedState != null) { 
            Pair myState = (Pair)savedState;
            base.LoadViewState(myState.First); 

            if (myState.Second != null) {
                if (attributeStorage == null) {
                    attributeStorage = new StateBag(true); 
                    attributeStorage.TrackViewState();
                } 
                attributeStorage.LoadViewState(myState.Second); 
            }
        } 
    }


    protected override object SaveViewState() { 
        Pair myState = null;
 
        object baseState = base.SaveViewState(); 
        object attrState = null;
        if (attributeStorage != null) { 
            attrState = attributeStorage.SaveViewState();
        }

        if (baseState != null || attrState != null) { 
            myState = new Pair(baseState, attrState);
        } 
        return myState; 
    }
 


    /// 
    ///  
    /// Returns the attribute value of the UserControl having
    /// the specified attribute name. 
    ///  
    string IAttributeAccessor.GetAttribute(string name) {
        return ((attributeStorage != null) ? (string)attributeStorage[name] : null); 
    }


    ///  
    /// 
    /// Sets an attribute of the UserControl with the specified 
    /// name and value. 
    /// 
    void IAttributeAccessor.SetAttribute(string name, string value) { 
        Attributes[name] = value;
    }

    /* 
     * Map virtual path (absolute or relative) to physical path
     */ 
 
    /// 
    ///    Assigns a virtual path, either absolute or relative, to a physical path. 
    /// 
    public string MapPath(string virtualPath) {
        return Request.MapPath(VirtualPath.CreateAllowNull(virtualPath), TemplateControlVirtualDirectory,
            true/*allowCrossAppMapping*/); 
    }
 
 
    /// 
    string IUserControlDesignerAccessor.TagName { 
        get {
            string text = (string)ViewState["!DesignTimeTagName"];
            if (text == null) {
                return String.Empty; 
            }
            return text; 
        } 
        set {
            ViewState["!DesignTimeTagName"] = value; 
        }
    }

 
    /// 
    string IUserControlDesignerAccessor.InnerText { 
        get { 
            string text = (string)ViewState["!DesignTimeInnerText"];
            if (text == null) { 
                return String.Empty;
            }
            return text;
        } 
        set {
            ViewState["!DesignTimeInnerText"] = value; 
        } 
    }
} 

}

// 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
UserControl.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
