scoped methods and variables

[lazyloader]

basically this

public class Foo
    {
         {
         int x = 43;      // can only be used in this scope
         void Bar() { }  // can only be used in this scope
         }

        void Baz()
            {
            // can't use x or Bar
            }
    }

this will make code more simple and easy to understand. by using this scope blocks to hide members from the other parts of the class.

[svick]

I don't understand, if the rest of the code can't use x or Bar, how are they useful?

[stakx]

This already works just as you'd expect if you move that block from the type level into the block of a type member:

public class Foo
{
    void Baz()
    {
        ...
        {
            int x = 43;
            void Bar() { }
        }
        ...
    }
}

Having that scope at the type level doesn't appear to make much sense because it's completely unclear when the code in that local scope would run. If you want it to run upon object instantiation, just put it inside the constructor:

public class Foo
{
    public Foo()
    {
        ...
        {
            int x = 43;
            void Bar() { }
        }
        ...
    }
}

Nested scopes can sometimes be useful to reduce cluttering of the outer scope with variable declarations, or to avoid name collisions.

That said, your example doesn't make much sense because you have a variable that you never use, and a local function that you never call. If I may make a suggestion, if you propose a new syntax, it would be a good idea to include a realistic example of how it would be useful, and talk people through it a little bit. 😉

[Mteheran]

@lazyloader using the new feature "local functions" in c# 7 you can create functions only visible inside the method, is more or less the same thing.

[lazyloader]

I tried to keep the example brief, so let me add more to it. Imagine this code

public class Foo
    {
         {
         int x = 43;            // can only be used in this scope
         void Bar(int z) { }  // can only be used in this scope

         void Fizz() => Bar(34);
         void Buzz() => x * 2;
         }

        void Baz()
            {
            // can't use x or Bar
            }
        void FooBar() => Buzz();   // error, Buzz() is out of scope
    }

Local functions only show themselves to one function, but these scopes, the functions are local to two or more functions, but not any outside of it, giving better encapsulation

[theunrepentantgeek]

All of your examples so far seem to show members that can't be called/referenced from anywhere at all.

So what's the point? 😕

[lazyloader]

@theunrepentantgeek That's not true. In the comment I made, Bar and x can be used anywhere in the scope of the braces, but not anywhere outside of them. How have I not made that clear?

I show Fizz using Bar and Buzz using x. That example clear as day demonstrates how it's used.

It's literally the same thing as block bodies inside methods. It's not a foriegn concept.

[Neme12]

In the comment I made, Bar and x can be used anywhere in the scope of the braces, but not anywhere outside of them.

Yes. But how will you use anything in that "scope" from the outside world? 😄

[Neme12]

It's literally the same thing as block bodies inside methods

No it's not. Control flow will enter a block through normal execution. But there's no way to execute any of the code inside that "scope" in your example.

[theunrepentantgeek]

@lazyloader, I'm trying to understand how you think this feature is supposed to work. If it was obvious from your example, I wouldn't have asked for clarification.

Here's one of your examples:

public class Foo
    {
         {
         int x = 43;            // can only be used in this scope
         void Bar(int z) { }  // can only be used in this scope

         void Fizz() => Bar(34);
         void Buzz() => x * 2;
         }

        void Baz()
            {
            // can't use x or Bar
            }
        void FooBar() => Buzz();   // error, Buzz() is out of scope
    }

The nested scope contains four members - x, Bar(int), Fizz() and Buzz().

They're all declared in exactly the same way - none of them have any explicit visibility modifiers - so I'd expect them to have the same visibility as each other.

You explicitly show that x, Bar() and Buzz() cannot be used outside the nested scope.

Can Fizz() be used outside the nested scope?

If Fizz() can be used, what's special about the declaration of Fizz() that makes it visible? How would the compiler make the decision?

If Fizz() cannot be used outside the nested scope, how do any of those members affect the state of the rest of the class? How do they contribute to the execution of the program?

[svick]

@lazyloader Maybe another way to ask the question everyone is asking would help:

Can you show a small, but complete program (i.e. including Main) that demonstrates the use of this feature?

[gulshan]

Just use a nested class-

public class Foo
{
    class Scoped
    {
        int x = 43;            // can only be used in this scope
        void Bar(int z) { }  // can only be used in this scope

        void Fizz() => Bar(34);
        int Buzz() => x * 2;
    }

    void Baz()
    {
        // can't use x or Bar
    }
    void FooBar() => Buzz();   // error, Buzz() is out of scope
}

[Unknown6656]

Considered in https://github.com/dotnet/csharplang/blob/master/meetings/2020/LDM-2020-04-01.md

[jnm2]

@Unknown6656 #140 (use backing field without naming it) was discussed in that meeting, but this issue has overlap with #133 (declare normal fields with property scope) which is a different and partially independent request.