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();
 }

Answer 1

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)

Answer 2

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.

Answer 3

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.