Add feature like: "using lock(_lockObject) expression"

[Yevhen-Myroshnychenko]

How it looks now:

var lockObject = new Lock()

lock(lockObject)
{
      // some expressions
}

proposition:

var lockObject = new Lock()

using lock(lockObject)
// some expressions
// that are placed to the lock body implicitly by the compiler 

Of course, using keyword could be different, something like area, body, or block ...

[HaloFour]

See: #2451

[Yevhen-Myroshnychenko]

@HaloFour
Sure.

My idea is: I don't want to use { ... } explicitly if my lock block contains more than one expression.

2451 idea is: He wants to declare a variable or maybe a field or a property without using lock everywhere where this variable is used.

I hope that I clearly got the idea of the 2451 If not, than, maybe, that's another good idea to have option to declare local variable, class field or property, using syntax like:
lock var varName = value

[HaloFour]

That proposal still uses a lock statement, it's just that the block is implicitly scoped to the remainder of the method:

public void M() {
    var lockObject = new Lock()

    using lock(lockObject)
    // multiple expressions
}

In both cases it's about getting rid of the block.

[Yevhen-Myroshnychenko]

@HaloFour
Yes, our cases have common: "Remove {...} usage". But we have different use cases.

I think that he wants to declare local variable, class field or property, using syntax like: lock var varName = value. I think he expects that every invocation of the varName will be auto wrapped in lock(lockObject) { varName = expression} and probably this needs an implicit var lockObject = Lock() to be created. It's not so clear for me the hall idea from his example.

In my case I want different behaviour for different use case.

[Yevhen-Myroshnychenko]

@HaloFour
But it would be nice to have option to declare local variable, class field or may be property, using syntax like:

lock var varName = value

class SomeClass 
{
    lock Type somField = value;
}

were lockObject = Lock() for this use cases will be automatically created implicitly and every invocation of the somField will be automatically wrapped into lock(lockObject) { somField = ...} or lock(lockObject) { someVarible = somField}

[HaloFour]

I think that he wants to declare local variable, class field or property, using syntax like: lock var varName = value

I don't see that anywhere in their proposal. It might be suggested elsewhere in the comments, but the original post is only about eliminating the block.

Either way, I believe the answer would be the same, that lock blocks should be as short as possible so having it implicitly surround the remainder of the method is not desirable.