Tidak Ada Daftar Berurutan <T> dalam .Net 4.0?

Saya sangat senang melihat System.Collections.Concurrentnamespace baru di. Net 4.0, cukup bagus! Aku pernah melihat ConcurrentDictionary, ConcurrentQueue, ConcurrentStack, ConcurrentBagdan BlockingCollection.

Satu hal yang tampaknya hilang secara misterius adalah a ConcurrentList<T>. Apakah saya harus menulis sendiri (atau mengeluarkannya dari web :))?

Apakah saya melewatkan sesuatu yang jelas di sini?

Saya mencobanya beberapa waktu lalu (juga: di GitHub ). Implementasi saya memiliki beberapa masalah, yang tidak akan saya bahas di sini. Biarkan saya memberi tahu Anda, yang lebih penting, apa yang saya pelajari.

Pertama, tidak mungkin Anda akan mendapatkan implementasi penuh IList<T>yang tidak terkunci dan aman. Secara khusus, penyisipan dan pemindahan acak tidak akan berfungsi, kecuali jika Anda juga melupakan O (1) akses acak (yaitu, kecuali jika Anda "menipu" dan hanya menggunakan semacam daftar yang ditautkan dan membiarkan pengindeksan menyedot).

Apa yang saya pikir mungkin ada baiknya adalah, bagian terbatas benang-aman dari IList<T>: khususnya, yang akan memungkinkan Adddan menyediakan random read-only akses dengan indeks (tapi tidak ada Insert, RemoveAt, dll, dan juga tidak ada random write akses).

Ini adalah tujuan implementasi sayaConcurrentList<T> . Tetapi ketika saya menguji kinerjanya dalam skenario multithreaded, saya menemukan bahwa hanya menyinkronkan menambahkan ke List<T>lebih cepat . Pada dasarnya, menambahkan ke List<T>sudah cepat kilat; kompleksitas langkah-langkah komputasi yang terlibat adalah sangat kecil (menambah indeks dan menetapkan ke elemen dalam array; itu benar - benar itu ). Anda akan membutuhkan satu ton tulisan bersamaan untuk melihat segala jenis pertikaian kunci tentang ini; dan bahkan kemudian, kinerja rata-rata dari setiap penulisan masih akan mengalahkan yang lebih mahal meskipun implementasi tanpa kunci di ConcurrentList<T>.

Dalam peristiwa yang relatif jarang bahwa array internal daftar perlu mengubah ukuran sendiri, Anda membayar biaya yang kecil. Jadi pada akhirnya saya menyimpulkan bahwa ini adalah satu ceruk skenario di mana ConcurrentList<T>jenis koleksi add-only akan masuk akal: ketika Anda ingin overhead rendah dijamin menambahkan elemen pada setiap panggilan (sehingga, sebagai lawan dari tujuan kinerja diamortisasi).

Ini hanya kelas yang hampir tidak berguna seperti yang Anda pikirkan.

Untuk apa Anda menggunakan ConcurrentList?

Konsep wadah Akses Acak di dunia berulir tidak berguna seperti yang terlihat. Pernyataan

  if (i < MyConcurrentList.Count)  
      x = MyConcurrentList[i]; 

secara keseluruhan masih belum aman.

Alih-alih membuat ConcurrentList, cobalah untuk membangun solusi dengan apa yang ada di sana. Kelas yang paling umum adalah ConcurrentBag dan terutama BlockingCollection.

Dengan segala hormat pada jawaban-jawaban luar biasa yang telah diberikan, ada saatnya saya hanya menginginkan IList yang aman utas. Tidak ada yang maju atau mewah. Kinerja penting dalam banyak kasus tetapi kadang-kadang itu bukan masalah. Ya, akan selalu ada tantangan tanpa metode seperti "TryGetValue" dll, tetapi kebanyakan kasus saya hanya ingin sesuatu yang dapat saya sebutkan tanpa perlu khawatir tentang meletakkan kunci di sekitar segalanya. Dan ya, seseorang mungkin dapat menemukan beberapa "bug" dalam implementasi saya yang mungkin menyebabkan kebuntuan atau sesuatu (saya kira) tetapi mari kita jujur: Ketika datang ke multi-threading, jika Anda tidak menulis kode Anda dengan benar, itu akan menemui jalan buntu. Dengan pemikiran itu saya memutuskan untuk membuat implementasi ConcurrentList sederhana yang menyediakan kebutuhan dasar ini.

