title: Possible to lock a {portion} of an array in C#? or have dynamic lock array?
body: <p>I have an dynamic list of objects I am tracking, and may in the future use many threads. Can someone look at this implementation for errors?</p>
  
  <p>In other words I want to track a many instances of this object:</p>
  
  <pre><code>object AzureBatchTrackerLock = new object();
  Dictionary&lt;string, List&lt;TableServiceEntity&gt;&gt; AzureBatchTracker = new Dictionary&lt;string, List&lt;TableServiceEntity&gt;&gt;();
  </code></pre>
  
  <p>My current approach is to use <code>lock</code> with dedicated objects, and List and Dictionry to handle the dynamic arrays...</p>
  
  <p><strong>BatchThread.cs</strong></p>
  
  <pre><code>/// This object itself contains a dictionary AND a lock.  
  ///  This object will ALSO be contained in a second dictionary that also has its own lock 
  public class BatchThread
  { 
     // When I perform updates to AzureBatchTracker dictionary, lock the following
    internal readonly object AzureBatchTrackerLock = new object();
    internal Dictionary&lt;string, List&lt;TableServiceEntity&gt;&gt; AzureBatchTracker = new Dictionary&lt;string, List&lt;TableServiceEntity&gt;&gt;();
  } 
  </code></pre>
  
  <p><strong>BatchProcessor.cs</strong></p>
  
  <pre><code>public class BatchProcessor
  { 
   // Class-wide scope
   readonly object _BatchEntriesLock = new object();
   Dictionary&lt;string, BatchThread&gt; _BatchEntries = new Dictionary&lt;string, BatchThread&gt;();
  
   // The "outer loop"
   public BatchThread GetAnEntry(string ThingToProcess)
   { 
       // Prepare return variable
      BatchThread foundBatchThread = null;
  
      // And then I would select an object like this:
      // Notice that I'm performing what may be a concurrent entry here
      // on a non-locked object ............................
      //  Is this a bad idea?  Should I lock?  Does it matter?
      //  If I must lock, want to exit as quickly as possible. Must not be later than the next lock() command
      var activeRow = _BatchEntries[ThingToProcess];
  
  
      // Since I have the object I care about, I'll work with the "secondary" lock object 
      // It works in practice, but I don't know what kind concurrency issues I'll run into.
      lock (activeRow.Value.AzureBatchTrackerLock)
      {
         // Add and remove from the collection 
         ActiveRow.Value.AzureBatchTracker.Add(new exampleEntry); 
  
         // Do Stuff
  
         ActiveRow.Value.AzureBatchTracker.Remove(something);
  
           foundBatchThread =  activeRow.Value.AzureBatchTracker[ThingToProcess];
       }
  
       return foundBatchThread;
     }
  
     // The inner loop
     // Called whenever the "Outer" array needs to be expanded
     public void AddNewBatchEntry(string newEntryName)
     {  
       lock (_BatchEntriesLock)
        {
           // Add placeholder to the collection
           _BatchEntries.Add( newEntryName, new BatchThread() ); 
  
            // Do Stuff
  
         }
     }
    }  
  </code></pre>
  
  <p>Do you see any flaws in this implementation?  Is there a better way?</p>