thread safe drawlayermanager

encompass-cs/DrawLayerManager.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -6,40 +7,45 @@ namespace Encompass
 {
     internal class DrawLayerManager
     {
+        private readonly object layerOrderLock = new object();
+
         private readonly SortedList<int, int> layerOrder = new SortedList<int, int>();
 
-        private readonly Dictionary<int, HashSet<Guid>> layerIndexToComponentIDs = new Dictionary<int, HashSet<Guid>>();
+        private readonly ConcurrentDictionary<int, ConcurrentDictionary<Guid, byte>> layerIndexToComponentIDs = new ConcurrentDictionary<int, ConcurrentDictionary<Guid, byte>>();
-        private readonly Dictionary<int, HashSet<GeneralRenderer>> layerIndexToGeneralRenderers = new Dictionary<int, HashSet<GeneralRenderer>>();
+        private readonly ConcurrentDictionary<int, ConcurrentDictionary<GeneralRenderer, byte>> layerIndexToGeneralRenderers = new ConcurrentDictionary<int, ConcurrentDictionary<GeneralRenderer, byte>>();
 
-        private readonly Dictionary<Guid, int> componentIDToLayerIndex = new Dictionary<Guid, int>();
+        private readonly ConcurrentDictionary<Guid, int> componentIDToLayerIndex = new ConcurrentDictionary<Guid, int>();
 
-        public IEnumerable<int> LayerOrder { get { return layerOrder.Values; } }
+        public IEnumerable<int> LayerOrder { get { lock(layerOrderLock) { return layerOrder.Values; } } }
 
         public void RegisterGeneralRendererWithLayer(GeneralRenderer renderer, int layer)
         {
             if (layerIndexToGeneralRenderers.ContainsKey(layer))
             {
                 var set = layerIndexToGeneralRenderers[layer];
-                set.Add(renderer);
+                set[renderer] = 0;
             }
             else
             {
-                var set = new HashSet<GeneralRenderer>();
+                var set = new ConcurrentDictionary<GeneralRenderer, byte>();
-                layerIndexToGeneralRenderers.Add(layer, set);
+                layerIndexToGeneralRenderers[layer] = set;
-                set.Add(renderer);
+                set[renderer] = 0;
             }
 
+            lock (layerOrderLock)
+            {
                 if (!layerOrder.ContainsKey(layer))
                 {
                     layerOrder.Add(layer, layer);
                 }
             }
+        }
 
         public void UnregisterGeneralRendererWithLayer(GeneralRenderer renderer, int layer)
         {
             if (layerIndexToGeneralRenderers.ContainsKey(layer))
             {
-                layerIndexToGeneralRenderers[layer].Remove(renderer);
+                layerIndexToGeneralRenderers[layer].TryRemove(renderer, out _);
             }
         }
 
@@ -54,29 +60,32 @@ namespace Encompass
             if (layerIndexToComponentIDs.ContainsKey(layer))
             {
                 var set = layerIndexToComponentIDs[layer];
-                set.Add(id);
+                set[id] = 0;
             }
             else
             {
-                var set = new HashSet<Guid>();
+                var set = new ConcurrentDictionary<Guid, byte>();
-                layerIndexToComponentIDs.Add(layer, set);
+                layerIndexToComponentIDs[layer] = set;
-                set.Add(id);
+                set[id] = 0;
             }
 
             componentIDToLayerIndex[id] = layer;
 
+            lock (layerOrderLock)
+            {
                 if (!layerOrder.ContainsKey(layer))
                 {
                     layerOrder.Add(layer, layer);
                 }
             }
+        }
 
         public void UnRegisterComponentWithLayer(Guid id)
         {
             if (componentIDToLayerIndex.ContainsKey(id))
             {
                 var layer = componentIDToLayerIndex[id];
-                layerIndexToComponentIDs[layer].Remove(id);
+                layerIndexToComponentIDs[layer].TryRemove(id, out _);
             }
         }
 
@@ -89,14 +98,14 @@ namespace Encompass
         public IEnumerable<Guid> ComponentIDsByLayer(int layer)
         {
             return layerIndexToComponentIDs.ContainsKey(layer) ?
-                layerIndexToComponentIDs[layer] :
+                layerIndexToComponentIDs[layer].Keys :
                 Enumerable.Empty<Guid>();
         }
 
         public IEnumerable<GeneralRenderer> GeneralRenderersByLayer(int layer)
         {
             return layerIndexToGeneralRenderers.ContainsKey(layer) ?
-                layerIndexToGeneralRenderers[layer] :
+                layerIndexToGeneralRenderers[layer].Keys :
                 Enumerable.Empty<GeneralRenderer>();
         }
     }