Dan untuk apa nilainya: Saya melakukan tes dasar untuk menambahkan 10.000.000 item ke Daftar dan Daftar Bersama reguler dan hasilnya adalah:

Daftar selesai dalam: 7793 milidetik. Bersamaan selesai dalam: 8064 milidetik.

public class ConcurrentList<T> : IList<T>, IDisposable
{
    #region Fields
    private readonly List<T> _list;
    private readonly ReaderWriterLockSlim _lock;
    #endregion

    #region Constructors
    public ConcurrentList()
    {
        this._lock = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
        this._list = new List<T>();
    }

    public ConcurrentList(int capacity)
    {
        this._lock = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
        this._list = new List<T>(capacity);
    }

    public ConcurrentList(IEnumerable<T> items)
    {
        this._lock = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
        this._list = new List<T>(items);
    }
    #endregion

    #region Methods
    public void Add(T item)
    {
        try
        {
            this._lock.EnterWriteLock();
            this._list.Add(item);
        }
        finally
        {
            this._lock.ExitWriteLock();
        }
    }

    public void Insert(int index, T item)
    {
        try
        {
            this._lock.EnterWriteLock();
            this._list.Insert(index, item);
        }
        finally
        {
            this._lock.ExitWriteLock();
        }
    }

    public bool Remove(T item)
    {
        try
        {
            this._lock.EnterWriteLock();
            return this._list.Remove(item);
        }
        finally
        {
            this._lock.ExitWriteLock();
        }
    }

    public void RemoveAt(int index)
    {
        try
        {
            this._lock.EnterWriteLock();
            this._list.RemoveAt(index);
        }
        finally
        {
            this._lock.ExitWriteLock();
        }
    }

    public int IndexOf(T item)
    {
        try
        {
            this._lock.EnterReadLock();
            return this._list.IndexOf(item);
        }
        finally
        {
            this._lock.ExitReadLock();
        }
    }

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

    public bool Contains(T item)
    {
        try
        {
            this._lock.EnterReadLock();
            return this._list.Contains(item);
        }
        finally
        {
            this._lock.ExitReadLock();
        }
    }

    public void CopyTo(T[] array, int arrayIndex)
    {
        try
        {
            this._lock.EnterReadLock();
            this._list.CopyTo(array, arrayIndex);
        }
        finally
        {
            this._lock.ExitReadLock();
        }
    }

    public IEnumerator<T> GetEnumerator()
    {
        return new ConcurrentEnumerator<T>(this._list, this._lock);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return new ConcurrentEnumerator<T>(this._list, this._lock);
    }

    ~ConcurrentList()
    {
        this.Dispose(false);
    }

    public void Dispose()
    {
        this.Dispose(true);
    }

    private void Dispose(bool disposing)
    {
        if (disposing)
            GC.SuppressFinalize(this);

        this._lock.Dispose();
    }
    #endregion

    #region Properties
    public T this[int index]
    {
        get
        {
            try
            {
                this._lock.EnterReadLock();
                return this._list[index];
            }
            finally
            {
                this._lock.ExitReadLock();
            }
        }
        set
        {
            try
            {
                this._lock.EnterWriteLock();
                this._list[index] = value;
            }
            finally
            {
                this._lock.ExitWriteLock();
            }
        }
    }

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

    public bool IsReadOnly
    {
        get { return false; }
    }
    #endregion
}

    public class ConcurrentEnumerator<T> : IEnumerator<T>
{
    #region Fields
    private readonly IEnumerator<T> _inner;
    private readonly ReaderWriterLockSlim _lock;
    #endregion

