mcs/class/referencesource/System.Data.Entity/System/Data/Common/Utils/ThreadSafeList.cs

   1 //---------------------------------------------------------------------
   2 // <copyright file="ThreadSafeList.cs" company="Microsoft">
   3 //      Copyright (c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5 //
   6 // @owner Microsoft
   7 // @backupOwner Microsoft
   8 //---------------------------------------------------------------------
   9
  10 using System.Collections.Generic;
  11 using System.Threading;
  12 namespace System.Data.Common.Utils
  13 {
  14
  15     internal sealed class ThreadSafeList<T> : IList<T>
  16     {
  17         private readonly ReaderWriterLockSlim _lock;
  18         private List<T> _list;
  19
  20         internal ThreadSafeList()
  21         {
  22             _list = new List<T>();
  23             _lock = new ReaderWriterLockSlim();
  24         }
  25
  26         public int Count
  27         {
  28             get
  29             {
  30                 _lock.EnterReadLock();
  31                 int count;
  32                 try
  33                 {
  34                      count = _list.Count;
  35                 }
  36                 finally
  37                 {
  38                     _lock.ExitReadLock();
  39                 }
  40
  41                 return count;
  42             }
  43         }
  44
  45         public void Add(T item)
  46         {
  47             _lock.EnterWriteLock();
  48             try
  49             {
  50                 _list.Add(item);
  51             }
  52             finally
  53             {
  54                 _lock.ExitWriteLock();
  55             }
  56         }
  57
  58         public T this[int index]
  59         {
  60             get
  61             {
  62                 _lock.EnterReadLock();
  63                 T result;
  64                 try
  65                 {
  66                     result = _list[index];
  67                 }
  68                 finally
  69                 {
  70                     _lock.ExitReadLock();
  71                 }
  72                 return result;
  73             }
  74             set
  75             {
  76                 _lock.EnterWriteLock();
  77                 try
  78                 {
  79                     _list[index] = value;
  80                 }
  81                 finally
  82                 {
  83                     _lock.ExitWriteLock();
  84                 }
  85             }
  86         }
  87
  88         public bool IsReadOnly
  89         {
  90             get
  91             {
  92                 return false;
  93             }
  94         }
  95
  96         public int IndexOf(T item)
  97         {
  98             _lock.EnterReadLock();
  99             int result;
 100             try
 101             {
 102                 result = _list.IndexOf(item);
 103             }
 104             finally
 105             {
 106                 _lock.ExitReadLock();
 107             }
 108             return result;
 109         }
 110
 111         public void Insert(int index, T item)
 112         {
 113             _lock.EnterWriteLock();
 114             try
 115             {
 116                 _list.Insert(index, item);
 117             }
 118             finally
 119             {
 120                 _lock.ExitWriteLock();
 121             }
 122         }
 123
 124         public void RemoveAt(int index)
 125         {
 126             _lock.EnterWriteLock();
 127             try
 128             {
 129                 _list.RemoveAt(index);
 130             }
 131             finally
 132             {
 133                 _lock.ExitWriteLock();
 134             }
 135         }
 136
 137         public void Clear()
 138         {
 139             _lock.EnterWriteLock();
 140             try
 141             {
 142                 _list.Clear();
 143             }
 144             finally
 145             {
 146                 _lock.ExitWriteLock();
 147             }
 148         }
 149
 150         public bool Contains(T item)
 151         {
 152             _lock.EnterReadLock();
 153             bool result;
 154             try
 155             {
 156                 result = _list.Contains(item);
 157             }
 158             finally
 159             {
 160                 _lock.ExitReadLock();
 161             }
 162             return result;
 163         }
 164
 165         public void CopyTo(T[] array, int arrayIndex)
 166         {
 167             _lock.EnterWriteLock();
 168             try
 169             {
 170                 _list.CopyTo(array, arrayIndex);
 171             }
 172             finally
 173             {
 174                 _lock.ExitWriteLock();
 175             }
 176         }
 177
 178         public bool Remove(T item)
 179         {
 180             _lock.EnterWriteLock();
 181             bool result;
 182             try
 183             {
 184                 result = _list.Remove(item);
 185             }
 186             finally
 187             {
 188                 _lock.ExitWriteLock();
 189             }
 190             return result;
 191         }
 192
 193         public IEnumerator<T> GetEnumerator()
 194         {
 195             _lock.EnterReadLock();
 196             try
 197             {
 198                 foreach (T value in _list)
 199                 {
 200                     yield return value;
 201                 }
 202             }
 203             finally
 204             {
 205                 _lock.ExitReadLock();
 206             }
 207         }
 208
 209         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
 210         {
 211             return this.GetEnumerator();
 212         }
 213     }
 214
 215
 216
 217 }