Thread-safe List T property

Question

I want an implementation of List lt T gt  as a property which can be used thread-safely without any doubt   Something like this   private List lt T gt   list   private List lt T gt  MyT       get      return a copy of  list        set    list   value        It seems still I need to return a copy  cloned  of collection so if somewhere we are iterating the collection and at the same time the collection is set  then no exception is raised   How to implement a thread-safe collection property

User · Answer

In  NET Core  any version   you can use ImmutableList  which has all the functionality of List lt T gt

User · Answer

Even accepted answer is ConcurrentBag  I don t think it s real replacement of list in all cases  as Radek s comment to the answer says   ConcurrentBag is unordered collection  so unlike List it does not guarantee ordering  Also you cannot access items by index    So if you use  NET 4 0 or higher  a workaround could be to use ConcurrentDictionary with integer TKey as array index and TValue as array value  This is recommended way of replacing list in Pluralsight s C  Concurrent Collections course  ConcurrentDictionary solves both problems mentioned above  index accessing and ordering  we can not rely on ordering as it s hash table under the hood  but current  NET implementation saves order of elements adding

User · Answer

Even as it got the most votes  one usually can t take System Collections Concurrent ConcurrentBag lt T gt  as a thread-safe replacement for System Collections Generic List lt T gt  as it is  Radek Stromsk   already pointed it out  not ordered  But there is a class called System Collections Generic SynchronizedCollection lt T gt  that is already since  NET 3 0 part of the framework  but it is that well hidden in a location where one does not expect it that it is little known and probably you have never ever stumbled over it  at least I never did   SynchronizedCollection lt T gt  is compiled into assembly System ServiceModel dll  which is part of the client profile but not of the portable class library

User · Answer

I would think making a sample ThreadSafeList class would be easy  public class ThreadSafeList lt T gt    IList lt T gt        protected List lt T gt   internalList   new List lt T gt             Other Elements of IList implementation      public IEnumerator lt T gt  GetEnumerator                 return Clone   GetEnumerator               System Collections IEnumerator System Collections IEnumerable GetEnumerator                 return Clone   GetEnumerator               protected static object  lock   new object         public List lt T gt  Clone                 List lt T gt  newList   new List lt T gt              lock   lock                         internalList ForEach x   gt  newList Add x                       return newList           You simply clone the list before requesting an enumerator  and thus any enumeration is working off a copy that can t be modified while running

User · Answer

It seems like many of the people finding this are wanting a thread safe indexed dynamically sized collection   The closest and easiest thing I know of would be   System Collections Concurrent ConcurrentDictionary lt int  YourDataType gt    This would require you to ensure your key is properly incriminated if you want normal indexing behavior   If you are careful  count could suffice as the key for any new key value pairs you add

User · Answer

Use the lock statement to do this   Read here for more information    private List lt T gt   list   private List lt T gt  MyT       get   return  list        set                 Lock so only one thread can change the value at any given time          lock   list                         list   value                      FYI this probably isn t exactly what your asking - you likely want to lock farther out in your code but I can t assume that  Have a look at the lock keyword and tailor its use to your specific situation   If you need to  you could lock in both the get and set block using the  list variable which would make it so a read write can not occur at the same time

User · Answer

I believe  list ToList   will make you a copy  You can also query it if you need to such as     list Select  query here   ToList       Anyways  msdn says this is indeed a copy and not simply a reference  Oh  and yes  you will need to lock in the set method as the others have pointed out

User · Answer

If you are targetting  Net 4 there are a few options in System Collections Concurrent Namespace  You could use ConcurrentBag lt T gt  in this case instead of List lt T gt

User · Answer

Here is the class for thread safe list without lock   public class ConcurrentList                  private long  i   1          private ConcurrentDictionary lt long  T gt  dict   new ConcurrentDictionary lt long  T gt               public int Count                         return dict Count                     public List lt T gt  ToList                          return dict Values ToList                        public T this int i                        get                               long ii   dict Keys ToArray   i                   return dict ii                                   public void Remove T item                        T ov              var dicItem   dict Where c   gt  c Value Equals item   FirstOrDefault                if  dicItem Key  gt  0                                dict TryRemove dicItem Key  out ov                             this CheckReset                      public void RemoveAt int i                        long v   dict Keys ToArray   i               T ov              dict TryRemove v  out ov               this CheckReset                      public void Add T item                        dict TryAdd  i  item                i                      public IEnumerable lt T gt  Where Func lt T  bool gt  p                        return dict Values Where p                     public T FirstOrDefault Func lt T  bool gt  p                        return dict Values Where p  FirstOrDefault                      public bool Any Func lt T  bool gt  p                        return dict Values Where p  Count    gt  0   true   false                    public void Clear                         dict Clear                      private void CheckReset                         if  dict Count    0                                this Reset                                    private void Reset                          i   1

