Zastanawiam się, które z nich jest lepszym podejściem do ładowania danych w sposób bezpieczny dla wątków. Tradycyjnie użyłem wzoru podwójnego zamka, który dobrze spełniał swoje zadanie. Teraz, z dodatkiem System.Lazy typu, zastanawiam się, czy poleganie na wewnętrznych Lazy i Loading jest lepsze i wykonać zadanie w znacznie lepszy sposób. Wygląda na czystszy i łatwiejszy do czytania, ale czy jest lepszy?

jakieś pomysły?

namespace SomeNameSpace
{
  public class DataStoreContext
  {
    private readonly static Lazy<DataStoreContext> context = new Lazy<DataStoreContext>(() => new DataStoreContext());
    private Lazy<Dictionary<string, Entity>> _entities = new Lazy<Dictionary<string, Entity>>(() => { return DataStoreContext.Instance.Load(); });
    private readonly object _syncRoot = new object();
    private DataStoreContext()
    {
    }

    public Dictionary<string, Entity> Data
    {
      get { return _entities.Value; }
    }

    public static DataStoreContext Instance
    {
      get { return context.Value; }
    }

    private Dictionary<string, Entity> Load()
    {
      // Load Data from some data store. 
      return null;
    }

    private Dictionary<string, Entity> LoadWithLock()
    {
      if (_entities == null)
      {
        lock (_syncRoot)
        {
          if (_entities == null)
          {
            Dictionary<string, Entity> entities = this.Load();
            _entities = entities;
            return _entities;
          }
        }
      }

      return _entities ;
    }

    public void Clear()
    {

     _entities = new Lazy<Dictionary<string, Entity>>(() => { return DataStoreContext.Instance.Load(); });

    }
  }
}