Did file-scoped namespaces for the entire dotnet project. Adjusted the namespaces of source files NOT in the "commands" folder. That'll be separate.

Author: MiYanni

src/Cli/dotnet/AspNetCoreCertificateGenerator.cs

@@ -3,15 +3,14 @@
 
 using Microsoft.DotNet.Configurer;
 
-namespace Microsoft.DotNet.Cli
+namespace Microsoft.DotNet.Cli;
+
+public class AspNetCoreCertificateGenerator : IAspNetCoreCertificateGenerator
 {
-    public class AspNetCoreCertificateGenerator : IAspNetCoreCertificateGenerator
+    public void GenerateAspNetCoreDevelopmentCertificate()
     {
-        public void GenerateAspNetCoreDevelopmentCertificate()
-        {
 #if !EXCLUDE_ASPNETCORE
-            AspNetCore.DeveloperCertificates.XPlat.CertificateGenerator.GenerateAspNetHttpsCertificate();
+        AspNetCore.DeveloperCertificates.XPlat.CertificateGenerator.GenerateAspNetHttpsCertificate();
 #endif
-        }
     }
 }

src/Cli/dotnet/AutomaticEncodingRestorer.cs

@@ -3,59 +3,58 @@
 
 using System.Security;
 
-namespace Microsoft.DotNet.Cli
+namespace Microsoft.DotNet.Cli;
+
+/// <summary>
+/// A program can change the encoding of the console which would affect other programs.
+/// We would prefer to have a pattern where the program does not affect encoding of other programs.
+/// Create this class in a function akin to Main and let it manage the console encoding resources to return it to the state before execution upon destruction.
+/// </summary>
+internal class AutomaticEncodingRestorer : IDisposable
 {
-    /// <summary>
-    /// A program can change the encoding of the console which would affect other programs.
-    /// We would prefer to have a pattern where the program does not affect encoding of other programs.
-    /// Create this class in a function akin to Main and let it manage the console encoding resources to return it to the state before execution upon destruction.
-    /// </summary>
-    internal class AutomaticEncodingRestorer : IDisposable
-    {
-        Encoding _originalOutputEncoding = null;
-        Encoding _originalInputEncoding = null;
+    Encoding _originalOutputEncoding = null;
+    Encoding _originalInputEncoding = null;
 
-        bool outputEncodingAccessible = false;
-        bool inputEncodingAccessible = false;
+    bool outputEncodingAccessible = false;
+    bool inputEncodingAccessible = false;
 
-        public AutomaticEncodingRestorer()
+    public AutomaticEncodingRestorer()
+    {
+        try
         {
-            try
+            if (!OperatingSystem.IsIOS() && !OperatingSystem.IsAndroid() && !OperatingSystem.IsTvOS()) // Output + Input Encoding are unavailable on these platforms per docs.
             {
-                if (!OperatingSystem.IsIOS() && !OperatingSystem.IsAndroid() && !OperatingSystem.IsTvOS()) // Output + Input Encoding are unavailable on these platforms per docs.
+                _originalOutputEncoding = Console.OutputEncoding;
+                outputEncodingAccessible = true;
+                if (!OperatingSystem.IsBrowser()) // Input Encoding is also unavailable in this platform.
                 {
-                    _originalOutputEncoding = Console.OutputEncoding;
-                    outputEncodingAccessible = true;
-                    if (!OperatingSystem.IsBrowser()) // Input Encoding is also unavailable in this platform.
-                    {
-                        _originalInputEncoding = Console.InputEncoding;
-                        inputEncodingAccessible = true;
-                    }
+                    _originalInputEncoding = Console.InputEncoding;
+                    inputEncodingAccessible = true;
                 }
             }
-            catch (Exception ex) when (ex is IOException || ex is SecurityException)
-            {
-                // The encoding is unavailable. Do nothing.
-            }
         }
+        catch (Exception ex) when (ex is IOException || ex is SecurityException)
+        {
+            // The encoding is unavailable. Do nothing.
+        }
+    }
 
-        public void Dispose()
+    public void Dispose()
+    {
+        try
         {
-            try
+            if (outputEncodingAccessible)
             {
-                if (outputEncodingAccessible)
-                {
-                    Console.OutputEncoding = _originalOutputEncoding;
-                }
-                if (inputEncodingAccessible)
-                {
-                    Console.InputEncoding = _originalInputEncoding;
-                }
+                Console.OutputEncoding = _originalOutputEncoding;
             }
-            catch (Exception ex) when (ex is IOException || ex is SecurityException)
+            if (inputEncodingAccessible)
             {
-                // The encoding is unavailable. Do nothing.
+                Console.InputEncoding = _originalInputEncoding;
             }
         }
+        catch (Exception ex) when (ex is IOException || ex is SecurityException)
+        {
+            // The encoding is unavailable. Do nothing.
+        }
     }
 }

src/Cli/dotnet/BuildServer/RazorServer.cs

@@ -1,7 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Microsoft.DotNet.CommandFactory;
+using Microsoft.DotNet.Cli.CommandFactory;
 using Microsoft.Extensions.EnvironmentAbstractions;
 
 namespace Microsoft.DotNet.Cli.BuildServer;

src/Cli/dotnet/BuildServer/VBCSCompilerServer.cs

@@ -2,8 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Reflection;
+using Microsoft.DotNet.Cli.CommandFactory;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.CommandFactory;
 using NuGet.Configuration;
 
 namespace Microsoft.DotNet.Cli.BuildServer;

src/Cli/dotnet/BundledTargetFramework.cs

@@ -5,20 +5,19 @@
 using System.Runtime.Versioning;
 using NuGet.Frameworks;
 
-namespace Microsoft.DotNet.Cli
+namespace Microsoft.DotNet.Cli;
+
+internal static class BundledTargetFramework
 {
-    internal static class BundledTargetFramework
+    public static string GetTargetFrameworkMoniker()
     {
-        public static string GetTargetFrameworkMoniker()
-        {
-            TargetFrameworkAttribute targetFrameworkAttribute = typeof(BundledTargetFramework)
-                .GetTypeInfo()
-                .Assembly
-                .GetCustomAttribute<TargetFrameworkAttribute>();
+        TargetFrameworkAttribute targetFrameworkAttribute = typeof(BundledTargetFramework)
+            .GetTypeInfo()
+            .Assembly
+            .GetCustomAttribute<TargetFrameworkAttribute>();
 
-            return NuGetFramework
-                .Parse(targetFrameworkAttribute.FrameworkName)
-                .GetShortFolderName();
-        }
+        return NuGetFramework
+            .Parse(targetFrameworkAttribute.FrameworkName)
+            .GetShortFolderName();
     }
 }

src/Cli/dotnet/CliTransaction.cs

@@ -1,114 +1,113 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-namespace Microsoft.DotNet.Cli
+namespace Microsoft.DotNet.Cli;
+
+internal interface ITransactionContext
 {
-    internal interface ITransactionContext
-    {
-        public void AddRollbackAction(Action action);
+    public void AddRollbackAction(Action action);
+
+    //  Add an action which will be run at the end of the transaction, whether it succeeds or not (after any rollback actions, if applicable)
+    public void AddCleanupAction(Action action);
+}
+
+internal class CliTransaction
+{
+    //  Delegate called when rollback starts, mainly in order to print a log message
+    public Action RollbackStarted { get; set; }
 
-        //  Add an action which will be run at the end of the transaction, whether it succeeds or not (after any rollback actions, if applicable)
-        public void AddCleanupAction(Action action);
+    //  Delegate called when rollback fails.  If set, exception will be passed to the delegate, but not rethrown
+    public Action<Exception> RollbackFailed { get; set; }
+
+    public static void RunNew(Action<ITransactionContext> action)
+    {
+        new CliTransaction().Run(action);
     }
 
-    internal class CliTransaction
+    public void Run(Action<ITransactionContext> action, Action rollback)
     {
-        //  Delegate called when rollback starts, mainly in order to print a log message
-        public Action RollbackStarted { get; set; }
+        Run(context =>
+        {
+            context.AddRollbackAction(rollback);
 
-        //  Delegate called when rollback fails.  If set, exception will be passed to the delegate, but not rethrown
-        public Action<Exception> RollbackFailed { get; set; }
+            action(context);
+        });
+    }
 
-        public static void RunNew(Action<ITransactionContext> action)
+    public void Run(Action<ITransactionContext> action)
+    {
+        TransactionContext transactionContext = new();
+        try
         {
-            new CliTransaction().Run(action);
+            action(transactionContext);
         }
-
-        public void Run(Action<ITransactionContext> action, Action rollback)
+        catch (Exception)
         {
-            Run(context =>
-            {
-                context.AddRollbackAction(rollback);
-
-                action(context);
-            });
-        }
+            //  Roll back transaction
+            RollbackStarted?.Invoke();
 
-        public void Run(Action<ITransactionContext> action)
-        {
-            TransactionContext transactionContext = new();
-            try
-            {
-                action(transactionContext);
-            }
-            catch (Exception)
+            transactionContext.RollbackActions.Reverse();
+            foreach (var rollbackAction in transactionContext.RollbackActions)
             {
-                //  Roll back transaction
-                RollbackStarted?.Invoke();
-
-                transactionContext.RollbackActions.Reverse();
-                foreach (var rollbackAction in transactionContext.RollbackActions)
+                try
+                {
+                    rollbackAction();
+                }
+                catch (Exception ex)
                 {
-                    try
+                    if (RollbackFailed != null)
                     {
-                        rollbackAction();
+                        RollbackFailed(ex);
                     }
-                    catch (Exception ex)
+                    else
                     {
-                        if (RollbackFailed != null)
-                        {
-                            RollbackFailed(ex);
-                        }
-                        else
-                        {
-                            throw;
-                        }
+                        throw;
                     }
                 }
-
-                throw;
             }
-            finally
+
+            throw;
+        }
+        finally
+        {
+            foreach (var cleanupAction in transactionContext.CleanupActions)
             {
-                foreach (var cleanupAction in transactionContext.CleanupActions)
-                {
-                    cleanupAction();
-                }
+                cleanupAction();
             }
         }
+    }
 
-        class TransactionContext : ITransactionContext
-        {
-            public List<Action> RollbackActions { get; set; } = new List<Action>();
+    class TransactionContext : ITransactionContext
+    {
+        public List<Action> RollbackActions { get; set; } = new List<Action>();
 
-            //  Actions which will be run either when the transaction completes successfully, or after rollback actions have been run
-            public List<Action> CleanupActions { get; set; } = new List<Action>();
+        //  Actions which will be run either when the transaction completes successfully, or after rollback actions have been run
+        public List<Action> CleanupActions { get; set; } = new List<Action>();
 
-            public void AddRollbackAction(Action action)
-            {
-                RollbackActions.Add(action);
-            }
+        public void AddRollbackAction(Action action)
+        {
+            RollbackActions.Add(action);
+        }
 
-            public void AddCleanupAction(Action action)
-            {
-                CleanupActions.Add(action);
-            }
+        public void AddCleanupAction(Action action)
+        {
+            CleanupActions.Add(action);
         }
     }
+}
 
-    static class CliTransactionExtensions
+static class CliTransactionExtensions
+{
+    public static void Run(this ITransactionContext context, Action action, Action rollback = null, Action cleanup = null)
     {
-        public static void Run(this ITransactionContext context, Action action, Action rollback = null, Action cleanup = null)
+        if (rollback != null)
         {
-            if (rollback != null)
-            {
-                context.AddRollbackAction(rollback);
-            }
-            if (cleanup != null)
-            {
-                context.AddCleanupAction(cleanup);
-            }
-            action();
+            context.AddRollbackAction(rollback);
+        }
+        if (cleanup != null)
+        {
+            context.AddCleanupAction(cleanup);
         }
+        action();
     }
 }

src/Cli/dotnet/CommandBase.cs

@@ -4,23 +4,22 @@
 using System.CommandLine;
 using Microsoft.DotNet.Cli.Extensions;
 
-namespace Microsoft.DotNet.Cli
-{
-    public abstract class CommandBase
-    {
-        protected ParseResult _parseResult;
+namespace Microsoft.DotNet.Cli;
 
-        protected CommandBase(ParseResult parseResult)
-        {
-            _parseResult = parseResult;
-            ShowHelpOrErrorIfAppropriate(parseResult);
-        }
+public abstract class CommandBase
+{
+    protected ParseResult _parseResult;
 
-        protected virtual void ShowHelpOrErrorIfAppropriate(ParseResult parseResult)
-        {
-            parseResult.ShowHelpOrErrorIfAppropriate();
-        }
+    protected CommandBase(ParseResult parseResult)
+    {
+        _parseResult = parseResult;
+        ShowHelpOrErrorIfAppropriate(parseResult);
+    }
 
-        public abstract int Execute();
+    protected virtual void ShowHelpOrErrorIfAppropriate(ParseResult parseResult)
+    {
+        parseResult.ShowHelpOrErrorIfAppropriate();
     }
+
+    public abstract int Execute();
 }