User · Answer

Here is the class you asked for   namespace AI Collections       using System      using System Collections      using System Collections Generic      using System Linq      using System Runtime Serialization      using System Threading Tasks      using System Threading Tasks Dataflow            lt summary gt              Just a simple thread safe collection           lt  summary gt           lt typeparam name  T  gt  lt  typeparam gt           lt value gt Version 1 5 lt  value gt           lt remarks gt TODO replace locks with AsyncLocks lt  remarks gt       DataContract  IsReference   true        public class ThreadSafeList lt T gt    IList lt T gt                 lt summary gt                  TODO replace the locks with a ReaderWriterLockSlim              lt  summary gt           DataMember          private readonly List lt T gt   items   new List lt T gt              public ThreadSafeList  IEnumerable lt T gt  items   null     this Add  items               public long LongCount               get                   lock   this  items                         return this  items LongCount                                                       public IEnumerator lt T gt  GetEnumerator     return this Clone   GetEnumerator               IEnumerator IEnumerable GetEnumerator     return this GetEnumerator               public void Add  T item                 if   Equals  default  T    item                       return                            lock   this  items                     this  items Add  item                                     public Boolean TryAdd  T item                 try                   if   Equals  default  T    item                           return false                                    lock   this  items                         this  items Add  item                        return true                                              catch   NullReferenceException                   catch   ObjectDisposedException                   catch   ArgumentNullException                   catch   ArgumentOutOfRangeException                   catch   ArgumentException                   return false                     public void Clear                 lock   this  items                     this  items Clear                                     public bool Contains  T item                 lock   this  items                     return this  items Contains  item                                     public void CopyTo  T   array  int arrayIndex                 lock   this  items                     this  items CopyTo  array  arrayIndex                                     public bool Remove  T item                 lock   this  items                     return this  items Remove  item                                     public int Count               get                   lock   this  items                         return this  items Count                                                     public bool IsReadOnly   get   return false               public int IndexOf  T item                 lock   this  items                     return this  items IndexOf  item                                     public void Insert  int index  T item                 lock   this  items                     this  items Insert  index  item                                     public void RemoveAt  int index                 lock   this  items                     this  items RemoveAt  index                                     public T this  int index                 get                   lock   this  items                         return this  items  index                                                set                   lock   this  items                         this  items  index     value                                                          lt summary gt                  Add in an enumerable of items               lt  summary gt               lt param name  collection  gt  lt  param gt               lt param name  asParallel  gt  lt  param gt          public void Add  IEnumerable lt T gt  collection  Boolean asParallel   true                 if   collection    null                     return                            lock   this  items                     this  items AddRange  asParallel                                                 collection AsParallel   Where  arg   gt   Equals  default  T    arg                                                     collection Where  arg   gt   Equals  default  T    arg                                         public Task AddAsync  T item                 return Task Factory StartNew       gt    this TryAdd  item                                 lt summary gt                  Add in an enumerable of items               lt  summary gt               lt param name  collection  gt  lt  param gt          public Task AddAsync  IEnumerable lt T gt  collection                 if   collection    null                     throw new ArgumentNullException   collection                                var produce   new TransformBlock lt T  T gt   item   gt  item  new ExecutionDataflowBlockOptions   MaxDegreeOfParallelism   Environment ProcessorCount                   var consume   new ActionBlock lt T gt   action  async obj   gt  await this AddAsync  obj    dataflowBlockOptions  new ExecutionDataflowBlockOptions   MaxDegreeOfParallelism   Environment ProcessorCount                  produce LinkTo  consume                 return Task Factory StartNew  async      gt                    collection AsParallel   ForAll  item   gt  produce SendAsync  item                      produce Complete                    await consume Completion                                           lt summary gt                  Returns a new copy of all items in the  lt see cref  List T     gt                lt  summary gt               lt returns gt  lt  returns gt          public List lt T gt  Clone  Boolean asParallel   true                 lock   this  items                     return asParallel                                  new List lt T gt   this  items AsParallel                                      new List lt T gt   this  items                                          lt summary gt                  Perform the  lt paramref name  action    gt  on each item in the list               lt  summary gt               lt param name  action  gt                   lt paramref name  action    gt  to perform on each item               lt  param gt               lt param name  performActionOnClones  gt                  If true  the  lt paramref name  action    gt  will be performed on a  lt see cref  Clone    gt  of the items               lt  param gt               lt param name  asParallel  gt                  Use the  lt see cref  ParallelQuery TSource     gt  method               lt  param gt               lt param name  inParallel  gt                  Use the                  lt see                     cref  Parallel ForEach TSource  System Collections Generic IEnumerable TSource  System Action TSource      gt                  method               lt  param gt          public void ForEach  Action lt T gt  action  Boolean performActionOnClones   true  Boolean asParallel   true  Boolean inParallel   false                 if   action    null                     throw new ArgumentNullException   action                               var wrapper   new Action lt T gt   obj   gt                    try                       action  obj                                      catch   ArgumentNullException                           if a null gets into the list then swallow an ArgumentNullException so we can continue adding                                                if   performActionOnClones                     var clones   this Clone  asParallel  asParallel                    if   asParallel                         clones AsParallel   ForAll  wrapper                                      else if   inParallel                         Parallel ForEach  clones  wrapper                                      else                       clones ForEach  wrapper                                                else                   lock   this  items                         if   asParallel                             this  items AsParallel   ForAll  wrapper                                              else if   inParallel                             Parallel ForEach  this  items  wrapper                                              else                           this  items ForEach  wrapper                                                                                  lt summary gt                  Perform the  lt paramref name  action    gt  on each item in the list               lt  summary gt               lt param name  action  gt                   lt paramref name  action    gt  to perform on each item               lt  param gt               lt param name  performActionOnClones  gt                  If true  the  lt paramref name  action    gt  will be performed on a  lt see cref  Clone    gt  of the items               lt  param gt               lt param name  asParallel  gt                  Use the  lt see cref  ParallelQuery TSource     gt  method               lt  param gt               lt param name  inParallel  gt                  Use the                  lt see                     cref  Parallel ForEach TSource  System Collections Generic IEnumerable TSource  System Action TSource      gt                  method               lt  param gt          public void ForAll  Action lt T gt  action  Boolean performActionOnClones   true  Boolean asParallel   true  Boolean inParallel   false                 if   action    null                     throw new ArgumentNullException   action                               var wrapper   new Action lt T gt   obj   gt                    try                       action  obj                                      catch   ArgumentNullException                           if a null gets into the list then swallow an ArgumentNullException so we can continue adding                                                if   performActionOnClones                     var clones   this Clone  asParallel  asParallel                    if   asParallel                         clones AsParallel   ForAll  wrapper                                      else if   inParallel                         Parallel ForEach  clones  wrapper                                      else                       clones ForEach  wrapper                                                else                   lock   this  items                         if   asParallel                             this  items AsParallel   ForAll  wrapper                                              else if   inParallel                             Parallel ForEach  this  items  wrapper                                              else                           this  items ForEach  wrapper

