DataSourceSelectArguments.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ FX-1434 / FX-1434 / 1.0 / untmp / whidbey / REDBITS / ndp / fx / src / xsp / System / Web / UI / DataSourceSelectArguments.cs / 1 / DataSourceSelectArguments.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 
namespace System.Web.UI {
 
    using System.Diagnostics; 
    using System.Security.Permissions;
 
    [AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    public sealed class DataSourceSelectArguments {
        private DataSourceCapabilities _requestedCapabilities;
        private DataSourceCapabilities _supportedCapabilities; 

        private int _maximumRows; 
        private bool _retrieveTotalRowCount; 
        private string _sortExpression;
        private int _startRowIndex; 
        private int _totalRowCount = -1;


        public DataSourceSelectArguments() : this(String.Empty, 0, 0) { 
        }
 
        public DataSourceSelectArguments(string sortExpression) : this(sortExpression, 0, 0) { 
        }
 

        public DataSourceSelectArguments(int startRowIndex, int maximumRows) : this(String.Empty, startRowIndex, maximumRows) {
        }
 

        public DataSourceSelectArguments(string sortExpression, int startRowIndex, int maximumRows) { 
            SortExpression = sortExpression; 
            StartRowIndex = startRowIndex;
            MaximumRows = maximumRows; 
        }

        // Empty cannot be a static readonly field because we want each requester to get their own copy.
        // This is because DataSourceViews need to call AddSupportedCapabilities on the DataSourceSelectArguments, 
        // changing it to be suited to the DataSourceView's needs.  If another DataSourceView used the same instance,
        // the supported capabilities would be wrong.  This member stays as a property for programming ease and 
        // returns a new instance each time.  If the user wants to change this instance, they're free to. 
        public static DataSourceSelectArguments Empty {
            get { 
                return new DataSourceSelectArguments();
            }
        }
 
        /// 
        /// The maximum number of rows requested for a paged data request. 
        /// Use 0 to indicate all rows. 
        /// 
        public int MaximumRows { 
            get {
                return _maximumRows;
            }
            set { 
                if (value == 0) {
                    if (_startRowIndex == 0) { 
                        _requestedCapabilities &= ~DataSourceCapabilities.Page; 
                    }
                } 
                else {
                    _requestedCapabilities |= DataSourceCapabilities.Page;
                }
                _maximumRows = value; 
            }
        } 
 

        ///  
        /// Indicates whether the total row count is requested
        /// 
        public bool RetrieveTotalRowCount {
            get { 
                return _retrieveTotalRowCount;
            } 
            set { 
                if (value) {
                    _requestedCapabilities |= DataSourceCapabilities.RetrieveTotalRowCount; 
                }
                else {
                    _requestedCapabilities &= ~DataSourceCapabilities.RetrieveTotalRowCount;
                } 
                _retrieveTotalRowCount = value;
            } 
        } 

 
        /// 
        /// The expression used to sort the data.
        /// 
        public string SortExpression { 
            get {
                if (_sortExpression == null) 
                    _sortExpression = String.Empty; 
                return _sortExpression;
            } 
            set {
                if (String.IsNullOrEmpty(value)) {
                    _requestedCapabilities &= ~DataSourceCapabilities.Sort;
                } 
                else {
                    _requestedCapabilities |= DataSourceCapabilities.Sort; 
                } 
                _sortExpression = value;
            } 
        }


        ///  
        /// The index of the first row requested for a paged data request
        ///  
        public int StartRowIndex { 
            get {
                return _startRowIndex; 
            }
            set {
                if (value == 0) {
                    if (_maximumRows == 0) { 
                        _requestedCapabilities &= ~DataSourceCapabilities.Page;
                    } 
                } 
                else {
                    _requestedCapabilities |= DataSourceCapabilities.Page; 
                }
                _startRowIndex = value;
            }
        } 

 
        ///  
        /// The number of rows returned by the query that counts the number of rows.  Typically
        /// set by the DataSource. 
        /// 
        public int TotalRowCount {
            get {
                return _totalRowCount; 
            }
            set { 
                _totalRowCount = value; 
            }
        } 


        /// 
        /// DataSource controls would call this for each capability that it handled. 
        /// It would do the bitwise operations to handle determining what capabilities were left
        /// over at the end for RaiseUnsupportedCapabilitiesError to handle. 
        ///  
        public void AddSupportedCapabilities(DataSourceCapabilities capabilities) {
            _supportedCapabilities |= capabilities; 
        }


        ///  
        /// Prevents a compiler error because Equals was overridden
        ///  
        public override int GetHashCode() { 
            return System.Web.Util.HashCodeCombiner.CombineHashCodes(_maximumRows.GetHashCode(),
                                                                     _retrieveTotalRowCount.GetHashCode(), 
                                                                     _sortExpression.GetHashCode(),
                                                                     _startRowIndex.GetHashCode(),
                                                                     _totalRowCount.GetHashCode());
        } 

 
        public override bool Equals(object obj) { 
            DataSourceSelectArguments arguments = obj as DataSourceSelectArguments;
            if (arguments != null) { 
                return ((arguments.MaximumRows == _maximumRows) &&
                        (arguments.RetrieveTotalRowCount == _retrieveTotalRowCount) &&
                        (arguments.SortExpression == _sortExpression) &&
                        (arguments.StartRowIndex == _startRowIndex) && 
                        (arguments.TotalRowCount == _totalRowCount));
            } 
 
            return false;
        } 


        /// 
        /// Select implementations would call this method to raise errors on unsupported capabilities. 
        /// 
        public void RaiseUnsupportedCapabilitiesError(DataSourceView view) { 
            DataSourceCapabilities unsupportedCapabilities; 
            unsupportedCapabilities = _requestedCapabilities & ~_supportedCapabilities;
 
            if ((unsupportedCapabilities & DataSourceCapabilities.Sort) != 0) {
                view.RaiseUnsupportedCapabilityError(DataSourceCapabilities.Sort);
            }
 
            if ((unsupportedCapabilities & DataSourceCapabilities.Page) != 0) {
                view.RaiseUnsupportedCapabilityError(DataSourceCapabilities.Page); 
            } 

            if ((unsupportedCapabilities & DataSourceCapabilities.RetrieveTotalRowCount) != 0) { 
                view.RaiseUnsupportedCapabilityError(DataSourceCapabilities.RetrieveTotalRowCount);
            }

            Debug.Assert(unsupportedCapabilities == 0, "unknown capability not supported"); 
        }
    } 
}
                        

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