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

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++;
                }
          }
     }
 
}

using (var mutex = new Mutex(false, index.ToString()))
    {
        mutex.WaitOne();
 
        //write file
 
        mutex.ReleaseMutex();
    }

//...
          if (!IsMultiThreading)
          {
                 // ...
          }
          else
          {
                Monitor.Enter(Count);
                {
                    Monitor.Enter  (InternalArray[workingVal])
                    {
                         InternalArray[workingVal] = item;
                    }
                    Monitor.Exit(InternalArray[workingVal]);
 
                    Count++;
                }
                Monitor.Exit(Count);
          }
//...

public static void Enter(object obj);

    class LockTest
    {
        public void foo()
        {
            // lock (null) -- видимо смысла не имеет, т.к. в C# любой lock связан 
            // с объектом, а как просто объявить критическую секцию - 
            // код ниже с созданием спец-объекта.
             
            lock {  // эквивалентно lock(this)
 
                // допустим, один поток находится здесь
                // здесь код критической секции + залочен весь объект this
            }
        }
        public void foo1()
        {
            lock (this)
            {
                // а вот сюда другой поток не попадёт, 
                // т.к. монитор this уже выше захвачен в foo()  ! 
                // Именно это показывает что 1) вариант lock (this) - неоптимальный
            }
        }
 
        public void OtherMethod()
        {
            // другой (или много) потоков могут выполнять этот метод. 
            // Объект this залочен, но этот метод НЕ находится в блокируемом участке
        }
 
        private object foo2Lock = new object(); // спец-объект для критической секции 
        public void foo2()
        {
            lock (foo2Lock)
            {
                // третий поток может выполнять этот метод.  Но четвертый - не может,
                // пока третий не выйдет из этого блока. 
                // Т.е.,  foo2 одновременно может исполняться не более чем одним потоком. 
                // Это - 2-й вариант -- аналог C++ критической секции, и общий 
                // object foo2Lock -- был специально для неё и создан. 
 
                //  Если здесь пытаться переписывать элемент массива (как в классе, 
                //  с показанным кодом выше), т.е. 
                //
                //  InternalArray[workingVal] = item;
                // 
                //  то другие потоки, в это время не смогут переписывать элементы 
                //  массива структур, с другим  workingVal - именно с этом 
                //  неоптимальность этого, 2-го варианта! 
                // Хотя он лучше чем 1-й вариант  с lock (this) выше. 
 
            }
        }
    }

//...
                    lock (InternalArray[workingVal])
                    {
                         InternalArray[workingVal] = item;
                    }
//...

public class DynamicArrayIncreasing<T> where T : struct 
{
     // ... 
 
     public ulong Count { get; protected set; }
     public T[] InternalArray { get; set; }
 
     public pointer[] InternalPointers { get; set; }  // pointer - указатель на структуру длиной 8 байт
 
     public void AddOrReplace(ref T item , int index)
     {
          ulong workingVal = 0;
          // ... define workingVal
 
          if (!IsMultiThreading)
          {
                 // ...
          }
          else
          {
                //  блок Add.. 
 
                // блок Replace --> 
                lock (InternalArray[workingVal])
                {
                       InternalArray[workingVal] = item;
                }
                
          }
     }
 
        public T this[ulong index]
        {
            // ... define workingVal 
            get
            {
                return InternalArray[workingVal];
            }
        }
 
}

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

  
 
public interface ISizeDefinable
{
        ulong SizeOf();
}
  
 
// здесь используем struct  или class 
 
public struct MyEntity : ISizeDefinable
    {
        public ulong data0;
        public ulong data1;
        public ulong data2;
        public ulong data3;
        public ulong data4;
 
        public ulong SizeOf()
        {
            return 40UL;    // размер в байтах 
        }
    }
 
//  затем создаём объект 
 
MyEntity[] ent = null; //
 
private void btnBuild_Click(object sender, EventArgs e)
{
            // если структура (закомментируем всё кроме строки ниже), то Commit size  
            // в  Task Manager-e  ==  800500 КБ, что 40  байт на 1 структуру класса MyEntity
            MyEntity[] ent = new MyEntity[20000001];
 
 
            // если класс (закомментируем строку выше, откомментируем все ниже) , то Commit size
            //   в   ~Task Manager-e ==  ~1297000 КБ, что 66  байт на 1 объект класса MyEntity
            ent = new MyEntity[20000001];
            for (int i = 0; i < 20000001; i++ )
            {
                ent[i] = new MyEntity();
                ent[i].data4 = 22;
            }
}

     private readonly object _sync = new object();
     public void AddOrReplace(ref T item , int index)
     {
          ulong workingVal = 0;
          // ... define workingVal
 
          if (!IsMultiThreading)
          {
                 // ...
          }
          else
          {
                lock(_sync)
                {
                    InternalArray[workingVal] = item;
                    Count++;
                }
          }
     }