    #region Constructor
    public ConcurrentEnumerator(IEnumerable<T> inner, ReaderWriterLockSlim @lock)
    {
        this._lock = @lock;
        this._lock.EnterReadLock();
        this._inner = inner.GetEnumerator();
    }
    #endregion

    #region Methods
    public bool MoveNext()
    {
        return _inner.MoveNext();
    }

    public void Reset()
    {
        _inner.Reset();
    }

    public void Dispose()
    {
        this._lock.ExitReadLock();
    }
    #endregion

    #region Properties
    public T Current
    {
        get { return _inner.Current; }
    }

    object IEnumerator.Current
    {
        get { return _inner.Current; }
    }
    #endregion
}

ConcurrentList(sebagai array yang dapat diubah ukurannya, bukan daftar yang ditautkan) tidak mudah untuk ditulis dengan operasi nonblocking. API-nya tidak diterjemahkan dengan baik ke versi "bersamaan".

Alasan mengapa tidak ada ConcurrentList adalah karena secara fundamental tidak dapat ditulis. Alasan mengapa beberapa operasi penting dalam IList bergantung pada indeks, dan itu tidak akan berhasil. Sebagai contoh:

int catIndex = list.IndexOf("cat");
list.Insert(catIndex, "dog");

Efek yang penulis cari adalah memasukkan "anjing" sebelum "kucing", tetapi dalam lingkungan multithreaded, apa pun dapat terjadi pada daftar di antara dua baris kode tersebut. Misalnya, utas lainnya mungkin dilakukan list.RemoveAt(0), menggeser seluruh daftar ke kiri, tetapi yang terpenting, catIndex tidak akan berubah. Dampaknya di sini adalah bahwa Insertoperasi akan benar-benar menempatkan "anjing" setelah kucing, bukan sebelumnya.

Beberapa implementasi yang Anda lihat ditawarkan sebagai "jawaban" untuk pertanyaan ini bermaksud baik, tetapi seperti yang ditunjukkan di atas, mereka tidak menawarkan hasil yang dapat diandalkan. Jika Anda benar-benar menginginkan semantik mirip daftar dalam lingkungan multithreaded, Anda tidak bisa mencapainya dengan memasukkan kunci di dalamnya dalam metode implementasi daftar. Anda harus memastikan bahwa indeks apa pun yang Anda gunakan hidup sepenuhnya di dalam konteks kunci. Hasilnya adalah bahwa Anda dapat menggunakan Daftar di lingkungan multithreaded dengan penguncian yang benar, tetapi daftar itu sendiri tidak dapat dibuat ada di dunia itu.

Jika Anda merasa perlu daftar bersama, sebenarnya hanya ada dua kemungkinan:

1. Yang Anda butuhkan adalah ConcurrentBag
2. Anda perlu membuat koleksi Anda sendiri, mungkin diimplementasikan dengan Daftar dan kontrol konkurensi Anda sendiri.

Jika Anda memiliki ConcurrentBag dan berada dalam posisi di mana Anda harus melewatinya sebagai IList, maka Anda memiliki masalah, karena metode yang Anda panggil telah menentukan bahwa mereka mungkin mencoba melakukan sesuatu seperti yang saya lakukan di atas dengan kucing & anjing. Di sebagian besar dunia, apa artinya adalah bahwa metode yang Anda panggil sama sekali tidak dibangun untuk bekerja di lingkungan multi-utas. Itu berarti Anda baik refactor sehingga itu atau, jika Anda tidak bisa, Anda harus menanganinya dengan sangat hati-hati. Anda hampir pasti akan diminta untuk membuat koleksi Anda sendiri dengan kunci sendiri, dan memanggil metode yang menyinggung dalam kunci.

Dalam kasus di mana bacaan jauh lebih banyak daripada menulis, atau (betapapun sering) menulis tidak bersamaan , copy-on-write mungkin tepat.

