PagedDataSource.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / UI / WebControls / PagedDataSource.cs / 1305376 / 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;

    ///  
    ///    Provides a wrapper over an ICollection datasource to implement paging
    ///       semantics or 'paged views' on top of the underlying datasource. 
    ///  
    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  class.
        /// 
        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

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
PagedDataSource.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
