Do unnecessary curly braces reduce performance?

Question

After recently encountering this while programming, I have been wondering about this. Below are 2 snippets which are both legal and compile. Specifically, my question is this.. in the second case, do the brackets make the program slower? Also why is this allowed?

1st case:

if (statement)
{
 // do something
}

2nd case:

{
    if (statement)
    {
        // do something
    }
}

Additionally what if I had something like the code below.. Is the runtime the same as just calling function X without any of the curly brackets.

{
  {
    {
      // call function X
    }
  }
}

Answer 1

Most of the time it doesn't make any difference - and you should definitely code for readability more than anything else.

However, curly braces can have an effect on performance, in a surprising way, although it's pretty unusual. Consider this code:

using System;
using System.Collections.Generic;

class Test
{
    static void FewerCurlies()
    {
        List<Action> actions = new List<Action>();
        for (int i = 0; i < 100; i++)
        {
            int x;
            if (i % 3 == 0)
            {
                actions.Add(() => x = 10);
            }

            int y;
            if (i % 3 == 1)
            {
                actions.Add(() => y = 10);
            }
        }
    }

    static void MoreCurlies()
    {
        List<Action> actions = new List<Action>();
        for (int i = 0; i < 100; i++)
        {
            {
                int x;
                if (i % 3 == 0)
                {
                    actions.Add(() => x = 10);
                }
            }

            {
                int y;
                if (i % 3 == 1)
                {
                    actions.Add(() => y = 10);
                }
            }
        }
    }
}

The extra braces in MoreCurlies look redundant, right? Not quite... the generated code looks more like this:

using System;
using System.Collections.Generic;

class Test
{
    static void FewerCurlies()
    {
        List<Action> actions = new List<Action>();
        for (int i = 0; i < 100; i++)
        {
            FewerCurliesCapture capture = new FewerCurliesCapture();
            if (i % 3 == 0)
            {
                actions.Add(capture.Method1);
            }

            if (i % 3 == 1)
            {
                actions.Add(capture.Method2);
            }
        }
    }

    static void MoreCurlies()
    {
        List<Action> actions = new List<Action>();
        for (int i = 0; i < 100; i++)
        {
            {
                MoreCurliesCapture1 capture = new MoreCurliesCapture1();
                if (i % 3 == 0)
                {
                    actions.Add(capture.Method);
                }
            }

            {
                MoreCurliesCapture1 capture = new MoreCurliesCapture2();
                if (i % 3 == 1)
                {
                    actions.Add(capture.Method);
                }
            }
        }
    }

    private class FewerCurliesCapture
    {
        public int x;
        public int y;

        public void Method1()
        {
            x = 10;
        }

        public void Method2()
        {
            y = 10;
        }
    }

    private class MoreCurliesCapture1
    {
        public int x;

        public void Method()
        {
            x = 10;
        }
    }

    private class MoreCurliesCapture2
    {
        public int y;

        public void Method()
        {
            y = 10;
        }
    }
}

The differences here are:

• An instance of the capture class is created in each iteration of the loop in FewerCurlies, even if it's not used
• Each instance of the capture class used in FewerCurlies contains both variables, even though each delegate will only actually use one of them, whereas in MoreCurlies each capture class only captures a single variable

This is all somewhat implementation-specific, but it shows that redundant-looking curlies can have an impact.

Answer 2

Short answer is "no, they do not reduce performance".

Curly braces are needed for the compiler to determine scope of variables, and to know where the current group of statements end. Once the compiler finished processing, the code with and without the unnecessary curly braces would produce identical output.

Note that this is related to the performance of compiled code, not to the performance of the compiler itself. The compiler will take additional time to compile your code, simply because the raw size of the input is larger. However, in order for this additional time to become measurable, the number of unnecessary braces needs to be rather extreme.

Answer 3

As ever with such questions, the answer lies in the IL it generates. For the following code examples:

public int X()
{
    {
        {
            {
                return 0;
            }
        }
    }
}

public int Y()
{
    return 0;
}

We end up with the following compiled IL:

.method public hidebysig instance int32  X() cil managed
{
  // Code size       2 (0x2)
  .maxstack  8
  IL_0000:  ldc.i4.0
  IL_0001:  ret
} // end of method SomeType::X

.method public hidebysig instance int32  Y() cil managed
{
  // Code size       2 (0x2)
  .maxstack  8
  IL_0000:  ldc.i4.0
  IL_0001:  ret
} // end of method SomeType::Y

They are identical. so no, it has no affect on performance. X is horrible to read, but that's another issue.

Update {} affects the scope of variables, so perhaps this could have an effect. Again, let's check:

public int X()
{
    var i = 1;
    {
        {
            i++;
            {
                return i;
            }
        }
    }
}

public int Y()
{
    var i = 1;
    i++;
    return i;
}

Once again though, the IL produced is identical:

// Code size       8 (0x8)
.maxstack  2
.locals init ([0] int32 i)
IL_0000:  ldc.i4.1
IL_0001:  stloc.0
IL_0002:  ldloc.0
IL_0003:  ldc.i4.1
IL_0004:  add
IL_0005:  stloc.0
IL_0006:  ldloc.0
IL_0007:  ret

However if the variable is captured in a closure, it does affect things. X in the following case does create more IL, which would have an impact on performance:

public Func<int> X()
{
    {
        var i = 1;
        {
            i++;
            {
                return () => i;
            }
        }
    }
}

public Func<int> Y()
{
    var i = 1;
    i++;
    return () => i;
}

Answer 4

Unlike C++, in which the compiler may be required to generate code when variables go into or out of scope, most variables in C# are effectively hoisted to the enclosing function-level scope. The code:

void foo()
{
  {
    int i;
    ... stuff using i as int
  }
  {
    char i;
    ... stuff using i as char
  }
}

will effectively get turned into:

void foo()
{
  int i__1;
  char i__2;
  ... stuff using i__1 as int
  ... stuff using i__2 as char
}

with code from the first braced section using the first variable i__1 wherever it would have used i, and code in the second one using i__2. In some cases it is possible that declaring variables with the same name and purpose within multiple scoping blocks might generate less efficient code than declaring one variable with that common purpose in an outer scoping block, but it would rarely have a meaningful effect. In most cases the just-in-time compiler will be able to determine that multiple variables in the code can safely be mapped to the same storage location, and even in those where it can't the storage required for a few extra variables is unlikely to affect performance very much.

Answer 5

No curly braces not going to reduce performance.

Something its helpful to understnad code and provide good formating of code. But some curly braces are mandatory like function start /end,loop start/end,condition start/end and this barces also help to understand scrop of variables.

Answer 6

Its doesn't Cause any performance degradation but using curly brackets definitely increases the readability of your code. In real word scenario when you have peer code reviews or pair programming then the stuffs written by you would be much clear and readable.

Go through the following link

http://www.c-sharpcorner.com/UploadFile/d0e913/lame-question-of-the-day-role-of-curly-braces-in-our-cod/

Answer 7

Using unnecessary curly braces, assuming you have no nested variables, only adds a label to the label table during while it's converting your code to byte-code or machine code. So at worse the build time will be slower. If you have variables in the nesting you still shouldn't have problems if they are primitives which don't have destruction code but if you have objects created within the nested braces then a stronger understanding of the GC would be required, but I strongly doubt that any noticeable difference would be present. In all cases because the compiler is doing extra work by storing references in a lookup table while it builds your project, then there will be a, although probably unnoticeable, slight delay in building your project.