Implementasi yang ditunjukkan di bawah ini adalah

• tidak terkunci
• sangat cepat untuk membaca bersamaan , bahkan saat modifikasi bersamaan sedang berlangsung - tidak peduli berapa lama waktu yang dibutuhkan
• karena "snapshots" tidak dapat diubah, atomicity tanpa kunci adalah mungkin, yaitu var snap = _list; snap[snap.Count - 1];tidak akan pernah (yah, kecuali untuk daftar kosong tentu saja) melempar, dan Anda juga mendapatkan pencacahan aman dengan semantik snapshot gratis .. bagaimana saya MENCINTAI kekekalan!
• diimplementasikan secara umum , berlaku untuk setiap struktur data dan semua jenis modifikasi
• sederhana , yaitu mudah untuk menguji, men-debug, memverifikasi dengan membaca kode
• dapat digunakan dalam. Net 3.5

Agar copy-on-write berfungsi, Anda harus menjaga agar struktur data Anda tetap tidak dapat diubah , yaitu tidak ada seorang pun yang boleh mengubahnya setelah Anda membuatnya tersedia untuk utas lainnya. Ketika Anda ingin memodifikasi, Anda

1. mengkloning struktur
2. melakukan modifikasi pada klon
3. bertukar atom dalam referensi ke klon yang dimodifikasi

Kode

static class CopyOnWriteSwapper
{
    public static void Swap<T>(ref T obj, Func<T, T> cloner, Action<T> op)
        where T : class
    {
        while (true)
        {
            var objBefore = Volatile.Read(ref obj);
            var newObj = cloner(objBefore);
            op(newObj);
            if (Interlocked.CompareExchange(ref obj, newObj, objBefore) == objBefore)
                return;
        }
    }
}

Pemakaian

CopyOnWriteSwapper.Swap(ref _myList,
    orig => new List<string>(orig),
    clone => clone.Add("asdf"));

Jika Anda memerlukan lebih banyak kinerja, ini akan membantu untuk menghilangkan metode, misalnya membuat satu metode untuk setiap jenis modifikasi (Tambah, Hapus, ...) yang Anda inginkan, dan hard code pointer fungsi clonerdan op.

NB # 1 Adalah tanggung jawab Anda untuk memastikan tidak ada yang mengubah struktur data (yang seharusnya) tidak dapat diubah. Tidak ada yang bisa kita lakukan dalam implementasi generik untuk mencegah hal itu, tetapi ketika mengkhususkan diri untuk List<T>, Anda bisa menjaga terhadap modifikasi menggunakan List.AsReadOnly ()

NB # 2 Berhati-hatilah dengan nilai-nilai dalam daftar. Pendekatan salin saat menulis di atas hanya melindungi keanggotaan daftar mereka, tetapi jika Anda tidak meletakkan string, tetapi beberapa objek yang dapat berubah di sana, Anda harus menjaga keamanan utas (mis. Mengunci). Tapi itu ortogonal untuk solusi ini dan misalnya penguncian nilai-nilai yang bisa berubah dapat dengan mudah digunakan tanpa masalah. Anda hanya perlu menyadarinya.

NB # 3 Jika struktur data Anda sangat besar dan Anda sering memodifikasinya, pendekatan copy-all-on-write mungkin menjadi penghalang baik dalam hal konsumsi memori maupun biaya penyalinan CPU yang terlibat. Dalam hal itu, Anda mungkin ingin menggunakan Koleksi Immutable MS sebagai gantinya.

System.Collections.Generic.List<t>sudah aman untuk banyak pembaca. Mencoba membuatnya aman untuk banyak penulis tidak masuk akal. (Untuk alasan Henk dan Stephen sudah disebutkan)

Beberapa orang menunjukkan beberapa poin barang (dan beberapa pemikiran saya):

