IBindingList 接口 和 IEditableObject 接口

/*
 * 由SharpDevelop创建。
 * 用户: Changweihua
 * 日期: 2014/3/2
 * 时间: 21:05
 *
 */
using System;
using System.ComponentModel;
using System.Collections;
using System.IO;
namespace IBindingListSapmle
{
    static class Program
    {
        public static void Main(string[] args)
        {
               
            CustomersList list = new CustomersList();
            list.LoadCustomers();
            list.AddNew();
            list[0].FirstName = "Weihua";
               
            Console.ReadKey(true);
        }
    }
       
    public class Customer : IEditableObject
    {
        struct CustomerData
        {
            internal string id ;
            internal string firstName ;
            internal string lastName ;
        }
        private CustomersList parent;
        private CustomerData custData;
        private CustomerData backupData;
        private bool inTxn = false;
        // Implements IEditableObject
        public void IEditableObject.BeginEdit()
        {
            Console.WriteLine("Start BeginEdit");
            if (!inTxn)
            {
                this.backupData = custData;
                inTxn = true;
                Console.WriteLine("BeginEdit - " + this.backupData.lastName);
            }
            Console.WriteLine("End BeginEdit");
        }
        public void IEditableObject.CancelEdit()
        {
            Console.WriteLine("Start CancelEdit");
            if (inTxn)
            {
                this.custData = backupData;
                inTxn = false;
                Console.WriteLine("CancelEdit - " + this.custData.lastName);
            }
            Console.WriteLine("End CancelEdit");
        }
        public void IEditableObject.EndEdit()
        {
            Console.WriteLine("Start EndEdit" + this.custData.id + this.custData.lastName);
            if (inTxn)
            {
                backupData = new CustomerData();
                inTxn = false;
                Console.WriteLine("Done EndEdit - " + this.custData.id + this.custData.lastName);
            }
            Console.WriteLine("End EndEdit");
        }
        public Customer(string ID) : base()
        {
            this.custData = new CustomerData();
            this.custData.id = ID;
            this.custData.firstName = "";
            this.custData.lastName = "";
        }
        public string ID
        {
            get
            {
                return this.custData.id;
            }
        }
        public string FirstName
        {
            get
            {
                return this.custData.firstName;
            }
            set
            {
                this.custData.firstName = value;
                this.OnCustomerChanged();
            }
        }
        public string LastName
        {
            get
            {
                return this.custData.lastName;
            }
            set
            {
                this.custData.lastName = value;
                this.OnCustomerChanged();
            }
        }
        internal CustomersList Parent
        {
            get
            {
                return parent;
            }
            set
            {
                parent = value ;
            }
        }
        private void OnCustomerChanged()
        {
            if (!inTxn && Parent != null)
            {
                Parent.CustomerChanged(this);
            }
        }
           
