Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

435 lines
14 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="UserControl.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.ComponentModel;
using System.ComponentModel.Design;
using System.ComponentModel.Design.Serialization;
using System.Web.Caching;
using System.Web.ModelBinding;
using System.Web.SessionState;
using System.Web.Util;
/// <devdoc>
/// <para>The ControlBuilder associated with a UserControl. If you want a custom ControlBuilder for your
/// derived UserControl, you should derive it from UserControlControlBuilder.
/// </para>
/// </devdoc>
public class UserControlControlBuilder : ControlBuilder {
private string _innerText;
/// <internalonly/>
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;
}
/// <internalonly/>
public override bool NeedsTagInnerText() {
// in design-mode, we need to hang on to the inner text
return InDesigner;
}
/// <internalonly/>
public override void SetTagInnerText(string text) {
Debug.Assert(InDesigner == true, "Should only be called in design-mode!");
_innerText = text;
}
}
/// <devdoc>
/// Default ControlBuilder used to parse user controls files.
/// </devdoc>
public class FileLevelUserControlBuilder: RootBuilder {
}
/// <devdoc>
/// <para>This class is not marked as abstract, because the VS designer
/// needs to instantiate it when opening .ascx files</para>
/// </devdoc>
[
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;
/// <devdoc>
/// <para>Gets the collection of attribute name/value pairs expressed on a UserControl but
/// not supported by the control's strongly typed properties.</para>
/// </devdoc>
[
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
/// <devdoc>
/// <para>Gets the <see langword='Application'/> object provided by
/// the HTTP Runtime.</para>
/// </devdoc>
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public HttpApplicationState Application { get { return Page.Application;} }
/*
* Trace context for output of useful information to page during development
*/
/// <devdoc>
/// <para>Indicates the <see cref='System.Web.TraceContext'/> 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.</para>
/// </devdoc>
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public TraceContext Trace { get { return Page.Trace; } }
/// <devdoc>
/// <para>
/// Gets the <see langword='Request'/> object provided by the HTTP Runtime, which
/// allows developers to access data from incoming HTTP requests.
/// </para>
/// </devdoc>
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public HttpRequest Request { get { return Page.Request; } }
/// <devdoc>
/// <para>Gets the <see langword='Response '/>object provided by the HTTP Runtime, which
/// allows developers to send HTTP response data to a client browser.</para>
/// </devdoc>
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public HttpResponse Response { get { return Page.Response; } }
/// <devdoc>
/// <para>Gets the ASP-compatible <see langword='Server'/> object.</para>
/// </devdoc>
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public HttpServerUtility Server { get { return Page.Server; } }
/*
* Cache intrinsic
*/
/// <devdoc>
/// <para>Retrieves a <see langword='Cache'/>
/// object in which to store the user control's data for
/// subsequent requests. This property is read-only.</para>
/// </devdoc>
[
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();
}
}
/// <devdoc>
/// <para>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.</para>
/// </devdoc>
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public bool IsPostBack { get { return Page.IsPostBack; } }
/// <devdoc>
/// <para>Gets the <see langword='Session '/> object provided by the HTTP Runtime.</para>
/// </devdoc>
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
]
public HttpSessionState Session { get { return Page.Session; } }
/*
* Performs intialization of the control required by the designer.
*/
/// <devdoc>
/// <para>Performs any initialization of the control that is required by RAD designers.</para>
/// </devdoc>
[EditorBrowsable(EditorBrowsableState.Never)]
public void DesignerInitialize() {
InitRecursive(null);
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
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
*/
/// <devdoc>
/// <para>Initializes the <see langword='UserControl'/> object. Since there are some
/// differences between pages and user controls, this method makes sure that the
/// user control is initialized properly.</para>
/// </devdoc>
[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;
}
/// <internalonly/>
/// <devdoc>
/// Returns the attribute value of the UserControl having
/// the specified attribute name.
/// </devdoc>
string IAttributeAccessor.GetAttribute(string name) {
return ((attributeStorage != null) ? (string)attributeStorage[name] : null);
}
/// <internalonly/>
/// <devdoc>
/// <para>Sets an attribute of the UserControl with the specified
/// name and value.</para>
/// </devdoc>
void IAttributeAccessor.SetAttribute(string name, string value) {
Attributes[name] = value;
}
/*
* Map virtual path (absolute or relative) to physical path
*/
/// <devdoc>
/// <para>Assigns a virtual path, either absolute or relative, to a physical path.</para>
/// </devdoc>
public string MapPath(string virtualPath) {
return Request.MapPath(VirtualPath.CreateAllowNull(virtualPath), TemplateControlVirtualDirectory,
true/*allowCrossAppMapping*/);
}
/// <internalonly/>
string IUserControlDesignerAccessor.TagName {
get {
string text = (string)ViewState["!DesignTimeTagName"];
if (text == null) {
return String.Empty;
}
return text;
}
set {
ViewState["!DesignTimeTagName"] = value;
}
}
/// <internalonly/>
string IUserControlDesignerAccessor.InnerText {
get {
string text = (string)ViewState["!DesignTimeInnerText"];
if (text == null) {
return String.Empty;
}
return text;
}
set {
ViewState["!DesignTimeInnerText"] = value;
}
}
/// <summary>
/// Updates the model object from the values within a databound control. This must be invoked
/// within the Select/Update/Delete/InsertMethods used for data binding.
/// Throws an exception if the update fails.
/// </summary>
public virtual void UpdateModel<TModel>(TModel model) where TModel : class {
Page.UpdateModel<TModel>(model);
}
/// <summary>
/// Updates the model object from the values provided by given valueProvider.
/// Throws an exception if the update fails.
/// </summary>
public virtual void UpdateModel<TModel>(TModel model, IValueProvider valueProvider) where TModel : class {
Page.UpdateModel<TModel>(model, valueProvider);
}
/// <summary>
/// Attempts to update the model object from the values provided by given valueProvider.
/// </summary>
/// <returns>True if the model object is updated succesfully with valid values. False otherwise.</returns>
public virtual bool TryUpdateModel<TModel>(TModel model) where TModel : class {
return Page.TryUpdateModel<TModel>(model);
}
/// <summary>
/// Attempts to update the model object from the values within a databound control. This
/// must be invoked within the Select/Update/Delete/InsertMethods used for data binding.
/// </summary>
/// <returns>True if the model object is updated succesfully with valid values. False otherwise.</returns>
public virtual bool TryUpdateModel<TModel>(TModel model, IValueProvider valueProvider) where TModel : class {
return Page.TryUpdateModel<TModel>(model, valueProvider);
}
}
}