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

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

/// <summary>
    /// 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.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class SafeList<T> :IEnumerable<T> {

        public delegate void ChangedHandler(SafeList<T> sender);

        public delegate IEnumerable<T> ListEditor(IList<T> items);

        [CLSCompliant(false)]
        protected volatile ReadOnlyCollection<T> items;

        protected object writeLock = new object();


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

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

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

        public ReadOnlyCollection<T> GetCollection() {
            return items;
        }

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

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

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


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

        public T First {
            get {
                ReadOnlyCollection<T> 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<T> 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<T> newList = GetList();
                newList.Insert(0, item);
                items = new ReadOnlyCollection<T>(newList);
            }
            FireChanged();
        }

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

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


        public IEnumerator<T>  GetEnumerator()
        {
            return items.GetEnumerator();
        }

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

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


    }