Потокобезопасность переменной

private MyType _myProperty;
private readonly object _myPropertyLock = new object();
public MyType MyProperty
{
    get
    {
        lock(_myPropertyLock)
          return _myProperty;
 
     }
     set
     {
          lock(_myPropertyLock)
          {
               // Какой-то код
 
               _myProperty = value;
 
               // Какой-то код
          }
     }
}

private readonly List<int> _numbers = new List<int>();
 
public IEnumerable<int> Numbers
{
     get
     {
           lock(_numbers)
             return _numbers.ToList().AsReadOnly(); 
     }
}
 
public void RemoveNumber(int number)
{
     lock(_numbers)
       _numbers.Remove(number);
}
 
public void AddNumber(int number)
{
     lock(_numbers)
       _numbers.Add(number);
}

private readonly List<int> _numbers = new List<int>();
private readonly object _locker = new object();
public IEnumerable<int> Numbers
{
     get
     {
           lock(_locker)
             return _numbers.ToList().AsReadOnly(); 
     }
}
 
public void RemoveNumber(int number)
{
     lock(_locker)
       _numbers.Remove(number);
}
 
public void AddNumber(int number)
{
     lock(_locker)
       _numbers.Add(number);
}

private int _field;
public MyEnum Field  // added for convenience
{ 
  get { return (MyEnum)Interlocked.CompareExchange(ref _field, 0, 0); }
  set { Interlocked.Exchange(ref _field, (int)value); }
}

public MyEnum Field {get; set;} // Абсолютно тоже самое

int a = 20;
int b = 10;
int c;
lock(obj)
{
   с = a + b; // Две операции: сложение и присваивание. Защита нужна.
}
 
int d = c; // Одна операция. Защита не нужна.

int a;
int b;
int c;
 
// Чё-то делаем
 
lock(obj)
{ // Вот для такой группы операций защита нужна.
   a = arg1;
   b = arg2;
   с = a + b; 
}

{
    location1 += value;
    return location1;
}

{
    var prev = location1;
    if (location1.Eguals(comparand))
       location1 = value;
   return prev;
}

{
   var prev = location1;
   location1 = value;
   return prev;
}