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

665 lines
22 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="BaseDataList.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.UI.WebControls {
using System;
using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Web;
using System.Web.UI;
using System.Web.Util;
/// <devdoc>
/// <para>Serves as the abstract base class for the <see cref='System.Web.UI.WebControls.DataList'/> and <see cref='System.Web.UI.WebControls.DataGrid'/>
/// controls and implements the selection semantics which are common to both
/// controls.</para>
/// </devdoc>
[
DefaultEvent("SelectedIndexChanged"),
DefaultProperty("DataSource"),
Designer("System.Web.UI.Design.WebControls.BaseDataListDesigner, " + AssemblyRef.SystemDesign)
]
public abstract class BaseDataList : WebControl {
private static readonly object EventSelectedIndexChanged = new object();
internal const string ItemCountViewStateKey = "_!ItemCount";
private object dataSource;
private DataKeyCollection dataKeysCollection;
private bool _requiresDataBinding;
private bool _inited;
private bool _throwOnDataPropertyChange;
private DataSourceView _currentView;
private bool _currentViewIsFromDataSourceID;
private bool _currentViewValid;
private DataSourceSelectArguments _arguments;
private bool _pagePreLoadFired;
[
DefaultValue(""),
Localizable(true),
WebCategory("Accessibility"),
WebSysDescription(SR.DataControls_Caption)
]
public virtual string Caption {
get {
string s = (string)ViewState["Caption"];
return (s != null) ? s : String.Empty;
}
set {
ViewState["Caption"] = value;
}
}
[
DefaultValue(TableCaptionAlign.NotSet),
WebCategory("Accessibility"),
WebSysDescription(SR.WebControl_CaptionAlign)
]
public virtual TableCaptionAlign CaptionAlign {
get {
object o = ViewState["CaptionAlign"];
return (o != null) ? (TableCaptionAlign)o : TableCaptionAlign.NotSet;
}
set {
if ((value < TableCaptionAlign.NotSet) ||
(value > TableCaptionAlign.Right)) {
throw new ArgumentOutOfRangeException("value");
}
ViewState["CaptionAlign"] = value;
}
}
/// <devdoc>
/// <para>Indicates the amount of space between cells.</para>
/// </devdoc>
[
WebCategory("Layout"),
DefaultValue(-1),
WebSysDescription(SR.BaseDataList_CellPadding)
]
public virtual int CellPadding {
get {
if (ControlStyleCreated == false) {
return -1;
}
return ((TableStyle)ControlStyle).CellPadding;
}
set {
((TableStyle)ControlStyle).CellPadding = value;
}
}
/// <devdoc>
/// <para>Gets or sets the amount of space between the contents of
/// a cell and the cell's border.</para>
/// </devdoc>
[
WebCategory("Layout"),
DefaultValue(0),
WebSysDescription(SR.BaseDataList_CellSpacing)
]
public virtual int CellSpacing {
get {
if (ControlStyleCreated == false) {
return 0;
}
return ((TableStyle)ControlStyle).CellSpacing;
}
set {
((TableStyle)ControlStyle).CellSpacing = value;
}
}
public override ControlCollection Controls {
get {
EnsureChildControls();
return base.Controls;
}
}
/// <devdoc>
/// </devdoc>
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
WebSysDescription(SR.BaseDataList_DataKeys)
]
public DataKeyCollection DataKeys {
get {
if (dataKeysCollection == null) {
dataKeysCollection = new DataKeyCollection(this.DataKeysArray);
}
return dataKeysCollection;
}
}
/// <devdoc>
/// </devdoc>
protected ArrayList DataKeysArray {
get {
object o = ViewState["DataKeys"];
if (o == null) {
o = new ArrayList();
ViewState["DataKeys"] = o;
}
return(ArrayList)o;
}
}
/// <devdoc>
/// <para>Indicatesthe primary key field in the data source referenced by <see cref='System.Web.UI.WebControls.BaseDataList.DataSource'/>.</para>
/// </devdoc>
[
DefaultValue(""),
Themeable(false),
WebCategory("Data"),
WebSysDescription(SR.BaseDataList_DataKeyField)
]
public virtual string DataKeyField {
get {
object o = ViewState["DataKeyField"];
if (o != null)
return(string)o;
return String.Empty;
}
set {
ViewState["DataKeyField"] = value;
}
}
/// <devdoc>
/// </devdoc>
[
DefaultValue(""),
Themeable(false),
WebCategory("Data"),
WebSysDescription(SR.BaseDataList_DataMember)
]
public string DataMember {
get {
object o = ViewState["DataMember"];
if (o != null)
return (string)o;
return String.Empty;
}
set {
ViewState["DataMember"] = value;
OnDataPropertyChanged();
}
}
/// <devdoc>
/// <para>Gets
/// or sets the source to a list of values used to populate
/// the items within the control.</para>
/// </devdoc>
[
Bindable(true),
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
Themeable(false),
WebCategory("Data"),
WebSysDescription(SR.BaseDataBoundControl_DataSource),
]
public virtual object DataSource {
get {
return dataSource;
}
set {
if ((value == null) || (value is IListSource) || (value is IEnumerable)) {
dataSource = value;
OnDataPropertyChanged();
}
else {
throw new ArgumentException(SR.GetString(SR.Invalid_DataSource_Type, ID));
}
}
}
/// <summary>
/// The ID of the DataControl that this control should use to retrieve
/// its data source. When the control is bound to a DataControl, it
/// can retrieve a data source instance on-demand, and thereby attempt
/// to work in auto-DataBind mode.
/// </summary>
[
DefaultValue(""),
IDReferenceProperty(typeof(DataSourceControl)),
Themeable(false),
WebCategory("Data"),
WebSysDescription(SR.BaseDataBoundControl_DataSourceID)
]
public virtual string DataSourceID {
get {
object o = ViewState["DataSourceID"];
if (o != null) {
return (string)o;
}
return String.Empty;
}
set {
ViewState["DataSourceID"] = value;
OnDataPropertyChanged();
}
}
/// <devdoc>
/// <para>Gets or sets a value that specifies the grid line style.</para>
/// </devdoc>
[
WebCategory("Appearance"),
DefaultValue(GridLines.Both),
WebSysDescription(SR.DataControls_GridLines)
]
public virtual GridLines GridLines {
get {
if (ControlStyleCreated == false) {
return GridLines.Both;
}
return ((TableStyle)ControlStyle).GridLines;
}
set {
((TableStyle)ControlStyle).GridLines = value;
}
}
/// <devdoc>
/// <para>Gets or sets a value that specifies the alignment of a rows with respect
/// surrounding text.</para>
/// </devdoc>
[
Category("Layout"),
DefaultValue(HorizontalAlign.NotSet),
WebSysDescription(SR.WebControl_HorizontalAlign)
]
public virtual HorizontalAlign HorizontalAlign {
get {
if (ControlStyleCreated == false) {
return HorizontalAlign.NotSet;
}
return ((TableStyle)ControlStyle).HorizontalAlign;
}
set {
((TableStyle)ControlStyle).HorizontalAlign = value;
}
}
protected bool Initialized {
get {
return _inited;
}
}
protected bool IsBoundUsingDataSourceID {
get {
return (DataSourceID.Length > 0);
}
}
public override bool SupportsDisabledAttribute {
get {
return RenderingCompatibility < VersionUtil.Framework40;
}
}
protected bool RequiresDataBinding {
get {
return _requiresDataBinding;
}
set {
_requiresDataBinding = value;
}
}
protected DataSourceSelectArguments SelectArguments {
get {
if (_arguments == null) {
_arguments = CreateDataSourceSelectArguments();
}
return _arguments;
}
}
[
DefaultValue(false),
WebCategory("Accessibility"),
WebSysDescription(SR.Table_UseAccessibleHeader)
]
public virtual bool UseAccessibleHeader {
get {
object b = ViewState["UseAccessibleHeader"];
return (b != null) ? (bool)b : false;
}
set {
ViewState["UseAccessibleHeader"] = value;
}
}
/// <devdoc>
/// <para>Occurs when an item on the list is selected.</para>
/// </devdoc>
[
WebCategory("Action"),
WebSysDescription(SR.BaseDataList_OnSelectedIndexChanged)
]
public event EventHandler SelectedIndexChanged {
add {
Events.AddHandler(EventSelectedIndexChanged, value);
}
remove {
Events.RemoveHandler(EventSelectedIndexChanged, value);
}
}
/// <devdoc>
/// <para> Not coded yet.</para>
/// </devdoc>
protected override void AddParsedSubObject(object obj) {
return;
}
/// <devdoc>
/// Connects this data bound control to the appropriate DataSourceView
/// and hooks up the appropriate event listener for the
/// DataSourceViewChanged event. The return value is the new view (if
/// any) that was connected to. An exception is thrown if there is
/// a problem finding the requested view or data source.
/// </devdoc>
private DataSourceView ConnectToDataSourceView() {
if (_currentViewValid && !DesignMode) {
// If the current view is correct, there is no need to reconnect
return _currentView;
}
// Disconnect from old view, if necessary
if ((_currentView != null) && (_currentViewIsFromDataSourceID)) {
// We only care about this event if we are bound through the DataSourceID property
_currentView.DataSourceViewChanged -= new EventHandler(OnDataSourceViewChanged);
}
// Connect to new view
IDataSource ds = null;
string dataSourceID = DataSourceID;
if (dataSourceID.Length != 0) {
// Try to find a DataSource control with the ID specified in DataSourceID
Control control = DataBoundControlHelper.FindControl(this, dataSourceID);
if (control == null) {
throw new HttpException(SR.GetString(SR.DataControl_DataSourceDoesntExist, ID, dataSourceID));
}
ds = control as IDataSource;
if (ds == null) {
throw new HttpException(SR.GetString(SR.DataControl_DataSourceIDMustBeDataControl, ID, dataSourceID));
}
}
if (ds == null) {
// DataSource control was not found, construct a temporary data source to wrap the data
ds = new ReadOnlyDataSource(DataSource, DataMember);
}
else {
// Ensure that both DataSourceID as well as DataSource are not set at the same time
if (DataSource != null) {
throw new InvalidOperationException(SR.GetString(SR.DataControl_MultipleDataSources, ID));
}
}
// IDataSource was found, extract the appropriate view and return it
DataSourceView newView = ds.GetView(DataMember);
if (newView == null) {
throw new InvalidOperationException(SR.GetString(SR.DataControl_ViewNotFound, ID));
}
_currentViewIsFromDataSourceID = IsBoundUsingDataSourceID;
_currentView = newView;
if ((_currentView != null) && (_currentViewIsFromDataSourceID)) {
// We only care about this event if we are bound through the DataSourceID property
_currentView.DataSourceViewChanged += new EventHandler(OnDataSourceViewChanged);
}
_currentViewValid = true;
return _currentView;
}
/// <internalonly/>
/// <devdoc>
/// <para>Creates a child control using the view state.</para>
/// </devdoc>
protected internal override void CreateChildControls() {
Controls.Clear();
if (ViewState[ItemCountViewStateKey] == null) {
if (RequiresDataBinding) {
EnsureDataBound();
}
}
else {
// create the control hierarchy using the view state (and
// not the datasource)
CreateControlHierarchy(false);
ClearChildViewState();
}
}
protected abstract void CreateControlHierarchy(bool useDataSource);
public override void DataBind() {
// Don't databind to a data source control when the control is in the designer but not top-level
if (IsBoundUsingDataSourceID && DesignMode && (Site == null)) {
return;
}
// do our own databinding
RequiresDataBinding = false;
OnDataBinding(EventArgs.Empty);
}
protected virtual DataSourceSelectArguments CreateDataSourceSelectArguments() {
return DataSourceSelectArguments.Empty;
}
protected void EnsureDataBound() {
try {
_throwOnDataPropertyChange = true;
if (RequiresDataBinding && DataSourceID.Length > 0) {
DataBind();
}
}
finally {
_throwOnDataPropertyChange = false;
}
}
/// <devdoc>
/// Returns an IEnumerable that is the DataSource, which either came
/// from the DataSource property or from the control bound via the
/// DataSourceID property.
/// </devdoc>
protected virtual IEnumerable GetData() {
ConnectToDataSourceView();
Debug.Assert(_currentViewValid);
if (_currentView != null) {
return _currentView.ExecuteSelect(SelectArguments);
}
return null;
}
/// <devdoc>
/// <para>Determines if the specified data type can be bound to.</para>
/// </devdoc>
public static bool IsBindableType(Type type) {
return(type.IsPrimitive ||
(type == typeof(string)) ||
(type == typeof(DateTime)) ||
(type == typeof(Decimal)));
}
/// <internalonly/>
/// <devdoc>
/// <para>Raises the <see langword='DataBinding '/>event of a <see cref='System.Web.UI.WebControls.BaseDataList'/>
/// .</para>
/// </devdoc>
protected override void OnDataBinding(EventArgs e) {
base.OnDataBinding(e);
// reset the control state
Controls.Clear();
ClearChildViewState();
// and create the control hierarchy using the datasource
dataKeysCollection = null;
CreateControlHierarchy(true);
ChildControlsCreated = true;
TrackViewState();
}
/// <devdoc>
/// This method is called when DataMember, DataSource, or DataSourceID is changed.
/// </devdoc>
protected virtual void OnDataPropertyChanged() {
if (_throwOnDataPropertyChange) {
throw new HttpException(SR.GetString(SR.DataBoundControl_InvalidDataPropertyChange, ID));
}
if (_inited) {
RequiresDataBinding = true;
}
_currentViewValid = false;
}
protected virtual void OnDataSourceViewChanged(object sender, EventArgs e) {
RequiresDataBinding = true;
}
protected internal override void OnInit(EventArgs e) {
base.OnInit(e);
if (Page != null) {
Page.PreLoad += new EventHandler(this.OnPagePreLoad);
if (!IsViewStateEnabled && Page.IsPostBack) {
RequiresDataBinding = true;
}
}
}
protected internal override void OnLoad(EventArgs e) {
_inited = true; // just in case we were added to the page after PreLoad
ConnectToDataSourceView();
if (Page != null && !_pagePreLoadFired && ViewState[ItemCountViewStateKey] == null) {
// If the control was added after PagePreLoad, we still need to databind it because it missed its
// first change in PagePreLoad. If this control was created by a call to a parent control's DataBind
// in Page_Load (with is relatively common), this control will already have been databound even
// though pagePreLoad never fired and the page isn't a postback.
if (!Page.IsPostBack) {
RequiresDataBinding = true;
}
// If the control was added to the page after page.PreLoad, we'll never get the event and we'll
// never databind the control. So if we're catching up and Load happens but PreLoad never happened,
// call DataBind. This may make the control get databound twice if the user called DataBind on the control
// directly in Page.OnLoad, but better to bind twice than never to bind at all.
else if (IsViewStateEnabled) {
RequiresDataBinding = true;
}
}
base.OnLoad(e);
}
private void OnPagePreLoad(object sender, EventArgs e) {
_inited = true;
if (Page != null) {
Page.PreLoad -= new EventHandler(this.OnPagePreLoad);
// Setting RequiresDataBinding to true in OnLoad is too late because the OnLoad page event
// happens before the control.OnLoad method gets called. So a page_load handler on the page
// that calls DataBind won't prevent DataBind from getting called again in PreRender.
if (!Page.IsPostBack) {
RequiresDataBinding = true;
}
// If this is a postback and viewstate is enabled, but we have never bound the control
// before, it is probably because its visibility was changed in the postback. In this
// case, we need to bind the control or it will never appear. This is a common scenario
// for Wizard and MultiView.
if (Page.IsPostBack && IsViewStateEnabled && ViewState[ItemCountViewStateKey] == null) {
RequiresDataBinding = true;
}
}
_pagePreLoadFired = true;
}
protected internal override void OnPreRender(EventArgs e) {
EnsureDataBound();
base.OnPreRender(e);
}
/// <devdoc>
/// <para>Raises the <see cref='System.Web.UI.WebControls.BaseDataList.SelectedIndexChanged'/>event of a <see cref='System.Web.UI.WebControls.BaseDataList'/>.</para>
/// </devdoc>
protected virtual void OnSelectedIndexChanged(EventArgs e) {
EventHandler handler = (EventHandler)Events[EventSelectedIndexChanged];
if (handler != null) handler(this, e);
}
protected internal abstract void PrepareControlHierarchy();
/// <internalonly/>
/// <devdoc>
/// <para>Displays the control on the client.</para>
/// </devdoc>
protected internal override void Render(HtmlTextWriter writer) {
PrepareControlHierarchy();
RenderContents(writer);
}
}
}