Как правильно залочить структуру в массиве?

public struct MyEntity 
{
        public ulong data0;
        public ulong data1;
        public ulong data2;
        public ulong data3;
        public ulong data4;
}

public class DynamicArrayIncreasing<T> where T : struct 
{
     // ... 
 
     public ulong Count { get; protected set; }
     public T[] InternalArray { get; set; }
 
     public void AddOrReplace(ref T item , int index)
     {
          ulong workingVal = 0;
          // ... define workingVal
 
          if (!IsMultiThreading)
          {
                 // ...
          }
          else
          {
                lock(Count)
                {
                    lock (InternalArray[workingVal])
                    {
                         InternalArray[workingVal] = item;
                    }
                    Count++;
                }
          }
     }
 
}

     public void AddOrReplace(ref T item , int index)
     {
          ulong workingVal = 0;
          // ... define workingVal
 
          if (!IsMultiThreading)
          {
                 // ...
          }
          else
          {
                //  блок Add.. 
 
                // блок Replace --> 
                lock (InternalArray[workingVal])
                {
                       InternalArray[workingVal] = item;
                }
                
          }
     }

        const int factor = 101;
        var syncObjects = Enumerable.Range(0, factor).Select(i => new object()).ToArray();
        
        ....
 
        // блок Replace --> 
        lock (syncObjects[workingVal % factor])
        {
            InternalArray[workingVal] = item;
        }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace Algorithmictree._0.Common
{
 
    
    public interface ISizeDefinable
    {
        long SizeOfBytes();
    }
        
    
    public class DynamicNode<T> where T : struct, ISizeDefinable
    {
        public T[] internalArray { get; set; }
 
        public const long Capacity = 10000;
        // 10 000 - выделяем такими блоками. Т.к. тип  используется в основном для 
        // DynamicArrayIncreasing<T> where T : struct, ISizeDefinable  
        // где T - структуры размером от 16 байт (2 ulong) , до структур размером 64 байта (8 ulong), 
        // это СПЕЦИФИКА ЗАДАЧ, решаемых даннми классами, (хотя DynamicArrayIncreasing можно использовать 
        // и для любых структур, любых размеров. ) . Поскольку для основных задач зачем создается класс - 
        // максимумальная структура может именть размером 64 байта (это 8 ulong), то 
        // максимум на создание этого первого массива, будет не более  64 байта умноженное  на 10 тысяч, 
        // равно 640 килобайт, что совсем несущественно для переборной задачи, (т.е. стартовый размер первого блока
        // где гарантированно выделится память будет равен - будет равно 640 КБ ) а  динамический массив может 
        // далее увеличиваться так, что будет занимать многие ГБ оперативной памяти! 
        // В случае если, будут использоваться структуры размером даже в 10 килобайт, всё равно, тогда 
        // стартовый размер в памяти, первого блока, будет порядно 100 МБ, что также не существенно, 
        // если данный код пишется для переборных задач где подразумеваются многие гигабайты используемой памяти. 
 
 
        public DynamicNode()
        {
            internalArray = new T[Capacity];
        }
    }   // class DynamicNode<T>
 
 
 
 
    // 1) МНОГОПОТОЧНО-безопасный DynamicArrayIncreasing. 
    // 2) особенность -  элементы в массив только добавляются не удаляются. 
    // Increasing - означает возрастающий, и убывать не может.  
    // Но  есть возможность и ЗАМЕНИТЬ существующий элемент, этого достаточно лдя алгоритмических задач перебора,
    // т.е. будет известно, какие лишние элементы ("дырки" в массиве), которые где угодно в середине массива 
    // можно перезаписать. 
    public class DynamicArrayIncreasing<T> where T : struct, ISizeDefinable
    {
 
        public bool IsMultiThreading { get; protected set; }
 
        public const long MaxCapacity = 100000000000L;
        // 100 миллиардов максимум элементов, которые может содержать класс DynamicArrayIncreasing
        // а  так как внутренний блок занимает 10 000 элементов , то всего необходимых блоков равно 100 млрд / 10 тысяч ==  10000000 (10 млн)
        // каждый блок - это просто ссылка (8 байт) на объект (ссылочный тип, а объект - массив) - доп. расходы памяти на старте программы, 
        // составят эти 80 МБ . 
 
        protected DynamicNode<T>[] externalArray { get; set; }
        protected T defaultExemplar;
 
        
        private long count;  
        //     значение  текущего  количества элементов в массиве. 
        // 1. Если читается-пишется _Count совместно с перезаписью некоего элемента во внутренних массивах, (метод Add например), 
        //    то блокировать нужно весь объект  DynamicArrayIncreasing , т.е. lock(this) , потому что два объекта должны быть 
        //    обработаны как атомарная операция, нельзя чтобы например, элемент массива перезаписался, потом поток остановился, 
        //    а затем другой поток читает устаревшее и некорректное значение _Count 
        // 2. Если же для каких то целей, нужно только прочитать или изменить значение _Count , не меняя  при этом больше ничего, 
        //    для этого ниже есть Property, в котором чтение и запись происходит как атомарная операция с Interlocked, 
        //    потому что иначе, операции с long - вообще говоря, не являются атомарными.         
 
            
        public long Count
        {
            get
            {                
                long location = 0;
 
                // location = count;
                Interlocked.Exchange(ref location, count);
 
                //return count;
                return location;
            }
            protected set
            {
                //count = value;
                Interlocked.Exchange(ref count, value);
            }
        }
 
 
        // constructor 
        public DynamicArrayIncreasing(bool isMultiThreading = true)
        {
            IsMultiThreading = isMultiThreading;  // по умолчанию многопоточно-безопасный. 
 
            count = 0;
            externalArray = new DynamicNode<T>[10000000L];
            // 10.000.000 внешних  elements массивов. (по 10 000 элементов в каждом может быть позже - см выше) 
 
            defaultExemplar = default(T);
        }   // constructor 
 
        
 
        public long SizeOfMegabytes
        {
            get
            {
                long sizeOfExemplar = (defaultExemplar as ISizeDefinable).SizeOfBytes();
                long countElements = Count;
 
                long countFilledBlocks = countElements / 10000L;   //  10 тысяч - наш объект  DynamicNode<T> 
                long sizeInBytes = (countFilledBlocks * 10000L * sizeOfExemplar ) + (8L * 10000000L) + (12L * countFilledBlocks);
 
                // При старте программы, вся занимаемая память будет равна 80 МБ, плюс то что по первому слагаемому - 
                // зависит от размера струткруры, 10 000 умножить на размер структуры. 
                // в формуле все слагаемые и мнодители имеют тип long, потому и числовые - это литералы с буквой L . 
                // при старте программы - выделяется 10000000L (10 млн) ссылок ипа DynamicNode<T> в объекте-массиве  externalArray , 
                // и каждая такая ссылка, имеет размер 8 байт, до того как по ней выделится новый объект - внутренний массив. 
                // Также, в начале countFilledBlocks == 1, а потому, в массиве externalArray один элемент получит
                // дополнительные 12 байт. 
                // После того как массив externalArray полностью заполнится объектами , на каждый countFilledBlocks добавится 12 байт,
                // доп. затраты на объект по сравнению с пустой ссылкой = 12 байт. 
                // (На объект идёт в 64-битной системе, кроме  8 на саму ссылку на объект уже выше определенной, 
                // ещё 4 на синк. блок + 8 на хедер .)  Поэтому если заполнятся все countFilledBlocks реальными объектами,  т.е. 
                // countFilledBlocks == 10000000L , последние два слагаемые будут равны 20 байтам умноженным на 10 млн, т.е. 200 МБ - 
                // это максимум памяти, на доп. расходы. 
                // Но это ничто по сравнению сравнению с гигабайтами-терабайтами реальных данных, которые будут использщоваться при переборе. 
                // Первое же слагаемое понятно - сами струткруры занимают sizeOfExemplar байт, каждый новый блок - в 10 000 раз больше, 
                // и самих блоков countFilledBlocks может быть до 10 млн. 
 
                long sizeOfMegabytes = sizeInBytes / 1048576;
                return sizeOfMegabytes;
            }
        }   // public long SizeOfMegabytes
 
 
        public void Add(ref T item)
        {
            // почему в Add - см. выше. Изменяются два объекта, нужно делать как атомарную операцию.
            // а могут измняться даже три объекта, в случае если ещё и выделяться новый блок-массив. 
 
            if (IsMultiThreading)
                Monitor.Enter(this);  // аналог lock(this)
            {
                long count = Count;  // атомарное стение Property Count 
                long workingBlock = count / 100000L;
                long workingVal = count % 100000L;
 
                // если понадобился новый блок .
                if (workingVal == 0)
                {
                    externalArray[workingBlock] = new DynamicNode<T>();
                }
 
                externalArray[workingBlock].internalArray[workingVal] = item;
                
                Count++;
            }   // lock 
 
            if (IsMultiThreading)
                Monitor.Exit(this);  // аналог lock(this)
 
        }   // public void Add(T item)
 
 
 
        // 1) Решил через индексатор не делать, т.к. в set приходит value, которое является структурой, в значит 
        // скорее всего это value - переписывается (доп расходы на переписывание полей струткрур), а потом 
        // повторно должно переписаться в элемент массива (который тоже является структурой). 
        // Данный же метод Replace - получает ref  - т.е. ссылку на структуру, которая была определена где-то
        // в стеке вызывающего метода, потому лишнего копирования полей структуры не происходит, оно происходит 
        // только один рах - при записи в массив , т.е. в internalArray [...]
        // 2) ОБЯЗАТЕЛЬНОЕ условие - параметр long index - должен быть МЕНЬШЕ чем Count ! Т.е. перезаписываемый 
        // элемент должен уже существовать в массиве. 
        public void Replace(ref T item, long index)
        {
            long workingBlock = index / 10000L;            
 
            // блокировать полностью this не обязательно, производительнее заблокировать только один объект 
            // внутреннего массива, чтобы другие потоки могли работать  с другими блоками при перезаписи. 
 
            if (IsMultiThreading)
                Monitor.Enter(externalArray[workingBlock].internalArray );  // аналог lock(...) 
            
            {
                long workingVal = index % 10000L;
                externalArray[workingBlock].internalArray[workingVal] = item;
            }
 
            if (IsMultiThreading)
                Monitor.Exit(externalArray[workingBlock].internalArray);
 
 
        }   // public void Replace(ref T item, long index)
        
 
 
        // индексатор - только GET - по выше описанной причине. (см Replace метод)
        public T this[long index]
        {
            get
            {
                // чтение элемента массива, который есть струтктура, как и запись - 
                // должно быть атомарной операцией, чтобы не получилось, что один поток 
                // записывает структуру, в то же время как другой поток её читает. 
                // Так можно прочитать "грязные данные", т.е. некоторые устаревшие поля 
                // в структуре. 
 
                T retValue = default(T);
 
                long workingBlock = index / 100000L;
 
                if (IsMultiThreading)
                    Monitor.Enter(externalArray[workingBlock].internalArray);  // аналог lock(...) 
                {
                    long workingVal = index % 100000L;
                    retValue = externalArray[workingBlock].internalArray[workingVal];
                }
                if (IsMultiThreading)
                    Monitor.Exit(externalArray[workingBlock].internalArray);  // аналог lock(...) 
 
 
 
                return retValue;
            }
        }
 
 
    }   //class DynamicArrayIncreasing<T> where T : struct, ISizeDefinable
 
 
    
 
}