Is a readonly field in C# thread safe?

Question

Is a readonly field in C# thread safe?

public class Foo
{
  private readonly int _someField;

  public Foo()
  {
    _someField = 0;
  }

  public Foo(int someField)
  {
    _someField = someField;
  }

  public void SomeMethod()
  {
     doSomething(_someField);
  }
}

Have gone through some posts:

• What are the benefits to marking a field as readonly in C#? - JaredPar suggests that readonly fields once constructed are immutable and hence safe.
• Readonly Fields and Thread Safety, suggests that there is some risk if constructors do a lot of work.

So, if the readonly field is used as in the code above, and constructors are light, is it thread-safe? What if _someField is a referrence type (e.g. an array of strings)?

Answer 1

Yes - your code doesn't expose this within either constructor, so no other code can "see" the object before it's been fully constructed. The .NET memory model (as of .NET 2) includes a write barrier at the end of every constructor (IIRC - search Joe Duffy's blog posts for more details) so there's no risk of another thread seeing a "stale" value, as far as I'm aware.

I'd personally still usually use a property instead, as a way of separating implementation from API, but from a thread-safety point of view it's fine.

Answer 2

That depends what's in the field.

Reading from a readonly field, or from any field that is smaller than the word length (including all reference types) is an atomic operation.

However, the object inside the readonly field may or may not be thread-safe.

Answer 3

Not looking at your example but in general it depends what is readonly applied to, for example if dictionary is declared readonly you can still update keyvalue pairs