Odtnhj

Assume a class SomeClass with private static field like this. The access to this field is synchronized using lock.

private static SomeClass _instance
private static object _sync = new object();

public static SomeClass Instance 

 get 
 
 lock (_sync)
 
 if (_instance == null)
 
 _instance = Create();
 
 return _instance; 
 
 

When another code from different thread will try to set the value of this variable to e.g. null using reflection, will the lock prevent this and let the reflection call wait until the lock was released?

E.g. something like this:

Type type = typeof(SomeClass);
string fieldName = "_instance";
object value = null;
FieldInfo field = type.GetField(fieldName, true);
field.SetValue(null, value);

No, lock will not prevent any access that does not go through locking the same resource. Since reflection will not go through lock, you will get race conditions.
Here is (slightly different from your code but nontheless doing same thing) what I mean→

void SetOne()
 lock (_sync)
 critical_element = SOME_VALUE;
 


void SetTwo()
 critical_element = SOME_ANOTHER_VALUE;

Above definitely has race conditions.

Here is my understanding behind the OP's question. I think OP wants to use Singleton pattern and here is a very nice and thread safe implementation. You do not need to deal with locks either. However, some bad users might still set the backing field using reflection.

public sealed class Singleton

 private static readonly Lazy<Singleton> lazy = new Lazy<Singleton>(() => new Singleton());

 public static Singleton Instance get return lazy.Value; 

 private Singleton()