Usage of braces without definition of function, struct etc

Question

While analysing of Orchard.cms source code, I've found interesting code, when brackets in C# were used not for definition of any internal object. Seem it was made for some context usage. Can you please clarify what's goal of using brackets like this?

Here is code sample of it:

 builder.RegisterType<DefaultOrchardHost>().As<IOrchardHost>().As<IEventHandler>().SingleInstance();
 {
     builder.RegisterType<ShellSettingsManager>().As<IShellSettingsManager>().SingleInstance();

     builder.RegisterType<ShellContextFactory>().As<IShellContextFactory>().SingleInstance();
     {
         builder.RegisterType<ShellDescriptorCache>().As<IShellDescriptorCache>().SingleInstance();

         builder.RegisterType<CompositionStrategy>().As<ICompositionStrategy>().SingleInstance();
         {
             builder.RegisterType<ShellContainerRegistrations>().As<IShellContainerRegistrations>().SingleInstance();
             builder.RegisterType<ExtensionLoaderCoordinator>().As<IExtensionLoaderCoordinator>().SingleInstance();
             builder.RegisterType<ExtensionMonitoringCoordinator>().As<IExtensionMonitoringCoordinator>().SingleInstance();
             builder.RegisterType<ExtensionManager>().As<IExtensionManager>().SingleInstance();
             {
                 builder.RegisterType<ExtensionHarvester>().As<IExtensionHarvester>().SingleInstance();
                 builder.RegisterType<ModuleFolders>().As<IExtensionFolders>().SingleInstance()
                     .WithParameter(new NamedParameter("paths", new[] { "~/Modules" }));
                 builder.RegisterType<CoreModuleFolders>().As<IExtensionFolders>().SingleInstance()
                     .WithParameter(new NamedParameter("paths", new[] { "~/Core" }));
                 builder.RegisterType<ThemeFolders>().As<IExtensionFolders>().SingleInstance()
                     .WithParameter(new NamedParameter("paths", new[] { "~/Themes" }));

                 builder.RegisterType<CoreExtensionLoader>().As<IExtensionLoader>().SingleInstance();
                 builder.RegisterType<ReferencedExtensionLoader>().As<IExtensionLoader>().SingleInstance();
                 builder.RegisterType<PrecompiledExtensionLoader>().As<IExtensionLoader>().SingleInstance();
                 builder.RegisterType<DynamicExtensionLoader>().As<IExtensionLoader>().SingleInstance();
                 builder.RegisterType<RawThemeExtensionLoader>().As<IExtensionLoader>().SingleInstance();
             }
         }

         builder.RegisterType<ShellContainerFactory>().As<IShellContainerFactory>().SingleInstance();
     }

     builder.RegisterType<DefaultProcessingEngine>().As<IProcessingEngine>().SingleInstance();
 }

Naming: These are brackets: `[]` These are parenthesis: `()` These are braces: `{}` These are chevrons: `<>` — Matthew Watson, Jul 26 '13 at 13:01

lightbricko · Accepted Answer · 2013-07-26T13:21:58.040

5

The goal in this case is only to make it easier for a developer/human to understand how the types relate hierarchically when reading the code in order to easier understand the code.

(Using curly braces like this will indent the lines in most IDE's, such as Visual Studio)

edited Jul 26 '13 at 13:21

answered Jul 26 '13 at 12:17

lightbricko

2,649
15
21

H H · Answer 2 · 2013-07-26T12:23:09.923

4

Can you please clarify what's goal of using brackets like this?

They are simply blocks. They form a scope, as in :

Method1(1);

{
   int i = 1;  // i is local to this {} block
   Method1(i++);
}
// Here i does not exist any more

Note that the block is in no way related to the previous statement, the lack of empty lines in your sample can be misleading.

But in the posted code, no variables are declared. So they are completely superfluous. ~~I guess they are left over from some code pre-processing.~~

edited Jul 26 '13 at 12:23

answered Jul 26 '13 at 12:15

H H

263,252
30
330
514

Already edited. I think @lightbrick has the idea. They are completely cosmetic in this case. – H H Jul 26 '13 at 12:19
At first I thought that they are used for some context, but later understood, that using builder from Autofac already manages lifetime of objects created within this brackets. So I guess that it's really just for indent purpose. – Johnny_D Jul 26 '13 at 12:23

score 1 · Answer 3 · answered Jul 26 '13 at 12:19

It is simply an organizational thing in this instance. The curly braces create a scope, so that any variables declared inside the brackets are local to that block of code. So that's the normal purpose for them.

That said, in the example you give, there's nothing declared in any of them. In this case, the Orchard folks are just doing it as an organizational method to make the code easier to understand. I'm guessing if you look at the classes in the example you gave, you'd see that they are related in a hierarchical manner similar to the way they are grouped by the curly braces.

Usage of braces without definition of function, struct etc

3 Answers3