Local Functions In C# 7.0

Omar Maher

3y53.1k17100Article

C#C# 7 Local FunctionsGlobal functionParameter function

17 Comments

Join the conversation! Your thoughts help the community grow.

Marlon González Góngora9y ago
Thanks for sharing
- Omar Maher9y ago
  Thanks a lot :) ... .
Eman Ahmed9y ago
Nice one :)..........
Jorge Uribe9y ago
I did a test as overload, but is not supported, is that correct ?
- Omar Maher9y ago
  Yes , you can't do overload. and i think it's logical thing
Tim Tyler9y ago
Nice and clear, thanks. I think you repeat a typo throughout regarding the MyData 'Constructor' though.
- Omar Maher9y ago
  Thanks :) ,No i didn't repeat it , its different way for using variables inside constructor
abdullah Zayed9y ago
Nice ...............................................................
- Omar Maher9y ago
  Thanks :).........
Rajesh Kadam9y ago
Why do we need to create the local function if it is not going to need again..? I dont see any advantage of it.
- Aditya Rajgaria9y ago
  Local functions does not only improve the readability, but it also removes a need to create a private method which might require you to send number of parameters to and fro to reuse a value.
- diego angelino9y ago
  @Aditya Rajagaria how this could not fit exactly and only in readability case?
- Omar Maher9y ago
  Its for readability and if you will use this method just in this place ,so you should think in local functions
Waruna Manjula9y ago
Good.........................
- Omar Maher9y ago
  Thanks :) .........
Manav Pandya9y ago
Nice share ......................
- Omar Maher9y ago
  Thanks :) .............

Definition

Local functions mean you can create a function within another function, and it encapsulates completely within that function.

Features Of Local Functions In C# 7.0

Parameters and local variables from the enclosing scope are visible within the local function.

Why I should think about Local functions?

Let's think about when you need a helper function, which will be called once.

In the old days, before C# 7, you could think in 2 ways.

Create a private method inside the class and call it in the function, but that will end up having many private methods that wouldn’t be reused.
Using Func and Actions types with the anonymous methods, this solution has a limitation, like you can’t use generics, out, ref, and params.

Now, in C# 7 world, you can declare a function inside another one.

Let's take some examples.

Example 1. In the code mentioned above, we created a function GetMyName() inside the Main Function.

using System;
class Program
{
    static void Main(string[] args)
    {
        // Method calling
        GetMyName();
    }
    // Method Declaration
    static void GetMyName()
    {
        Console.WriteLine("My Name Is Omar Maher");
    }
}

Let's run it and see the result.

result

Also, you can make a calling for the local function after the declaration, as shown below.

using System;
class Program
{
    static void Main(string[] args)
    {
        // Method Declaration
        void GetMyName()
        {
            Console.WriteLine("My Name Is Omar Maher");
        }
        // Method calling
        GetMyName();
    }
}

It will give you the same result.

result

Example 2. Also, you can declare the parameter into the local function, but it will be available in the scope of GetMyName(string name), as shown.

using System;
class Program
{
    static void Main(string[] args)
    {
        // Method calling
        GetMyName("Omar Maher");
    }
    // Method Declaration
    static void GetMyName(string name)
    {
        Console.WriteLine($"My Name Is {name}");
    }
}

When you run, you will get the same result.

result

Example 3. Another example is that if you want the variable available anywhere in the Main method, you can declare the variable outside the local function, as shown.

using System;
class Program
{
    static void Main(string[] args)
    {
        string name = "Omar Maher";
        // Method calling
        GetMyName();
        // Method Declaration
        void GetMyName()
        {
            Console.WriteLine($"My Name Is {name}");
        }
    }
}

In the example, the variable name is available inside GetMyName() and outside it.

The result will be the same.

result

Example 4. Also, you can use the local functions inside the constrictors.

Let's create a class MyData and create a Constructor inside it, as shown.

class MyData
{
    public MyData()
    {
    }
}

Now, let's create a local function GetMyName() inside the MyData Constructor, as shown.

using System;
class MyData
{
    public MyData()
    {
        // Method calling
        GetMyName();

        // Method Declaration
        void GetMyName()
        {
            Console.WriteLine($"My Name Is Omar Maher");
        }
    }
}

Let's create an object from the MyData Class in the Main Method, as shown.

using System;
class MyData
{
    public MyData()
    {
        // Method Declaration
        void GetMyName()
        {
            Console.WriteLine($"My Name Is Omar Maher");
        }
    }
    static void Main(string[] args)
    {
        MyData data = new MyData();
    }
}

When we run the code, the Constructor will call GetMyName() and will continue.

The result will be the same.

result

Example 5. Also, you can send the parameters and throw the Constructor, as shown.

using System;
class MyData
{
    public MyData(string name)
    {
        // Method calling
        GetMyName();

        // Method Declaration
        void GetMyName()
        {
            Console.WriteLine($"My Name Is {name}");
        }
    }
}

Now, name the variable, and it will be available anywhere inside the Constructor.

Let's create another object.

using System;
class MyData
{
    public MyData(string name)
    {
    }
}
class Program
{
    static void Main(string[] args)
    {
        MyData data1 = new MyData("Omar Maher");
    }
}

The result will be the same.

result

You can find the source code here.

https://github.com/omarmaher100/LocalFunctions.

In the end, I hope it will help you. Wait for me for more topics.