Can I lock(something) on one line in C#?

Question

Will the _otherThing field below be protected by the locks?

class ThreadSafeThing
{
    private readonly object _sync = new object();

    private SomeOtherThing _otherThing;

    public SomeOtherThing OtherThing { get { lock(_sync) return _otherThing; } }

    public void UpdateOtherThing(SomeOtherThing otherThing)
    {
        lock(_sync) _otherThing = otherThing;
    }
}

Answer 1

Hi, i am not shure i haven't done anything with threads along time but i think it won't be locked Best Regards, Iordan

Answer 2

This construction:

lock(_sync) _otherThing = otherThing;

...is the same as this construction:

lock(_sync)
{
    _otherThing = otherThing;
}

So yes, the assignment of _otherThing is protected by the lock.

Answer 3

Yes, it will be protected because the _sync object doesn't change.

Edit: The usage of the lock you have here is almost certainly not what you meant, as detailed in several other answers in this thread.

Answer 4

Yes.

This is not related to lock. C# programs are expressed using statements. Using {} groups multiple statements as a block. A block can be used in the context where a single statement is allowed. See C# language specification section 1.5.

Answer 5

As far as I know

lock(_sync)
  _otherThing = otherThing;

is the same as

lock(_sync) _otherThing = otherThing;

is the same as

lock(_sync)
{
  _otherThing = otherThing;
}

Which is similar to

if(something)
  _otherThing = otherThing;

which is the same as

if(something)
{
  _otherThing = otherThing;
}

(And by similar I mean similar in syntax, not in function. if is not the same as lock of course :p)

Actually you can use { } even without a lock, if or anything similar to group statements.

Answer 6

Your code is not thread safe, as your dealing with references.

Unless the only thing your lock is preventing is the return of the reference to your object (which is threadsafe without a lock see section 5.5 of the C# language spec) then you will not make changes to the _otherThing threadsafe.

You would need to make your mutators and accessors threadsafe in this instance (by locking around changes and reads of your object).

Answer 7

That will work. Single statements and block statements are pretty much always interchangeable in the C# syntax (except with method bodies and such).

However, it may not even be necessary to do the lock at all. If you want to prevent the property from being changed while other changes are made, then yes. If SomeOtherThing is a value type (struct), you will also need to lock it.

If you chose to not use a lock, you will need to declare the field volatile if you want to make sure your changes are visible in other threads immediately.