• Itu bisa terlihat seperti gila untuk tidak dapat accesser acak (pengindeks) tetapi bagi saya tampaknya baik-baik saja. Anda hanya perlu berpikir bahwa ada banyak metode pada koleksi multi-utas yang bisa gagal seperti Indexer dan Hapus. Anda juga bisa mendefinisikan tindakan kegagalan (fallback) untuk aksesor tulis seperti "gagal" atau cukup "tambahkan di akhir".
• Ini bukan karena itu adalah kumpulan multithreaded yang akan selalu digunakan dalam konteks multithreaded. Atau bisa juga digunakan oleh hanya satu penulis dan satu pembaca.
• Cara lain untuk dapat menggunakan pengindeks dengan cara yang aman bisa dengan membungkus tindakan ke dalam kunci koleksi menggunakan root (jika dipublikasikan).
• Bagi banyak orang, membuat rootLock dapat dilihat berarti "Praktik yang baik". Saya tidak 100% yakin tentang hal ini karena jika disembunyikan Anda menghapus banyak fleksibilitas kepada pengguna. Kita harus selalu ingat bahwa pemrograman multithread bukan untuk siapa pun. Kami tidak dapat mencegah segala jenis penggunaan yang salah.
• Microsoft harus melakukan beberapa pekerjaan dan menetapkan beberapa standar baru untuk memperkenalkan penggunaan koleksi Multithreaded yang tepat. Pertama, IEnumerator seharusnya tidak memiliki moveNext tetapi harus memiliki GetNext yang mengembalikan true atau false dan mendapatkan parameter tipe T (dengan cara ini iterasi tidak akan memblokir lagi). Juga, Microsoft sudah menggunakan "menggunakan" secara internal di muka tetapi kadang-kadang menggunakan IEnumerator secara langsung tanpa membungkusnya dengan "menggunakan" (bug dalam tampilan koleksi dan mungkin di lebih banyak tempat) - Membungkus penggunaan IEnumerator adalah praktik yang disarankan oleh Microsoft. Bug ini menghilangkan potensi bagus untuk iterator aman ... Iterator yang mengunci koleksi di konstruktor dan membuka kunci pada metode Buang - untuk metode foreach pemblokiran.

Itu bukan jawaban. Ini hanya komentar yang tidak benar-benar cocok untuk tempat tertentu.

... Kesimpulan saya, Microsoft harus membuat beberapa perubahan mendalam pada "foreach" untuk membuat koleksi MultiThreaded lebih mudah digunakan. Juga harus mengikuti aturan penggunaan IEnumerator di sana. Sampai saat itu, kita dapat menulis MultiThreadList dengan mudah yang akan menggunakan iterator pemblokiran tetapi itu tidak akan mengikuti "IList". Sebagai gantinya, Anda harus mendefinisikan sendiri antarmuka "IListPersonnal" yang bisa gagal pada "insert", "remove" dan accessor acak (pengindeks) tanpa terkecuali. Tapi siapa yang mau menggunakannya jika tidak standar?

Dalam mengeksekusi kode secara berurutan struktur data yang digunakan berbeda dari (juga ditulis) secara bersamaan mengeksekusi kode. Alasannya adalah bahwa kode berurutan menyiratkan urutan implisit. Namun kode bersamaan tidak menyiratkan urutan apa pun; lebih baik lagi itu menyiratkan kurangnya urutan yang ditentukan!

Karena ini, struktur data dengan urutan tersirat (seperti Daftar) tidak sangat berguna untuk memecahkan masalah bersamaan. Daftar menyiratkan pesanan, tetapi tidak jelas mendefinisikan apa pesanan itu. Karena itu, urutan eksekusi kode yang memanipulasi daftar akan menentukan (hingga taraf tertentu) urutan implisit daftar, yang bertentangan langsung dengan solusi konkuren yang efisien.

Ingat concurrency adalah masalah data, bukan masalah kode! Anda tidak dapat Menerapkan kode terlebih dahulu (atau menulis ulang kode sekuensial yang ada) dan mendapatkan solusi bersamaan yang dirancang dengan baik. Anda perlu merancang struktur data terlebih dahulu sambil tetap mengingat bahwa pemesanan implisit tidak ada dalam sistem bersamaan.