User · Answer

Looking at the original sample one may guess that the intention was to be able to simply replace the list with the new one  The setter on the property tells us about it  The Micrisoft s Thread-Safe Collections are for safely adding and removing items from collection  But if in the application logic you are intending to replace the collection with the new one  one may guess  again  that the adding and deleting functionality of the List is not required  If this is the case then  the simple answer would be to use IReadOnlyList interface   private IReadOnlyList lt T gt   readOnlyList   new List lt T gt          private IReadOnlyList lt T gt  MyT              get   return  readOnlyList           set    readOnlyList   value           One doesn t need to use any locking in this situation because there is no way to modify the collection  If in the setter the  quot  readOnlyList   value  quot  will be replaced by something more complicated then the lock could be required

User · Answer

You can also use the more primitive   Monitor Enter lock   Monitor Exit lock     which lock uses  see this post C  Locking an object that is reassigned in lock block    If you are expecting exceptions in the code this is not safe but it allows you to do something like the following   using System  using System Collections Generic  using System Threading  using System Linq   public class Something       private readonly object  lock      private readonly List lt string gt   contents       public Something                  lock   new object              contents   new List lt string gt                public Modifier StartModifying                 return new Modifier this              public class Modifier   IDisposable               private readonly Something  thing           public Modifier Something thing                         thing   thing               Monitor Enter Lock                      public void OneOfLotsOfDifferentOperations string input                        DoSomethingWith input                      private void DoSomethingWith string input                        Contents Add input                      private List lt string gt  Contents                       get   return  thing  contents                       private object Lock                       get   return  thing  lock                       public void Dispose                         Monitor Exit Lock                      public class Caller       public void Use Something thing                using  var modifier   thing StartModifying                          modifier OneOfLotsOfDifferentOperations  A                modifier OneOfLotsOfDifferentOperations  B                 modifier OneOfLotsOfDifferentOperations  A                modifier OneOfLotsOfDifferentOperations  A                modifier OneOfLotsOfDifferentOperations  A                        One of the nice things about this is you ll get the lock for the duration of the series of operations  rather than locking in each operation    Which means that the output should come out in the right chunks  my usage of this was getting some output onto screen from an external process   I do really like the simplicity   transparency of the ThreadSafeList   that does the important bit in stopping crashes

