Local functions in C# 7.0

One of new features of C# 7.0 is support for local functions. Local functions are methods that are defined inside other methods to simplify more complex code and by example to support local recursion. This blog post shows how to use local functions in C# 7.0 and gives some advice in context of technical design of code.

To illustrate local function I will use finding of factorial as an example.

class Program
{
    static void Main(string[] args)
    {
        var i = 6;
 
        int Factorial(int n)
        {
            if (n == 0)
                return 1;
            else
                return n * Factorial(n - 1);
        }
 
        Console.WriteLine(Factorial(i));
        Console.ReadLine();
    }
}

Now one may ask why I use recursive call for factorial as it is not so efficient as using for-loop? Let’s move to for-loop.

class Program
{
    static void Main(string[] args)
    {
        var i = 6;
 
        int Factorial(int n)
        {
            var result = n;
 
            for (var counter = n - 1; counter >= 1; counter--)
            {
                result = result * counter;
            }
 
            return result;
        }
 
        Console.WriteLine(Factorial(i));
        Console.ReadLine();
    }
}

Now we have more effective method for finding factorials. But it is a simple for-loop. Why should we put it local function?

I think it’s good idea in the means of technical design. This for-loop has one concrete meaning – find the factorial – and this is why I prefer to communicate this fact to developer who is working on the code after me.

How to organize the code?

Now let’s see where we should put local functions in our methods. What I suggest here is my personal opinion. Most important part of every method is method body. So, this is coming as first thing. As we name local functions with informative and descriptive names we can keep these functions in the bottom part of method.

To illustrate my idea the modified version of factorial example is here.

class Program
{
    static void Main(string[] args)
    {
        // method body
        if(args.Length == 0)
        {
            Console.WriteLine("Missing argument: input value as integer");
            return;
        }
 
        var i = int.Parse(args[0]);
       
        Console.WriteLine(Factorial(i));
        Console.ReadLine();
 
        // local functions
        int Factorial(int n)
        {
            var result = n;
 
            for (var counter = n - 1; counter >= 1; counter--)
            {
                result = result * counter;
            }
 
            return result;
        }
    }
}

Now we have code organized and we benefit from this little trick if we use it everywhere in our codebase where local functions are used.

Some considerations of local functions

Some things to keep in mind when considering local functions:

1. Local functions are part of methods where they are defined and they should not contain any system-wide logic.
2. Local functions are not visible to other classes and therefore they are tested as unit with methods that own them.
3. Use local functions only if there is real need for this.
4. Don’t over-use local functions as you may end up with too long methods that are hard to test.

Wrapping up

Local functions are nice feature in C# 7.0 and there are situations where local functions help us to write cleaner code. Still local functions are not a thing to use to shorten or reorganize the code that doesn’t need them. This can heppen when working with spaghetti code. Consider well if local function is needed before going with this and try it out if it seems like solution. Be aware that local functions are not testable as they are considered to be same local unit with containing method.