        public override string ToString()
        {
            StringWriter sb = new StringWriter();
            sb.Write(this.FirstName);
            sb.Write(" ");
            sb.Write(this.LastName);
            return sb.ToString();
        }  
    }
    public class CustomersList :  CollectionBase, IBindingList
    {
        private ListChangedEventArgs resetEvent = new ListChangedEventArgs(ListChangedType.Reset, -1);
        private ListChangedEventHandler onListChanged;
        public void LoadCustomers()
        {
            IList l = (IList)this;
            l.Add(ReadCustomer1());
            l.Add(ReadCustomer2());
            OnListChanged(resetEvent);
        }
        public Customer this[int index]
        {
            get
            {
                return (Customer)(List[index]);
            }
            set
            {
                List[index] = value;
            }
        }
        public int Add (Customer value)
        {
            return List.Add(value);
        }
        public Customer AddNew()
        {
            return (Customer)((IBindingList)this).AddNew();
        }
        public void Remove (Customer value)
        {
            List.Remove(value);
        }
        protected virtual void OnListChanged(ListChangedEventArgs ev)
        {
            if (onListChanged != null)
            {
                onListChanged(this, ev);
            }
        }
        protected override void OnClear()
        {
            foreach (Customer c in List)
            {
                c.Parent = null;
            }
        }
        protected override void OnClearComplete()
        {
            OnListChanged(resetEvent);
        }
        protected override void OnInsertComplete(int index, object value)
        {
            Customer c = (Customer)value;
            c.Parent = this;
            OnListChanged(new ListChangedEventArgs(ListChangedType.ItemAdded, index));
        }
        protected override void OnRemoveComplete(int index, object value)
        {
            Customer c = (Customer)value;
            c.Parent = this;
            OnListChanged(new ListChangedEventArgs(ListChangedType.ItemDeleted, index));
        }
        protected override void OnSetComplete(int index, object oldValue, object newValue)
        {
            if (oldValue != newValue)
            {
                Customer oldcust = (Customer)oldValue;
                Customer newcust = (Customer)newValue;
                oldcust.Parent = null;
                newcust.Parent = this;
                   
                OnListChanged(new ListChangedEventArgs(ListChangedType.ItemAdded, index));
            }
        }
        // Called by Customer when it changes.
        internal void CustomerChanged(Customer cust)
        {
               
            int index = List.IndexOf(cust);
            OnListChanged(new ListChangedEventArgs(ListChangedType.ItemChanged, index));
        }
        // Implements IBindingList.
        bool IBindingList.AllowEdit
        {
            get { return true ; }
        }
        bool IBindingList.AllowNew
        {
            get { return true ; }
        }
        bool IBindingList.AllowRemove
        {
            get { return true ; }
        }
        bool IBindingList.SupportsChangeNotification
        {
            get { return true ; }
        }
        bool IBindingList.SupportsSearching
        {
            get { return false ; }
        }
        bool IBindingList.SupportsSorting
        {
            get { return false ; }
        }
        // Events.
        public event ListChangedEventHandler ListChanged
        {
            add
            {
                onListChanged += value;
            }
            remove
            {
                onListChanged -= value;
            }
        }
        // Methods.
        object IBindingList.AddNew()
        {
            Customer c = new Customer(this.Count.ToString());
            List.Add(c);
            return c;
        }
        // Unsupported properties.
        bool IBindingList.IsSorted
        {
            get { throw new NotSupportedException(); }
        }
        ListSortDirection IBindingList.SortDirection
        {
            get { throw new NotSupportedException(); }
        }
        PropertyDescriptor IBindingList.SortProperty
        {
            get { throw new NotSupportedException(); }
        }
        // Unsupported Methods.
        void IBindingList.AddIndex(PropertyDescriptor property)
        {
            throw new NotSupportedException();
        }
        void IBindingList.ApplySort(PropertyDescriptor property, ListSortDirection direction)
        {
            throw new NotSupportedException();
        }
        int IBindingList.Find(PropertyDescriptor property, object key)
        {
            throw new NotSupportedException();
        }
        void IBindingList.RemoveIndex(PropertyDescriptor property)
        {
            throw new NotSupportedException();
        }
        void IBindingList.RemoveSort()
        {
            throw new NotSupportedException();
        }
        // Worker functions to populate the list with data.
        private static Customer ReadCustomer1()
        {
            Customer cust = new Customer("536-45-1245");
            cust.FirstName = "Jo";
            cust.LastName = "Brown";
            return cust;
        }
        private static Customer ReadCustomer2()
        {
            Customer cust = new Customer("246-12-5645");
            cust.FirstName = "Robert";
            cust.LastName = "Brown";
            return cust;
        }
    }
       
}


知识共享许可协议
《IBindingList 接口 和 IEditableObject 接口》常伟华 创作。
采用 知识共享 署名-相同方式共享 3.0 中国大陆 许可协议进行许可。
  • 多说评论
  • 签名
  • 新浪微博
  • 默认评论
  • Tab Header 5

0 条评论 / 点击此处发表评论

Tab Content 5

开发技术


开发平台和工具

sitemap     164.16ms