DataSourceSelectArguments.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / UI / DataSourceSelectArguments.cs / 1305376 / DataSourceSelectArguments.cs
                        
                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 
namespace System.Web.UI {
 
    using System.Diagnostics; 
    using System.Security.Permissions;
 
    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");
        } 
    }
} 

// 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
DataSourceSelectArguments.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