User · Answer

I would suggest anyone dealing with a List lt T gt  in multi-threading scenarios to take look at Immutable Collections in particular the ImmutableArray   I ve found it very useful when you have    Relatively few items in the list Not so many read write operations A LOT of concurrent access  i e  many threads that access the list in reading mode    Also can be useful when you need to implement some sort of transaction-like behavior  i e  revert an insert update delete operation in case of fail

User · Answer

C  s ArrayList class has a Synchronized method   var threadSafeArrayList   ArrayList Synchronized new ArrayList       This returns a thread safe wrapper around any instance of IList  All operations need to be performed through the wrapper to ensure thread safety

User · Answer

If you look at the source code for List of T  https   referencesource microsoft com  mscorlib system collections generic list cs c66df6f36c131877  you will notice there is a class there  which is of course internal - why  Microsoft  why      called SynchronizedList of T  I am copy pasting the code here        Serializable        internal class SynchronizedList   IList lt T gt            private List lt T gt   list          private Object  root           internal SynchronizedList List lt T gt  list                 list   list               root     System Collections ICollection list  SyncRoot                     public int Count               get                   lock   root                         return  list Count                                                      public bool IsReadOnly               get                   return   ICollection lt T gt   list  IsReadOnly                                   public void Add T item                lock   root                      list Add item                                     public void Clear                 lock   root                      list Clear                                      public bool Contains T item                lock   root                     return  list Contains item                                    public void CopyTo T   array  int arrayIndex                lock   root                      list CopyTo array  arrayIndex                                    public bool Remove T item                lock   root                     return  list Remove item                                    System Collections IEnumerator System Collections IEnumerable GetEnumerator                 lock   root                     return  list GetEnumerator                                     IEnumerator lt T gt  IEnumerable lt T gt  GetEnumerator                 lock   root                     return   IEnumerable lt T gt   list  GetEnumerator                                     public T this int index                get                   lock  root                        return  list index                                               set                   lock  root                         list index    value                                                     public int IndexOf T item                lock   root                    return  list IndexOf item                                    public void Insert int index  T item                lock   root                     list Insert index  item                                    public void RemoveAt int index                lock   root                     list RemoveAt index                                   Personally I think they knew a better implementation using SemaphoreSlim could be created  but didn t get to it

User · Answer

Basically if you want to enumerate safely  you need to use lock   Please refer to MSDN on this  http   msdn microsoft com en-us library 6sh2ey19 aspx  Here is part of MSDN that you might be interested   Public static  Shared in Visual Basic  members of this type are thread safe  Any instance members are not guaranteed to be thread safe   A List can support multiple readers concurrently  as long as the collection is not modified  Enumerating through a collection is intrinsically not a thread-safe procedure  In the rare case where an enumeration contends with one or more write accesses  the only way to ensure thread safety is to lock the collection during the entire enumeration  To allow the collection to be accessed by multiple threads for reading and writing  you must implement your own synchronization

[c#] Thread-safe List<T> property

Examples related to c#

Examples related to collections

Examples related to properties

Examples related to thread-safety