|
//------------------------------------------------------------------------------
// <copyright file="Repeater.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>Defines the properties, methods, and events of a <see cref='System.Web.UI.WebControls.Repeater'/> class.</para>
/// </devdoc>
[
DefaultEvent("ItemCommand"),
DefaultProperty("DataSource"),
Designer("System.Web.UI.Design.WebControls.RepeaterDesigner, " + AssemblyRef.SystemDesign),
ParseChildren(true),
PersistChildren(false)
]
public class Repeater : Control, INamingContainer {
private static readonly object EventItemCreated = new object();
private static readonly object EventItemDataBound = new object();
private static readonly object EventItemCommand = new object();
private static readonly object EventCreatingModelDataSource = new object();
private static readonly object EventCallingDataMethods = new object();
internal const string ItemCountViewStateKey = "_!ItemCount";
private object dataSource;
private ITemplate headerTemplate;
private ITemplate footerTemplate;
private ITemplate itemTemplate;
private ITemplate alternatingItemTemplate;
private ITemplate separatorTemplate;
private ArrayList itemsArray;
private RepeaterItemCollection itemsCollection;
private bool _requiresDataBinding;
private bool _inited;
private bool _throwOnDataPropertyChange;
private DataSourceView _currentView;
private bool _currentViewIsFromDataSourceID;
private bool _currentViewValid;
private DataSourceSelectArguments _arguments;
private bool _pagePreLoadFired;
private string _itemType;
private string _selectMethod;
private ModelDataSource _modelDataSource;
private bool _asyncSelectPending;
/// <devdoc>
/// <para>Initializes a new instance of the <see cref='System.Web.UI.WebControls.Repeater'/> class.</para>
/// </devdoc>
public Repeater() {
}
private bool IsUsingModelBinders {
get {
return !String.IsNullOrEmpty(SelectMethod);
}
}
private void UpdateModelDataSourceProperties(ModelDataSource modelDataSource) {
if (modelDataSource == null) {
throw new ArgumentNullException("modelDataSource");
}
modelDataSource.UpdateProperties(ItemType, SelectMethod);
}
private ModelDataSource ModelDataSource {
get {
if (_modelDataSource == null) {
_modelDataSource = new ModelDataSource(this);
}
return _modelDataSource;
}
set {
if (value == null) {
throw new ArgumentNullException("value");
}
_modelDataSource = value;
}
}
protected virtual void OnCreatingModelDataSource(CreatingModelDataSourceEventArgs e) {
CreatingModelDataSourceEventHandler handler = Events[EventCreatingModelDataSource] as CreatingModelDataSourceEventHandler;
if (handler != null) {
handler(this, e);
}
}
[
WebCategory("Data"),
WebSysDescription(SR.DataBoundControl_OnCreatingModelDataSource)
]
public event CreatingModelDataSourceEventHandler CreatingModelDataSource {
add {
Events.AddHandler(EventCreatingModelDataSource, value);
}
remove {
Events.RemoveHandler(EventCreatingModelDataSource, value);
}
}
/// <summary>
/// The name of the model type used in the SelectMethod, InsertMethod, UpdateMethod, and DeleteMethod.
/// </summary>
[
DefaultValue(""),
Themeable(false),
WebCategory("Data"),
WebSysDescription(SR.DataBoundControl_ItemType)
]
public virtual string ItemType {
get {
return _itemType ?? String.Empty;
}
set {
if (!String.Equals(_itemType, value, StringComparison.OrdinalIgnoreCase)) {
_itemType = value;
OnDataPropertyChanged();
}
}
}
/// <summary>
/// The name of the method on the page which is called when this Control does a select operation.
/// </summary>
[
DefaultValue(""),
Themeable(false),
WebCategory("Data"),
WebSysDescription(SR.DataBoundControl_SelectMethod)
]
public virtual string SelectMethod {
get {
return _selectMethod ?? String.Empty;
}
set {
if (!String.Equals(_selectMethod, value, StringComparison.OrdinalIgnoreCase)) {
_selectMethod = value;
OnDataPropertyChanged();
}
}
}
/// <summary>
/// Occurs before model methods are invoked for data operations.
/// Handle this event if the model methods are defined on a custom type other than the code behind file.
/// </summary>
[
WebCategory("Data"),
WebSysDescription(SR.DataBoundControl_CallingDataMethods)
]
public event CallingDataMethodsEventHandler CallingDataMethods {
add {
Events.AddHandler(EventCallingDataMethods, value);
}
remove {
Events.RemoveHandler(EventCallingDataMethods, value);
if (_modelDataSource != null) {
_modelDataSource.CallingDataMethods -= value;
}
}
}
/// <devdoc>
/// <para>Gets or sets the <see cref='System.Web.UI.ITemplate' qualify='true'/> that defines how alternating (even-indexed) items
/// are rendered. </para>
/// </devdoc>
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(RepeaterItem)),
WebSysDescription(SR.Repeater_AlternatingItemTemplate)
]
public virtual ITemplate AlternatingItemTemplate {
get {
return alternatingItemTemplate;
}
set {
alternatingItemTemplate = value;
}
}
public override ControlCollection Controls {
get {
EnsureChildControls();
return base.Controls;
}
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
[
DefaultValue(""),
WebCategory("Data"),
WebSysDescription(SR.Repeater_DataMember)
]
public virtual 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 data source that provides data for
/// populating the list.</para>
/// </devdoc>
[
Bindable(true),
WebCategory("Data"),
DefaultValue(null),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
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)),
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 and sets a value indicating whether theme is enabled.</para>
/// </devdoc>
[
Browsable(true)
]
public override bool EnableTheming {
get {
return base.EnableTheming;
}
set {
base.EnableTheming = value;
}
}
/// <devdoc>
/// <para>Gets or sets the <see cref='System.Web.UI.ITemplate' qualify='true'/> that defines how the control footer is
/// rendered. </para>
/// </devdoc>
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(RepeaterItem)),
WebSysDescription(SR.Repeater_FooterTemplate)
]
public virtual ITemplate FooterTemplate {
get {
return footerTemplate;
}
set {
footerTemplate = value;
}
}
/// <devdoc>
/// <para>Gets or sets the <see cref='System.Web.UI.ITemplate' qualify='true'/> that defines how the control header is rendered. </para>
/// </devdoc>
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(RepeaterItem)),
WebSysDescription(SR.WebControl_HeaderTemplate)
]
public virtual ITemplate HeaderTemplate {
get {
return headerTemplate;
}
set {
headerTemplate = value;
}
}
protected bool Initialized {
get {
return _inited;
}
}
protected bool IsBoundUsingDataSourceID {
get {
return (DataSourceID.Length > 0);
}
}
protected bool IsDataBindingAutomatic {
get {
return IsBoundUsingDataSourceID || IsUsingModelBinders;
}
}
/// <devdoc>
/// Gets the <see cref='System.Web.UI.WebControls.RepeaterItem'/> collection.
/// </devdoc>
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
WebSysDescription(SR.Repeater_Items)
]
public virtual RepeaterItemCollection Items {
get {
if (itemsCollection == null) {
if (itemsArray == null) {
EnsureChildControls();
}
itemsCollection = new RepeaterItemCollection(itemsArray);
}
return itemsCollection;
}
}
/// <devdoc>
/// <para>Gets or sets the <see cref='System.Web.UI.ITemplate' qualify='true'/> that defines how items are rendered. </para>
/// </devdoc>
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(RepeaterItem)),
WebSysDescription(SR.Repeater_ItemTemplate)
]
public virtual ITemplate ItemTemplate {
get {
return itemTemplate;
}
set {
itemTemplate = value;
}
}
protected bool RequiresDataBinding {
get {
return _requiresDataBinding;
}
set {
_requiresDataBinding = value;
}
}
protected DataSourceSelectArguments SelectArguments {
get {
if (_arguments == null) {
_arguments = CreateDataSourceSelectArguments();
}
return _arguments;
}
}
/// <devdoc>
/// <para>Gets or sets the <see cref='System.Web.UI.ITemplate' qualify='true'/> that defines how separators
/// in between items are rendered.</para>
/// </devdoc>
[
Browsable(false),
DefaultValue(null),
PersistenceMode(PersistenceMode.InnerProperty),
TemplateContainer(typeof(RepeaterItem)),
WebSysDescription(SR.Repeater_SeparatorTemplate)
]
public virtual ITemplate SeparatorTemplate {
get {
return separatorTemplate;
}
set {
separatorTemplate = value;
}
}
/// <devdoc>
/// <para>Occurs when a button is clicked within the <see cref='System.Web.UI.WebControls.Repeater'/> control tree.</para>
/// </devdoc>
[
WebCategory("Action"),
WebSysDescription(SR.Repeater_OnItemCommand)
]
public event RepeaterCommandEventHandler ItemCommand {
add {
Events.AddHandler(EventItemCommand, value);
}
remove {
Events.RemoveHandler(EventItemCommand, value);
}
}
/// <devdoc>
/// <para> Occurs when an item is created within the <see cref='System.Web.UI.WebControls.Repeater'/> control tree.</para>
/// </devdoc>
[
WebCategory("Behavior"),
WebSysDescription(SR.DataControls_OnItemCreated)
]
public event RepeaterItemEventHandler ItemCreated {
add {
Events.AddHandler(EventItemCreated, value);
}
remove {
Events.RemoveHandler(EventItemCreated, value);
}
}
/// <devdoc>
/// <para>Occurs when an item is databound within a <see cref='System.Web.UI.WebControls.Repeater'/> control tree.</para>
/// </devdoc>
[
WebCategory("Behavior"),
WebSysDescription(SR.DataControls_OnItemDataBound)
]
public event RepeaterItemEventHandler ItemDataBound {
add {
Events.AddHandler(EventItemDataBound, value);
}
remove {
Events.RemoveHandler(EventItemDataBound, value);
}
}
/// <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;
if (!DesignMode && IsUsingModelBinders) {
if (DataSourceID.Length != 0 || DataSource != null) {
throw new InvalidOperationException(SR.GetString(SR.DataControl_ItemType_MultipleDataSources, ID));
}
//Let the developer choose a custom ModelDataSource.
CreatingModelDataSourceEventArgs e = new CreatingModelDataSourceEventArgs();
OnCreatingModelDataSource(e);
if (e.ModelDataSource != null) {
ModelDataSource = e.ModelDataSource;
}
//Update the properties of ModelDataSource so that it's ready for data-binding.
UpdateModelDataSourceProperties(ModelDataSource);
//Add the CallingDataMethodsEvent
CallingDataMethodsEventHandler handler = Events[EventCallingDataMethods] as CallingDataMethodsEventHandler;
if (handler != null) {
ModelDataSource.CallingDataMethods += handler;
}
ds = ModelDataSource;
}
else {
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 = IsDataBindingAutomatic;
_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;
}
/// <devdoc>
/// </devdoc>
protected internal override void CreateChildControls() {
Controls.Clear();
if (ViewState[ItemCountViewStateKey] != null) {
// create the control hierarchy using the view state (and
// not the datasource)
CreateControlHierarchy(false);
}
else {
itemsArray = new ArrayList();
}
ClearChildViewState();
}
/// <devdoc>
/// A protected method. Creates a control
/// hierarchy, with or without the data source as specified.
/// </devdoc>
protected virtual void CreateControlHierarchy(bool useDataSource) {
IEnumerable dataSource = null;
if (itemsArray != null) {
itemsArray.Clear();
}
else {
itemsArray = new ArrayList();
}
if (!useDataSource) {
// ViewState must have a non-null value for ItemCount because we check for
// this in CreateChildControls
int count = (int)ViewState[ItemCountViewStateKey];
if (count != -1) {
dataSource = new DummyDataSource(count);
itemsArray.Capacity = count;
}
AddDataItemsIntoItemsArray(dataSource, useDataSource);
}
else {
dataSource = GetData();
PostGetDataAction(dataSource);
}
}
private void OnDataSourceViewSelectCallback(IEnumerable data) {
_asyncSelectPending = false;
PostGetDataAction(data);
}
private void PostGetDataAction(IEnumerable dataSource) {
if (_asyncSelectPending)
return;
ICollection collection = dataSource as ICollection;
if (collection != null) {
itemsArray.Capacity = collection.Count;
}
int addedItemCount = AddDataItemsIntoItemsArray(dataSource, true/*useDataSource*/);
ViewState[ItemCountViewStateKey] = addedItemCount;
}
private int AddDataItemsIntoItemsArray(IEnumerable dataSource, bool useDataSource) {
int dataItemCount = -1;
if (dataSource != null) {
RepeaterItem item;
ListItemType itemType;
int index = 0;
bool hasSeparators = (separatorTemplate != null);
dataItemCount = 0;
if (headerTemplate != null) {
CreateItem(-1, ListItemType.Header, useDataSource, null);
}
foreach (object dataItem in dataSource) {
// rather than creating separators after the item, we create the separator
// for the previous item in all iterations of this loop.
// this is so that we don't create a separator for the last item
if (hasSeparators && (dataItemCount > 0)) {
CreateItem(index - 1, ListItemType.Separator, useDataSource, null);
}
itemType = (index % 2 == 0) ? ListItemType.Item : ListItemType.AlternatingItem;
item = CreateItem(index, itemType, useDataSource, dataItem);
itemsArray.Add(item);
dataItemCount++;
index++;
}
if (footerTemplate != null) {
CreateItem(-1, ListItemType.Footer, useDataSource, null);
}
}
return dataItemCount;
}
protected virtual DataSourceSelectArguments CreateDataSourceSelectArguments() {
return DataSourceSelectArguments.Empty;
}
/// <devdoc>
/// </devdoc>
private RepeaterItem CreateItem(int itemIndex, ListItemType itemType, bool dataBind, object dataItem) {
RepeaterItem item = CreateItem(itemIndex, itemType);
RepeaterItemEventArgs e = new RepeaterItemEventArgs(item);
InitializeItem(item);
if (dataBind) {
item.DataItem = dataItem;
}
OnItemCreated(e);
Controls.Add(item);
if (dataBind) {
item.DataBind();
OnItemDataBound(e);
item.DataItem = null;
}
return item;
}
/// <devdoc>
/// <para>A protected method. Creates a <see cref='System.Web.UI.WebControls.RepeaterItem'/> with the specified item type and
/// location within the <see cref='System.Web.UI.WebControls.Repeater'/>.</para>
/// </devdoc>
protected virtual RepeaterItem CreateItem(int itemIndex, ListItemType itemType) {
return new RepeaterItem(itemIndex, itemType);
}
/// <internalonly/>
/// <devdoc>
/// </devdoc>
public override void DataBind() {
// Don't databind to a data source control when the control is in the designer but not top-level
if (IsDataBindingAutomatic && DesignMode && (Site == null)) {
return;
}
// do our own databinding
RequiresDataBinding = false;
OnDataBinding(EventArgs.Empty);
// contained items will be databound after they have been created,
// so we don't want to walk the hierarchy here.
}
protected void EnsureDataBound() {
try {
_throwOnDataPropertyChange = true;
if (RequiresDataBinding && IsDataBindingAutomatic) {
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() {
DataSourceView view = ConnectToDataSourceView();
Debug.Assert(_currentViewValid);
if (view != null) {
// DevDiv 1070535: enable async model binding for Repeater
bool useAsyncSelect = false;
if (AppSettings.EnableAsyncModelBinding) {
var modelDataView = view as ModelDataSourceView;
useAsyncSelect = modelDataView != null && modelDataView.IsSelectMethodAsync;
}
if (useAsyncSelect) {
_asyncSelectPending = true; // disable post data binding action until the callback is invoked
view.Select(SelectArguments, OnDataSourceViewSelectCallback);
}
else {
return view.ExecuteSelect(SelectArguments);
}
}
return null;
}
/// <devdoc>
/// <para>A protected method. Populates iteratively the specified <see cref='System.Web.UI.WebControls.RepeaterItem'/> with a
/// sub-hierarchy of child controls.</para>
/// </devdoc>
protected virtual void InitializeItem(RepeaterItem item) {
ITemplate contentTemplate = null;
switch (item.ItemType) {
case ListItemType.Header:
contentTemplate = headerTemplate;
break;
case ListItemType.Footer:
contentTemplate = footerTemplate;
break;
case ListItemType.Item:
contentTemplate = itemTemplate;
break;
case ListItemType.AlternatingItem:
contentTemplate = alternatingItemTemplate;
if (contentTemplate == null)
goto case ListItemType.Item;
break;
case ListItemType.Separator:
contentTemplate = separatorTemplate;
break;
}
if (contentTemplate != null) {
contentTemplate.InstantiateIn(item);
}
}
/// <internalonly/>
/// <devdoc>
/// </devdoc>
protected override bool OnBubbleEvent(object sender, EventArgs e) {
bool handled = false;
if (e is RepeaterCommandEventArgs) {
OnItemCommand((RepeaterCommandEventArgs)e);
handled = true;
}
return handled;
}
/// <internalonly/>
/// <devdoc>
/// <para>A protected method. Raises the <see langword='DataBinding'/> event.</para>
/// </devdoc>
protected override void OnDataBinding(EventArgs e) {
base.OnDataBinding(e);
// reset the control state
Controls.Clear();
ClearChildViewState();
// and then create the control hierarchy using the datasource
CreateControlHierarchy(true);
ChildControlsCreated = true;
}
/// <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;
}
}
if (!DesignMode && !String.IsNullOrEmpty(ItemType)) {
DataBoundControlHelper.EnableDynamicData(this, ItemType);
}
}
/// <devdoc>
/// <para>A protected method. Raises the <see langword='ItemCommand'/> event.</para>
/// </devdoc>
protected virtual void OnItemCommand(RepeaterCommandEventArgs e) {
RepeaterCommandEventHandler onItemCommandHandler = (RepeaterCommandEventHandler)Events[EventItemCommand];
if (onItemCommandHandler != null) onItemCommandHandler(this, e);
}
/// <devdoc>
/// <para>A protected method. Raises the <see langword='ItemCreated'/> event.</para>
/// </devdoc>
protected virtual void OnItemCreated(RepeaterItemEventArgs e) {
RepeaterItemEventHandler onItemCreatedHandler = (RepeaterItemEventHandler)Events[EventItemCreated];
if (onItemCreatedHandler != null) onItemCreatedHandler(this, e);
}
/// <devdoc>
/// <para>A protected method. Raises the <see langword='ItemDataBound'/>
/// event.</para>
/// </devdoc>
protected virtual void OnItemDataBound(RepeaterItemEventArgs e) {
RepeaterItemEventHandler onItemDataBoundHandler = (RepeaterItemEventHandler)Events[EventItemDataBound];
if (onItemDataBoundHandler != null) onItemDataBoundHandler(this, e);
}
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>
/// Loads view state.
/// </devdoc>
protected override void LoadViewState(object savedState) {
if (IsUsingModelBinders) {
Pair myState = (Pair)savedState;
if (savedState == null) {
base.LoadViewState(null);
}
else {
base.LoadViewState(myState.First);
if (myState.Second != null) {
((IStateManager)ModelDataSource).LoadViewState(myState.Second);
}
}
}
else {
base.LoadViewState(savedState);
}
}
/// <devdoc>
/// Saves view state.
/// </devdoc>
protected override object SaveViewState() {
// Bug 322689: In the web farms scenario, if a web site is hosted in 4.0 and 4.5 servers
// (though this is not a really supported scenario, we are fixing this instance),
// the View state created by 4.0 should be able to be understood by 4.5 controls.
// So, we create a Pair only if we are using model binding and otherwise fallback to 4.0 behavior.
object baseViewState = base.SaveViewState();
if (IsUsingModelBinders) {
Pair myState = new Pair();
myState.First = baseViewState;
myState.Second = ((IStateManager)ModelDataSource).SaveViewState();
if ((myState.First == null) &&
(myState.Second == null)) {
return null;
}
return myState;
}
else {
return baseViewState;
}
}
/// <devdoc>
/// Starts tracking view state.
/// </devdoc>
protected override void TrackViewState() {
base.TrackViewState();
if (IsUsingModelBinders) {
((IStateManager)ModelDataSource).TrackViewState();
}
}
}
}
|