ThreadSafeList<T>

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Threading;

namespace Core {

    public class ThreadSafeList<T>:IEnumerable<T> where T:class {

        readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
        readonly List<T> _innerList;

        public ThreadSafeList() {
            _innerList = new List<T>();
        }
        public ThreadSafeList(int capacity) {
            _innerList = new List<T>(capacity);
        }
        public ThreadSafeList(IEnumerable<T> collection) {
            _innerList = new List<T>(collection);
        }
        public void Add(T item) {
            _lock.EnterWriteLock();
            try {
                _innerList.Add(item);
            }
            finally {
                _lock.ExitWriteLock();
            }
        }

        public void AddRange(IEnumerable<T> collection) {
            _lock.EnterWriteLock();
            try {
                _innerList.AddRange(collection);
            }
            finally {
                _lock.ExitWriteLock();
            }
        }

        public void Insert(int index,T item) {
            _lock.EnterWriteLock();
            try {
                _innerList.Insert(index,item);
            }
            finally {
                _lock.ExitWriteLock();
            }
        }
        public void InsertRange(int index,IEnumerable<T> collection) {
            _lock.EnterWriteLock();
            try {
                _innerList.InsertRange(index,collection);
            }
            finally {
                _lock.ExitWriteLock();
            }
        }

        public bool Remove(T item) {
            _lock.EnterWriteLock();
            try {
                return _innerList.Remove(item);
            }
            finally {
                _lock.ExitWriteLock();
            }
        }
        public void RemoveAt(int index) {

            _lock.EnterWriteLock();
            try {
                _innerList.RemoveAt(index);
            }
            finally {
                _lock.ExitWriteLock();
            }
        }


        public int Count {
            get {
                _lock.EnterReadLock();
                try {
                    return _innerList.Count;
                }
                finally {
                    _lock.ExitReadLock();
                }
            }
        }

        public T this[int index] {
            get {
                _lock.EnterReadLock();
                try {
                    return _innerList[index];
                }
                finally {
                    _lock.ExitReadLock();
                }

            }
            set {
                _lock.EnterWriteLock();
                try {
                    _innerList[index] = value;
                }
                finally {
                    _lock.ExitWriteLock();
                }
            }
        }
        public T GetOrCreate(Predicate<T> predicate,Func<T> creator) {
            _lock.EnterUpgradeableReadLock();
            try {
                var item = _innerList.FirstOrDefault(pm => predicate(pm));

                if(item == null) {
                    _lock.EnterWriteLock();
                    try {
                        item = creator();

                        _innerList.Add(item);
                    }
                    finally {
                        _lock.ExitWriteLock();
                    }
                }

                return item;
            }
            finally {
                _lock.ExitUpgradeableReadLock();
            }

        }

        public void Clear() {
            _lock.EnterWriteLock();
            try {
                _innerList.Clear();
            }
            finally {
                _lock.ExitWriteLock();
            }
        }

        IEnumerator<T> IEnumerable<T>.GetEnumerator() {
            return GetEnumeratorInternal();
        }

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

        IEnumerator<T> GetEnumeratorInternal() {
            _lock.EnterReadLock();
            try {
                return _innerList.ToList().GetEnumerator();
            }
            finally {
                _lock.ExitReadLock();
            }
        }
    }
}