Question

I got this síngleton cache object and it exposes an IEnumerable property which just returns a private IEnumerable variable.

I have a static method on my singleton object that updates this member variable (that exists on the single ‘Instance’ instance of this cache object).

Let’s say some thread is currently iterating over this IEnumerable variable/property while my cache is updating. I made it so the cache is updating on a new local variable and finally setting the exposed private variable to point to this new local variable.

I know i’m just updating a reference, leaving the other (old) object in memory waiting to be picked up by the GC but my problem is – i’m not 100% sure what happens once i set the new reference? Would the other thread suddenly be iterating over the new object or the old one it got passed through the IEnumerable interface? If it had been a normal reference i’d say ‘no’. The calling thread would be operating on the old object, but i’m not sure if this is the case for IEnumerable as well?

Here is the class stripped down:

internal sealed class SektionCache : CacheBase {     public static readonly SektionCache Instance = new SektionCache();     private static readonly object lockObject = new object();     private static bool isUpdating;      private IEnumerable<Sektion> sektioner;      static SektionCache()     {         UpdateCache();     }      public IEnumerable<Sektion> Sektioner     {         get { return sektioner; }     }      public static void UpdateCache()     {     // SNIP - getting data, locking etc.     Instance.sektioner = newSektioner;     // SNIP     } } 

Answer 1

The thread which is currently enumerating sektioner will continue to enumerate it even when you update the reference within the singleton. There is nothing special about objects which implement IEnumerable.

You should perhaps add the volatile keyword to the sektioner field as you are not providing read-locking and multiple threads are reading/writing it.