Lockless Copy and Write approach bekerja sangat baik jika Anda tidak berurusan dengan terlalu banyak item. Inilah kelas yang saya tulis:

public class CopyAndWriteList<T>
{
    public static List<T> Clear(List<T> list)
    {
        var a = new List<T>(list);
        a.Clear();
        return a;
    }

    public static List<T> Add(List<T> list, T item)
    {
        var a = new List<T>(list);
        a.Add(item);
        return a;
    }

    public static List<T> RemoveAt(List<T> list, int index)
    {
        var a = new List<T>(list);
        a.RemoveAt(index);
        return a;
    }

    public static List<T> Remove(List<T> list, T item)
    {
        var a = new List<T>(list);
        a.Remove(item);
        return a;
    }

}

contoh penggunaan: orders_BUY = CopyAndWriteList.Clear (orders_BUY);

Saya menerapkan yang mirip dengan Brian . Milik saya berbeda:

• Saya mengelola array secara langsung.
• Saya tidak memasukkan kunci di dalam blok coba.
• saya menggunakan yield return untuk menghasilkan enumerator.
• Saya mendukung rekursi kunci. Ini memungkinkan membaca dari daftar selama iterasi.
• Saya menggunakan kunci baca yang dapat diupgrade jika memungkinkan.
• DoSyncdan GetSyncmetode yang memungkinkan interaksi berurutan yang memerlukan akses eksklusif ke daftar.

Kode :

public class ConcurrentList<T> : IList<T>, IDisposable
{
    private ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
    private int _count = 0;

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

    public int InternalArrayLength
    { 
        get
        { 
            _lock.EnterReadLock();
            try
            {           
                return _arr.Length;
            }
            finally
            {
                _lock.ExitReadLock();
            }
        }
    }

    private T[] _arr;

    public ConcurrentList(int initialCapacity)
    {
        _arr = new T[initialCapacity];
    }

    public ConcurrentList():this(4)
    { }

    public ConcurrentList(IEnumerable<T> items)
    {
        _arr = items.ToArray();
        _count = _arr.Length;
    }

    public void Add(T item)
    {
        _lock.EnterWriteLock();
        try
        {       
            var newCount = _count + 1;          
            EnsureCapacity(newCount);           
            _arr[_count] = item;
            _count = newCount;                  
        }
        finally
        {
            _lock.ExitWriteLock();
        }       
    }

    public void AddRange(IEnumerable<T> items)
    {
        if (items == null)
            throw new ArgumentNullException("items");

        _lock.EnterWriteLock();

        try
        {           
            var arr = items as T[] ?? items.ToArray();          
            var newCount = _count + arr.Length;
            EnsureCapacity(newCount);           
            Array.Copy(arr, 0, _arr, _count, arr.Length);       
            _count = newCount;
        }
        finally
        {
            _lock.ExitWriteLock();          
        }
    }

    private void EnsureCapacity(int capacity)
    {   
        if (_arr.Length >= capacity)
            return;

        int doubled;
        checked
        {
            try
            {           
                doubled = _arr.Length * 2;
            }
            catch (OverflowException)
            {
                doubled = int.MaxValue;
            }
        }

        var newLength = Math.Max(doubled, capacity);            
        Array.Resize(ref _arr, newLength);
    }

    public bool Remove(T item)
    {
        _lock.EnterUpgradeableReadLock();

        try
        {           
            var i = IndexOfInternal(item);

            if (i == -1)
                return false;

            _lock.EnterWriteLock();
            try
            {   
                RemoveAtInternal(i);
                return true;
            }
            finally
            {               
                _lock.ExitWriteLock();
            }
        }
        finally
        {           
            _lock.ExitUpgradeableReadLock();
        }
    }

