SafeList-线程安全的List(c#)

标签：etl   index   通过   logic   sum   form   getting   oid   writing   

List是线程不安全的，通过一个数组存储数据，当容量达到数组上限时，创建一个新数组，因此存在线程安全问题
SafeList是在做增删改操作时返回一个新的ReadonlyList，所以不存在线程安全问题

/// 

    /// SafeList is mutable, but it uses immutable data structures to minimize the need for locking.
    /// The provided manipulation 
    /// Exposes a immutable list. Changes are made by copying the lists.
    /// SafeList is 
    /// Never perform logic on SafeList directly, always use GetList() or GetCollection() first, followed by SetList().
    /// If you need involved list-fu, use ModifyList and specify a callback. It will execute inside a lock, preventing changes on other threads from overwriting each other.
    /// 
    /// 
    public class SafeList :IEnumerable {

        public delegate void ChangedHandler(SafeList sender);

        public delegate IEnumerable ListEditor(IList items);

        [CLSCompliant(false)]
        protected volatile ReadOnlyCollection items;

        protected object writeLock = new object();


        public SafeList(){
            items = new ReadOnlyCollection(new List());
        }

        public SafeList(IEnumerable items) {
            items = new ReadOnlyCollection(new List(items));
        }

        public event ChangedHandler Changed;
        protected void FireChanged() {
            if (Changed != null) Changed(this);
        }

        public ReadOnlyCollection GetCollection() {
            return items;
        }

        public IList GetList() {
            return new List(items);
        }
        

        public void SetList(IEnumerable list) {
            lock (writeLock) {
                items = new ReadOnlyCollection(new List(list));
            }
            FireChanged();
        }

        public void Add(T item) {
            lock (writeLock) {
                IList newList = GetList();
                newList.Add(item);
                items = new ReadOnlyCollection(newList);
            }
            FireChanged();
        }


        public bool Remove(T item) {
            lock (writeLock) {
                IList newList = GetList();
                bool removed = newList.Remove(item);
                if (!removed) return false; //The item didn‘t exist, don‘t fire changed events.
                items = new ReadOnlyCollection(newList);
            }
            FireChanged();
            return true;
        }

        public T First {
            get {
                ReadOnlyCollection copy = items; //So we can do logic without getting an index invalid exception
                if (copy.Count > 0) return copy[0];
                else return default(T);
            }
        }

        public T Last {
            get {
                ReadOnlyCollection copy = items; //So we can do logic without getting an index invalid exception
                if (copy.Count > 0) return copy[copy.Count -1];
                else return default(T);
            }
        }

        public void AddFirst(T item) {
            lock (writeLock) {
                IList newList = GetList();
                newList.Insert(0, item);
                items = new ReadOnlyCollection(newList);
            }
            FireChanged();
        }

        public void ModifyList(ListEditor callback) {
            lock (writeLock) {
                items = new ReadOnlyCollection(new List(callback(GetList())));
            }
            FireChanged();
        }

        public bool Contains(T item) {
            return items.Contains(item);
        }
    


        public IEnumerator  GetEnumerator()
        {
            return items.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable)items).GetEnumerator();
        }

        public IEnumerable Reversed {
            get {
                return new ReverseEnumerable(items);
            }
        }


    }

SafeList-线程安全的List(c#)

标签：etl   index   通过   logic   sum   form   getting   oid   writing   

原文地址：https://www.cnblogs.com/fanfan-90/p/14417727.html