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

238 lines
10 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="HierarchicalDataBoundControl.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.UI.WebControls {
using System.Collections;
using System.ComponentModel;
using System.Web.Util;
using System.Web.UI.WebControls.Adapters;
[
Designer("System.Web.UI.Design.WebControls.HierarchicalDataBoundControlDesigner, " + AssemblyRef.SystemDesign)
]
public abstract class HierarchicalDataBoundControl : BaseDataBoundControl {
private IHierarchicalDataSource _currentHierarchicalDataSource;
private bool _currentDataSourceIsFromControl;
private bool _currentDataSourceValid;
private bool _pagePreLoadFired;
private const string DataBoundViewStateKey = "_!DataBound";
/// <internalonly />
[IDReferenceProperty(typeof(HierarchicalDataSourceControl))]
public override string DataSourceID {
get {
return base.DataSourceID;
}
set {
base.DataSourceID = value;
}
}
/// <devdoc>
/// Connects this hierarchical data bound control to the appropriate
/// HierarchicalDataSource and hooks up the appropriate event listener
/// for the DataSourceChanged event. The return value is the new data source
/// (if any) that was connected to. An exception is thrown if there is
/// a problem finding the requested data source.
/// </devdoc>
private IHierarchicalDataSource ConnectToHierarchicalDataSource() {
if (_currentDataSourceValid && !DesignMode) {
// Ensure that both DataSourceID as well as DataSource are not set at the same time
if (!_currentDataSourceIsFromControl && DataSourceID != null && DataSourceID.Length != 0) {
throw new InvalidOperationException(SR.GetString(SR.DataControl_MultipleDataSources, ID));
}
// If the current view is correct, there is no need to reconnect
return _currentHierarchicalDataSource;
}
// Disconnect from old view, if necessary
if ((_currentHierarchicalDataSource != null) && (_currentDataSourceIsFromControl)) {
// We only care about this event if we are bound through the DataSourceID property
_currentHierarchicalDataSource.DataSourceChanged -= new EventHandler(OnDataSourceChanged);
}
// Connect to new view
_currentHierarchicalDataSource = GetDataSource();
_currentDataSourceIsFromControl = IsBoundUsingDataSourceID;
if (_currentHierarchicalDataSource == null) {
// HierarchicalDataSource control was not found, construct a temporary data source to wrap the data
_currentHierarchicalDataSource = new ReadOnlyHierarchicalDataSource(DataSource);
}
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));
}
}
_currentDataSourceValid = true;
if ((_currentHierarchicalDataSource != null) && (_currentDataSourceIsFromControl)) {
// We only care about this event if we are bound through the DataSourceID property
_currentHierarchicalDataSource.DataSourceChanged += new EventHandler(OnDataSourceChanged);
}
return _currentHierarchicalDataSource;
}
/// <devdoc>
/// Gets the HierarchicalDataSourceView of the IHierarchicalDataSource
/// that this control is bound to, if any.
/// </devdoc>
protected virtual HierarchicalDataSourceView GetData(string viewPath) {
string currentViewPath = viewPath;
IHierarchicalDataSource ds = ConnectToHierarchicalDataSource();
Debug.Assert(_currentDataSourceValid);
Debug.Assert(ds != null);
// IHierarchicalDataSource was found, extract the appropriate view and return it
HierarchicalDataSourceView view = ds.GetHierarchicalView(currentViewPath);
if (view == null) {
throw new InvalidOperationException(SR.GetString(SR.HierarchicalDataControl_ViewNotFound, ID));
}
return view;
}
/// <devdoc>
/// Gets the IHierarchicalDataSource that this control is bound to, if any.
/// </devdoc>
protected virtual IHierarchicalDataSource GetDataSource() {
if (!DesignMode && _currentDataSourceValid && (_currentHierarchicalDataSource != null)) {
return _currentHierarchicalDataSource;
}
IHierarchicalDataSource 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.HierarchicalDataControl_DataSourceDoesntExist, ID, dataSourceID));
}
ds = control as IHierarchicalDataSource;
if (ds == null) {
throw new HttpException(SR.GetString(SR.HierarchicalDataControl_DataSourceIDMustBeHierarchicalDataControl, ID, dataSourceID));
}
}
return ds;
}
protected void MarkAsDataBound() {
ViewState[DataBoundViewStateKey] = true;
}
protected override void OnDataPropertyChanged() {
_currentDataSourceValid = false;
base.OnDataPropertyChanged();
}
/// <devdoc>
/// This method is called when the IHierarchicalDataSource raises a DataSourceChanged event.
/// </devdoc>
protected virtual void OnDataSourceChanged(object sender, EventArgs e) {
RequiresDataBinding = true;
}
protected internal override void OnLoad(EventArgs e) {
ConfirmInitState();
ConnectToHierarchicalDataSource();
if (Page != null && !_pagePreLoadFired && ViewState[DataBoundViewStateKey] == 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);
}
protected override void OnPagePreLoad(object sender, EventArgs e) {
base.OnPagePreLoad(sender, e);
if (Page != null) {
// 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.
else if (IsViewStateEnabled && ViewState[DataBoundViewStateKey] == null) {
RequiresDataBinding = true;
}
}
_pagePreLoadFired = true;
}
/// <devdoc>
/// This method should be overridden by databound controls to perform their databinding.
/// Overriding this method instead of DataBind() will allow the DataBound control developer
/// to not worry about DataBinding events to be called in the right order.
/// </devdoc>
protected internal virtual void PerformDataBinding() {
}
/// <summary>
/// Issues an asynchronous request for data to the data source using the arguments from CreateDataSourceSelectArguments.
/// </summary>
protected override void PerformSelect() {
OnDataBinding(EventArgs.Empty);
if (AdapterInternal != null) {
HierarchicalDataBoundControlAdapter hierarchicalAdapter = AdapterInternal as HierarchicalDataBoundControlAdapter;
if(hierarchicalAdapter != null) {
hierarchicalAdapter.PerformDataBinding();
}
else {
PerformDataBinding();
}
}
else {
PerformDataBinding();
}
RequiresDataBinding = false;
MarkAsDataBound();
OnDataBound(EventArgs.Empty);
}
protected override void ValidateDataSource(object dataSource) {
if ((dataSource == null) ||
(dataSource is IHierarchicalEnumerable) ||
(dataSource is IHierarchicalDataSource)) {
return;
}
throw new InvalidOperationException(SR.GetString(SR.HierarchicalDataBoundControl_InvalidDataSource));
}
}
}