DataSourceView.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / UI / DataSourceView.cs / 1305376 / DataSourceView.cs
                        
                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Web.UI { 
 
    using System.Collections;
    using System.ComponentModel; 
    using System.Security.Permissions;

    public abstract class DataSourceView {
 
        private static readonly object EventDataSourceViewChanged = new object();
 
        private EventHandlerList _events; 
        private string _name;
 

        protected DataSourceView(IDataSource owner, string viewName) {
            if (owner == null) {
                throw new ArgumentNullException("owner"); 
            }
            if (viewName == null) { 
                throw new ArgumentNullException("viewName"); 
            }
 
            _name = viewName;

            DataSourceControl dataSourceControl = owner as DataSourceControl;
            if (dataSourceControl != null) { 
                dataSourceControl.DataSourceChangedInternal += new EventHandler(OnDataSourceChangedInternal);
            } 
            else { 
                owner.DataSourceChanged += new EventHandler(OnDataSourceChangedInternal);
            } 
        }

        // CanX properties indicate whether the data source allows each
        // operation, and if so, whether it's appropriate to do so. 
        // For instance, a control may allow Deletion, but if a required Delete
        // command isn't set, CanDelete should be false, because a Delete 
        // operation would fail. 

        public virtual bool CanDelete { 
            get {
                return false;
            }
        } 

 
        public virtual bool CanInsert { 
            get {
                return false; 
            }
        }

 
        public virtual bool CanPage {
            get { 
                return false; 
            }
        } 


        public virtual bool CanRetrieveTotalRowCount {
            get { 
                return false;
            } 
        } 

 
        public virtual bool CanSort {
            get {
                return false;
            } 
        }
 
 
        public virtual bool CanUpdate {
            get { 
                return false;
            }
        }
 

        ///  
        /// Indicates the list of event handler delegates for the view. This property is read-only. 
        /// 
        protected EventHandlerList Events { 
            get {
                if (_events == null) {
                    _events = new EventHandlerList();
                } 
                return _events;
            } 
        } 

 
        public string Name {
            get {
                return _name;
            } 
        }
 
 
        public event EventHandler DataSourceViewChanged {
            add { 
                Events.AddHandler(EventDataSourceViewChanged, value);
            }
            remove {
                Events.RemoveHandler(EventDataSourceViewChanged, value); 
            }
        } 
 
        public virtual bool CanExecute(string commandName) {
            return false; 
        }

        public virtual void Delete(IDictionary keys, IDictionary oldValues, DataSourceViewOperationCallback callback) {
            if (callback == null) { 
                throw new ArgumentNullException("callback");
            } 
 
            int affectedRecords = 0;
            bool performedCallback = false; 

            try {
                affectedRecords = ExecuteDelete(keys, oldValues);
            } 
            catch (Exception ex) {
                performedCallback = true; 
                if (!callback(affectedRecords, ex)) { 
                    throw;
                } 
            }
            finally {
                if (!performedCallback) {
                    callback(affectedRecords, null); 
                }
            } 
        } 

        public virtual void ExecuteCommand(string commandName, IDictionary keys, IDictionary values, DataSourceViewOperationCallback callback) { 
            if (callback == null) {
                throw new ArgumentNullException("callback");
            }
 
            int affectedRecords = 0;
            bool performedCallback = false; 
 
            try {
                affectedRecords = ExecuteCommand(commandName, keys, values); 
            }
            catch (Exception ex) {
                performedCallback = true;
                if (!callback(affectedRecords, ex)) { 
                    throw;
                } 
            } 
            finally {
                if (!performedCallback) { 
                    callback(affectedRecords, null);
                }
            }
        } 

        protected virtual int ExecuteCommand(string commandName, IDictionary keys, IDictionary values) { 
            throw new NotSupportedException(); 
        }
 
        /// 
        /// Performs a delete operation on the specified list. This is only
        /// supported by a DataSourceControl when CanDelete returns true.
        ///  
        /// 
        /// The set of name/value pairs used to filter 
        /// the items in the list that should be deleted. 
        /// 
        ///  
        /// The complete set of name/value pairs used to filter
        /// the items in the list that should be deleted.
        /// 
        ///  
        /// The number of items that were affected by the operation.
        ///  
        protected virtual int ExecuteDelete(IDictionary keys, IDictionary oldValues) { 
            throw new NotSupportedException();
        } 


        /// 
        /// Performs an insert operation on the specified list. This is only 
        /// supported by a DataControl when CanInsert is true.
        ///  
        ///  
        /// The set of name/value pairs to be used to initialize
        /// a new item in the list. 
        /// 
        /// 
        /// The number of items that were affected by the operation.
        ///  
        protected virtual int ExecuteInsert(IDictionary values) {
            throw new NotSupportedException(); 
        } 

 
        /// 
        /// 
        protected internal abstract IEnumerable ExecuteSelect(DataSourceSelectArguments arguments);
 

        ///  
        /// Performs an update operation on the specified list. This is only 
        /// supported by a DataControl when CanUpdate is true.
        ///  
        /// 
        /// The set of name/value pairs used to filter
        /// the items in the list that should be updated.
        ///  
        /// 
        /// The set of name/value pairs to be used to update the 
        /// items in the list. 
        /// 
        ///  
        /// The set of name/value pairs to be used to identify the
        /// item to be updated.
        /// 
        ///  
        /// The number of items that were affected by the operation.
        ///  
        protected virtual int ExecuteUpdate(IDictionary keys, IDictionary values, IDictionary oldValues) { 
            throw new NotSupportedException();
        } 

        private void OnDataSourceChangedInternal(object sender, EventArgs e) {
            OnDataSourceViewChanged(e);
        } 

 
        protected virtual void OnDataSourceViewChanged(EventArgs e) { 
            EventHandler handler = Events[EventDataSourceViewChanged] as EventHandler;
            if (handler != null) { 
                handler(this, e);
            }
        }
 
        public virtual void Insert(IDictionary values, DataSourceViewOperationCallback callback) {
            if (callback == null) { 
                throw new ArgumentNullException("callback"); 
            }
 
            int affectedRecords = 0;
            bool performedCallback = false;

            try { 
                affectedRecords = ExecuteInsert(values);
            } 
            catch (Exception ex) { 
                performedCallback = true;
                if (!callback(affectedRecords, ex)) { 
                    throw;
                }
            }
            finally { 
                if (!performedCallback) {
                    callback(affectedRecords, null); 
                } 
            }
        } 



        protected internal virtual void RaiseUnsupportedCapabilityError(DataSourceCapabilities capability) { 
            if (!CanPage && ((capability & DataSourceCapabilities.Page) != 0)) {
                throw new NotSupportedException(SR.GetString(SR.DataSourceView_NoPaging)); 
            } 

            if (!CanSort && ((capability & DataSourceCapabilities.Sort) != 0)) { 
                throw new NotSupportedException(SR.GetString(SR.DataSourceView_NoSorting));
            }

            if (!CanRetrieveTotalRowCount && ((capability & DataSourceCapabilities.RetrieveTotalRowCount) != 0)) { 
                throw new NotSupportedException(SR.GetString(SR.DataSourceView_NoRowCount));
            } 
        } 

        public virtual void Select(DataSourceSelectArguments arguments, DataSourceViewSelectCallback callback) { 
            if (callback == null) {
                throw new ArgumentNullException("callback");
            }
            callback(ExecuteSelect(arguments)); 
        }
 
        public virtual void Update(IDictionary keys, IDictionary values, IDictionary oldValues, DataSourceViewOperationCallback callback) { 
            if (callback == null) {
                throw new ArgumentNullException("callback"); 
            }

            int affectedRecords = 0;
            bool performedCallback = false; 

            try { 
                affectedRecords = ExecuteUpdate(keys, values, oldValues); 
            }
            catch (Exception ex) { 
                performedCallback = true;
                if (!callback(affectedRecords, ex)) {
                    throw;
                } 
            }
            finally { 
                if (!performedCallback) { 
                    callback(affectedRecords, null);
                } 
            }
        }
    }
} 

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

Source code for the .NET framework in C#

Code:

Link Menu