    public IEnumerator<T> GetEnumerator()
    {
        _lock.EnterReadLock();

        try
        {    
            for (int i = 0; i < _count; i++)
                // deadlocking potential mitigated by lock recursion enforcement
                yield return _arr[i]; 
        }
        finally
        {           
            _lock.ExitReadLock();
        }
    }

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

    public int IndexOf(T item)
    {
        _lock.EnterReadLock();
        try
        {   
            return IndexOfInternal(item);
        }
        finally
        {
            _lock.ExitReadLock();
        }
    }

    private int IndexOfInternal(T item)
    {
        return Array.FindIndex(_arr, 0, _count, x => x.Equals(item));
    }

    public void Insert(int index, T item)
    {
        _lock.EnterUpgradeableReadLock();

        try
        {                       
            if (index > _count)
                throw new ArgumentOutOfRangeException("index"); 

            _lock.EnterWriteLock();
            try
            {       
                var newCount = _count + 1;
                EnsureCapacity(newCount);

                // shift everything right by one, starting at index
                Array.Copy(_arr, index, _arr, index + 1, _count - index);

                // insert
                _arr[index] = item;     
                _count = newCount;
            }
            finally
            {           
                _lock.ExitWriteLock();
            }
        }
        finally
        {
            _lock.ExitUpgradeableReadLock();            
        }


    }

    public void RemoveAt(int index)
    {   
        _lock.EnterUpgradeableReadLock();
        try
        {   
            if (index >= _count)
                throw new ArgumentOutOfRangeException("index");

            _lock.EnterWriteLock();
            try
            {           
                RemoveAtInternal(index);
            }
            finally
            {
                _lock.ExitWriteLock();
            }
        }
        finally
        {
            _lock.ExitUpgradeableReadLock();            
        }
    }

    private void RemoveAtInternal(int index)
    {           
        Array.Copy(_arr, index + 1, _arr, index, _count - index-1);
        _count--;

        // release last element
        Array.Clear(_arr, _count, 1);
    }

    public void Clear()
    {
        _lock.EnterWriteLock();
        try
        {        
            Array.Clear(_arr, 0, _count);
            _count = 0;
        }
        finally
        {           
            _lock.ExitWriteLock();
        }   
    }

    public bool Contains(T item)
    {
        _lock.EnterReadLock();
        try
        {   
            return IndexOfInternal(item) != -1;
        }
        finally
        {           
            _lock.ExitReadLock();
        }
    }

    public void CopyTo(T[] array, int arrayIndex)
    {       
        _lock.EnterReadLock();
        try
        {           
            if(_count > array.Length - arrayIndex)
                throw new ArgumentException("Destination array was not long enough.");

            Array.Copy(_arr, 0, array, arrayIndex, _count);
        }
        finally
        {
            _lock.ExitReadLock();           
        }
    }

    public bool IsReadOnly
    {   
        get { return false; }
    }

    public T this[int index]
    {
        get
        {
            _lock.EnterReadLock();
            try
            {           
                if (index >= _count)
                    throw new ArgumentOutOfRangeException("index");

                return _arr[index]; 
            }
            finally
            {
                _lock.ExitReadLock();               
            }           
        }
        set
        {
            _lock.EnterUpgradeableReadLock();
            try
            {

                if (index >= _count)
                    throw new ArgumentOutOfRangeException("index");

                _lock.EnterWriteLock();
                try
                {                       
                    _arr[index] = value;
                }
                finally
                {
                    _lock.ExitWriteLock();              
                }
            }
            finally
            {
                _lock.ExitUpgradeableReadLock();
            }

        }
    }

    public void DoSync(Action<ConcurrentList<T>> action)
    {
        GetSync(l =>
        {
            action(l);
            return 0;
        });
    }

    public TResult GetSync<TResult>(Func<ConcurrentList<T>,TResult> func)
    {
        _lock.EnterWriteLock();
        try
        {           
            return func(this);
        }
        finally
        {
            _lock.ExitWriteLock();
        }
    }

    public void Dispose()
    {   
        _lock.Dispose();
    }
}