Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / whidbey / NetFXspW7 / ndp / fx / src / xsp / System / Web / UI / WebControls / PagedDataSource.cs / 1 / PagedDataSource.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Web.UI.WebControls {
using System;
using System.Collections;
using System.ComponentModel;
using System.Web.UI;
using System.Security.Permissions;
///
/// Provides a wrapper over an ICollection datasource to implement paging
/// semantics or 'paged views' on top of the underlying datasource.
///
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
public sealed class PagedDataSource : ICollection, ITypedList {
private IEnumerable dataSource;
private int currentPageIndex;
private int pageSize;
private bool allowPaging;
private bool allowCustomPaging;
private bool allowServerPaging;
private int virtualCount;
///
/// Initializes a new instance of the
///
public PagedDataSource() {
this.pageSize = 10;
this.allowPaging = false;
this.currentPageIndex = 0;
this.allowCustomPaging = false;
this.allowServerPaging = false;
this.virtualCount = 0;
}
///
/// Indicates whether to assume the underlying datasource
/// contains data for just the current page.
///
public bool AllowCustomPaging {
get {
return allowCustomPaging;
}
set {
allowCustomPaging = value;
}
}
///
/// Indicates whether to implement page semantics on top of the underlying datasource.
///
public bool AllowPaging {
get {
return allowPaging;
}
set {
allowPaging = value;
}
}
///
/// Indicates whether to implement page semantics on top of the underlying datasource.
///
public bool AllowServerPaging {
get {
return allowServerPaging;
}
set {
allowServerPaging = value;
}
}
///
///
/// Specifies the number of items
/// to be used from the datasource.
///
public int Count {
get {
if (dataSource == null)
return 0;
if (IsPagingEnabled) {
if (IsCustomPagingEnabled || (IsLastPage == false)) {
// In custom paging the datasource can contain at most
// a single page's worth of data.
// In non-custom paging, all pages except last one have
// a full page worth of data.
return pageSize;
}
else {
// last page might have fewer items in datasource
return DataSourceCount - FirstIndexInPage;
}
}
else {
return DataSourceCount;
}
}
}
///
/// Indicates the index of the current page.
///
public int CurrentPageIndex {
get {
return currentPageIndex;
}
set {
currentPageIndex = value;
}
}
///
/// Indicates the data source.
///
public IEnumerable DataSource {
get {
return dataSource;
}
set {
dataSource = value;
}
}
///
///
public int DataSourceCount {
get {
if (dataSource == null)
return 0;
if (IsCustomPagingEnabled || IsServerPagingEnabled) {
return virtualCount;
}
else {
if (dataSource is ICollection) {
return ((ICollection)dataSource).Count;
}
else {
// The caller should not call this in the case of an IEnumerator datasource
// This is required for paging, but the assumption is that the user will set
// up custom paging.
throw new HttpException(SR.GetString(SR.PagedDataSource_Cannot_Get_Count));
}
}
}
}
///
///
public int FirstIndexInPage {
get {
if ((dataSource == null) || (IsPagingEnabled == false)) {
return 0;
}
else {
if (IsCustomPagingEnabled || IsServerPagingEnabled) {
// In this mode, all the data belongs to the current page.
return 0;
}
else {
return currentPageIndex * pageSize;
}
}
}
}
///
///
public bool IsCustomPagingEnabled {
get {
return IsPagingEnabled && allowCustomPaging;
}
}
///
///
public bool IsFirstPage {
get {
if (IsPagingEnabled)
return(CurrentPageIndex == 0);
else
return true;
}
}
///
///
public bool IsLastPage {
get {
if (IsPagingEnabled)
return(CurrentPageIndex == (PageCount - 1));
else
return true;
}
}
///
///
public bool IsPagingEnabled {
get {
return allowPaging && (pageSize != 0);
}
}
///
///
public bool IsReadOnly {
get {
return false;
}
}
///
/// Indicates whether server-side paging is enabled
///
public bool IsServerPagingEnabled {
get {
return IsPagingEnabled && allowServerPaging;
}
}
///
///
public bool IsSynchronized {
get {
return false;
}
}
///
///
public int PageCount {
get {
if (dataSource == null)
return 0;
int dataSourceItemCount = DataSourceCount;
if (IsPagingEnabled && (dataSourceItemCount > 0)) {
int pageCountNum = dataSourceItemCount + pageSize - 1;
if (pageCountNum < 0) {
return 1; // integer overflow
}
return (int)(pageCountNum/pageSize);
}
else {
return 1;
}
}
}
///
///
public int PageSize {
get {
return pageSize;
}
set {
pageSize = value;
}
}
///
///
public object SyncRoot {
get {
return this;
}
}
///
///
public int VirtualCount {
get {
return virtualCount;
}
set {
virtualCount = value;
}
}
///
///
public void CopyTo(Array array, int index) {
for (IEnumerator e = this.GetEnumerator(); e.MoveNext();)
array.SetValue(e.Current, index++);
}
///
///
public IEnumerator GetEnumerator() {
int startIndex = FirstIndexInPage;
int count = -1;
if (dataSource is ICollection) {
count = Count;
}
if (dataSource is IList) {
return new EnumeratorOnIList((IList)dataSource, startIndex, count);
}
else if (dataSource is Array) {
return new EnumeratorOnArray((object[])dataSource, startIndex, count);
}
else if (dataSource is ICollection) {
return new EnumeratorOnICollection((ICollection)dataSource, startIndex, count);
}
else {
if (allowCustomPaging || allowServerPaging) {
// startIndex does not matter
// however count does... even if the data source contains more than 1 page of data in
// it, we only want to enumerate over a single page of data
// note: we can call Count here, even though we're dealing with an IEnumerator
// because by now we have ensured that we're in custom paging mode
return new EnumeratorOnIEnumerator(dataSource.GetEnumerator(), Count);
}
else {
// startIndex and count don't matter since we're going to enumerate over all the
// data (either non-paged or custom paging scenario)
return dataSource.GetEnumerator();
}
}
}
///
///
public PropertyDescriptorCollection GetItemProperties(PropertyDescriptor[] listAccessors) {
if (dataSource == null)
return null;
if (dataSource is ITypedList) {
return((ITypedList)dataSource).GetItemProperties(listAccessors);
}
return null;
}
///
///
public string GetListName(PropertyDescriptor[] listAccessors) {
return String.Empty;
}
///
///
private sealed class EnumeratorOnIEnumerator : IEnumerator {
private IEnumerator realEnum;
private int index;
private int indexBounds;
public EnumeratorOnIEnumerator(IEnumerator realEnum, int count) {
this.realEnum = realEnum;
this.index = -1;
this.indexBounds = count;
}
public object Current {
get {
return realEnum.Current;
}
}
public bool MoveNext() {
bool result = realEnum.MoveNext();
index++;
return result && (index < indexBounds);
}
public void Reset() {
realEnum.Reset();
index = -1;
}
}
///
///
private sealed class EnumeratorOnICollection : IEnumerator {
private ICollection collection;
private IEnumerator collectionEnum;
private int startIndex;
private int index;
private int indexBounds;
public EnumeratorOnICollection(ICollection collection, int startIndex, int count) {
this.collection = collection;
this.startIndex = startIndex;
this.index = -1;
this.indexBounds = startIndex + count;
if (indexBounds > collection.Count) {
indexBounds = collection.Count;
}
}
public object Current {
get {
return collectionEnum.Current;
}
}
public bool MoveNext() {
if (collectionEnum == null) {
collectionEnum = collection.GetEnumerator();
for (int i = 0; i < startIndex; i++)
collectionEnum.MoveNext();
}
collectionEnum.MoveNext();
index++;
return (startIndex + index) < indexBounds;
}
public void Reset() {
collectionEnum = null;
index = -1;
}
}
///
///
private sealed class EnumeratorOnIList : IEnumerator {
private IList collection;
private int startIndex;
private int index;
private int indexBounds;
public EnumeratorOnIList(IList collection, int startIndex, int count) {
this.collection = collection;
this.startIndex = startIndex;
this.index = -1;
this.indexBounds = startIndex + count;
if (indexBounds > collection.Count) {
indexBounds = collection.Count;
}
}
public object Current {
get {
if (index < 0) {
throw new InvalidOperationException(SR.GetString(SR.Enumerator_MoveNext_Not_Called));
}
return collection[startIndex + index];
}
}
public bool MoveNext() {
index++;
return (startIndex + index) < indexBounds;
}
public void Reset() {
index = -1;
}
}
///
///
private sealed class EnumeratorOnArray : IEnumerator {
private object[] array;
private int startIndex;
private int index;
private int indexBounds;
public EnumeratorOnArray(object[] array, int startIndex, int count) {
this.array = array;
this.startIndex = startIndex;
this.index = -1;
this.indexBounds = startIndex + count;
if (indexBounds > array.Length) {
indexBounds = array.Length;
}
}
public object Current {
get {
if (index < 0) {
throw new InvalidOperationException(SR.GetString(SR.Enumerator_MoveNext_Not_Called));
}
return array[startIndex + index];
}
}
public bool MoveNext() {
index++;
return (startIndex + index) < indexBounds;
}
public void Reset() {
index = -1;
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Web.UI.WebControls {
using System;
using System.Collections;
using System.ComponentModel;
using System.Web.UI;
using System.Security.Permissions;
///
/// Provides a wrapper over an ICollection datasource to implement paging
/// semantics or 'paged views' on top of the underlying datasource.
///
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
public sealed class PagedDataSource : ICollection, ITypedList {
private IEnumerable dataSource;
private int currentPageIndex;
private int pageSize;
private bool allowPaging;
private bool allowCustomPaging;
private bool allowServerPaging;
private int virtualCount;
///
/// Initializes a new instance of the
///
public PagedDataSource() {
this.pageSize = 10;
this.allowPaging = false;
this.currentPageIndex = 0;
this.allowCustomPaging = false;
this.allowServerPaging = false;
this.virtualCount = 0;
}
///
/// Indicates whether to assume the underlying datasource
/// contains data for just the current page.
///
public bool AllowCustomPaging {
get {
return allowCustomPaging;
}
set {
allowCustomPaging = value;
}
}
///
/// Indicates whether to implement page semantics on top of the underlying datasource.
///
public bool AllowPaging {
get {
return allowPaging;
}
set {
allowPaging = value;
}
}
///
/// Indicates whether to implement page semantics on top of the underlying datasource.
///
public bool AllowServerPaging {
get {
return allowServerPaging;
}
set {
allowServerPaging = value;
}
}
///
///
/// Specifies the number of items
/// to be used from the datasource.
///
public int Count {
get {
if (dataSource == null)
return 0;
if (IsPagingEnabled) {
if (IsCustomPagingEnabled || (IsLastPage == false)) {
// In custom paging the datasource can contain at most
// a single page's worth of data.
// In non-custom paging, all pages except last one have
// a full page worth of data.
return pageSize;
}
else {
// last page might have fewer items in datasource
return DataSourceCount - FirstIndexInPage;
}
}
else {
return DataSourceCount;
}
}
}
///
/// Indicates the index of the current page.
///
public int CurrentPageIndex {
get {
return currentPageIndex;
}
set {
currentPageIndex = value;
}
}
///
/// Indicates the data source.
///
public IEnumerable DataSource {
get {
return dataSource;
}
set {
dataSource = value;
}
}
///
///
public int DataSourceCount {
get {
if (dataSource == null)
return 0;
if (IsCustomPagingEnabled || IsServerPagingEnabled) {
return virtualCount;
}
else {
if (dataSource is ICollection) {
return ((ICollection)dataSource).Count;
}
else {
// The caller should not call this in the case of an IEnumerator datasource
// This is required for paging, but the assumption is that the user will set
// up custom paging.
throw new HttpException(SR.GetString(SR.PagedDataSource_Cannot_Get_Count));
}
}
}
}
///
///
public int FirstIndexInPage {
get {
if ((dataSource == null) || (IsPagingEnabled == false)) {
return 0;
}
else {
if (IsCustomPagingEnabled || IsServerPagingEnabled) {
// In this mode, all the data belongs to the current page.
return 0;
}
else {
return currentPageIndex * pageSize;
}
}
}
}
///
///
public bool IsCustomPagingEnabled {
get {
return IsPagingEnabled && allowCustomPaging;
}
}
///
///
public bool IsFirstPage {
get {
if (IsPagingEnabled)
return(CurrentPageIndex == 0);
else
return true;
}
}
///
///
public bool IsLastPage {
get {
if (IsPagingEnabled)
return(CurrentPageIndex == (PageCount - 1));
else
return true;
}
}
///
///
public bool IsPagingEnabled {
get {
return allowPaging && (pageSize != 0);
}
}
///
///
public bool IsReadOnly {
get {
return false;
}
}
///
/// Indicates whether server-side paging is enabled
///
public bool IsServerPagingEnabled {
get {
return IsPagingEnabled && allowServerPaging;
}
}
///
///
public bool IsSynchronized {
get {
return false;
}
}
///
///
public int PageCount {
get {
if (dataSource == null)
return 0;
int dataSourceItemCount = DataSourceCount;
if (IsPagingEnabled && (dataSourceItemCount > 0)) {
int pageCountNum = dataSourceItemCount + pageSize - 1;
if (pageCountNum < 0) {
return 1; // integer overflow
}
return (int)(pageCountNum/pageSize);
}
else {
return 1;
}
}
}
///
///
public int PageSize {
get {
return pageSize;
}
set {
pageSize = value;
}
}
///
///
public object SyncRoot {
get {
return this;
}
}
///
///
public int VirtualCount {
get {
return virtualCount;
}
set {
virtualCount = value;
}
}
///
///
public void CopyTo(Array array, int index) {
for (IEnumerator e = this.GetEnumerator(); e.MoveNext();)
array.SetValue(e.Current, index++);
}
///
///
public IEnumerator GetEnumerator() {
int startIndex = FirstIndexInPage;
int count = -1;
if (dataSource is ICollection) {
count = Count;
}
if (dataSource is IList) {
return new EnumeratorOnIList((IList)dataSource, startIndex, count);
}
else if (dataSource is Array) {
return new EnumeratorOnArray((object[])dataSource, startIndex, count);
}
else if (dataSource is ICollection) {
return new EnumeratorOnICollection((ICollection)dataSource, startIndex, count);
}
else {
if (allowCustomPaging || allowServerPaging) {
// startIndex does not matter
// however count does... even if the data source contains more than 1 page of data in
// it, we only want to enumerate over a single page of data
// note: we can call Count here, even though we're dealing with an IEnumerator
// because by now we have ensured that we're in custom paging mode
return new EnumeratorOnIEnumerator(dataSource.GetEnumerator(), Count);
}
else {
// startIndex and count don't matter since we're going to enumerate over all the
// data (either non-paged or custom paging scenario)
return dataSource.GetEnumerator();
}
}
}
///
///
public PropertyDescriptorCollection GetItemProperties(PropertyDescriptor[] listAccessors) {
if (dataSource == null)
return null;
if (dataSource is ITypedList) {
return((ITypedList)dataSource).GetItemProperties(listAccessors);
}
return null;
}
///
///
public string GetListName(PropertyDescriptor[] listAccessors) {
return String.Empty;
}
///
///
private sealed class EnumeratorOnIEnumerator : IEnumerator {
private IEnumerator realEnum;
private int index;
private int indexBounds;
public EnumeratorOnIEnumerator(IEnumerator realEnum, int count) {
this.realEnum = realEnum;
this.index = -1;
this.indexBounds = count;
}
public object Current {
get {
return realEnum.Current;
}
}
public bool MoveNext() {
bool result = realEnum.MoveNext();
index++;
return result && (index < indexBounds);
}
public void Reset() {
realEnum.Reset();
index = -1;
}
}
///
///
private sealed class EnumeratorOnICollection : IEnumerator {
private ICollection collection;
private IEnumerator collectionEnum;
private int startIndex;
private int index;
private int indexBounds;
public EnumeratorOnICollection(ICollection collection, int startIndex, int count) {
this.collection = collection;
this.startIndex = startIndex;
this.index = -1;
this.indexBounds = startIndex + count;
if (indexBounds > collection.Count) {
indexBounds = collection.Count;
}
}
public object Current {
get {
return collectionEnum.Current;
}
}
public bool MoveNext() {
if (collectionEnum == null) {
collectionEnum = collection.GetEnumerator();
for (int i = 0; i < startIndex; i++)
collectionEnum.MoveNext();
}
collectionEnum.MoveNext();
index++;
return (startIndex + index) < indexBounds;
}
public void Reset() {
collectionEnum = null;
index = -1;
}
}
///
///
private sealed class EnumeratorOnIList : IEnumerator {
private IList collection;
private int startIndex;
private int index;
private int indexBounds;
public EnumeratorOnIList(IList collection, int startIndex, int count) {
this.collection = collection;
this.startIndex = startIndex;
this.index = -1;
this.indexBounds = startIndex + count;
if (indexBounds > collection.Count) {
indexBounds = collection.Count;
}
}
public object Current {
get {
if (index < 0) {
throw new InvalidOperationException(SR.GetString(SR.Enumerator_MoveNext_Not_Called));
}
return collection[startIndex + index];
}
}
public bool MoveNext() {
index++;
return (startIndex + index) < indexBounds;
}
public void Reset() {
index = -1;
}
}
///
///
private sealed class EnumeratorOnArray : IEnumerator {
private object[] array;
private int startIndex;
private int index;
private int indexBounds;
public EnumeratorOnArray(object[] array, int startIndex, int count) {
this.array = array;
this.startIndex = startIndex;
this.index = -1;
this.indexBounds = startIndex + count;
if (indexBounds > array.Length) {
indexBounds = array.Length;
}
}
public object Current {
get {
if (index < 0) {
throw new InvalidOperationException(SR.GetString(SR.Enumerator_MoveNext_Not_Called));
}
return array[startIndex + index];
}
}
public bool MoveNext() {
index++;
return (startIndex + index) < indexBounds;
}
public void Reset() {
index = -1;
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- XmlAttributeOverrides.cs
- HtmlHistory.cs
- XLinq.cs
- NumberFormatInfo.cs
- GetIndexBinder.cs
- ConfigWriter.cs
- Run.cs
- SqlTransaction.cs
- ShaderRenderModeValidation.cs
- Automation.cs
- ToolStripSettings.cs
- KnownAssemblyEntry.cs
- TemplateManager.cs
- iisPickupDirectory.cs
- UnicastIPAddressInformationCollection.cs
- WindowsImpersonationContext.cs
- OdbcError.cs
- ClientBuildManager.cs
- NativeMethods.cs
- ProtocolsSection.cs
- CreateUserWizardDesigner.cs
- DetailsView.cs
- SystemEvents.cs
- CodeCatchClause.cs
- WebSysDisplayNameAttribute.cs
- HtmlTableCellCollection.cs
- FrameSecurityDescriptor.cs
- Exceptions.cs
- StackOverflowException.cs
- TransformValueSerializer.cs
- FileRecordSequenceHelper.cs
- PageAdapter.cs
- PrinterUnitConvert.cs
- ManipulationVelocities.cs
- SqlLiftIndependentRowExpressions.cs
- ProxyWebPartConnectionCollection.cs
- DbProviderFactoriesConfigurationHandler.cs
- MultiByteCodec.cs
- ServiceDescriptionSerializer.cs
- ListViewGroupConverter.cs
- UnsafePeerToPeerMethods.cs
- UnknownBitmapEncoder.cs
- EmptyReadOnlyDictionaryInternal.cs
- ScriptComponentDescriptor.cs
- ActivationArguments.cs
- Substitution.cs
- log.cs
- SelectingProviderEventArgs.cs
- LightweightCodeGenerator.cs
- RequestQueryParser.cs
- SymbolPair.cs
- ControlHelper.cs
- OdbcConnectionStringbuilder.cs
- GuidConverter.cs
- FileUtil.cs
- HttpCookie.cs
- MatrixTransform3D.cs
- SpecularMaterial.cs
- DateTimeConverter2.cs
- ChildrenQuery.cs
- MemoryMappedFile.cs
- CompatibleComparer.cs
- Expression.cs
- ColumnBinding.cs
- ColumnResizeUndoUnit.cs
- XmlAnyElementAttribute.cs
- ProfileProvider.cs
- UrlAuthorizationModule.cs
- ConversionValidationRule.cs
- WpfKnownMember.cs
- FontStyleConverter.cs
- ConversionValidationRule.cs
- NegotiationTokenAuthenticatorState.cs
- ModelPropertyCollectionImpl.cs
- Symbol.cs
- MessageSmuggler.cs
- UInt64.cs
- DataGridViewRow.cs
- DataGridItemCollection.cs
- MergeExecutor.cs
- Rfc2898DeriveBytes.cs
- KeysConverter.cs
- TypeElement.cs
- TCPClient.cs
- ReadWriteSpinLock.cs
- HostingMessageProperty.cs
- VersionedStream.cs
- CorePropertiesFilter.cs
- XmlSerializableWriter.cs
- SynchronizedDispatch.cs
- FixedSOMTable.cs
- ResourcePropertyMemberCodeDomSerializer.cs
- TraceUtility.cs
- OpacityConverter.cs
- RegisteredHiddenField.cs
- SpeakCompletedEventArgs.cs
- SchemaTableOptionalColumn.cs
- XmlArrayAttribute.cs
- DataGridViewCell.cs
- DefaultSection.cs