Convert to file scoped namespaces (#6917)

src/NServiceBus.AcceptanceTesting/AcceptanceTestingPersistence/AcceptanceTestingPersistence.cs

@@ -1,26 +1,25 @@
-namespace NServiceBus
-{
-    using Features;
-    using AcceptanceTesting;
-    using Persistence;
+namespace NServiceBus;
+
+using Features;
+using AcceptanceTesting;
+using Persistence;
 
-    public class AcceptanceTestingPersistence : PersistenceDefinition
+public class AcceptanceTestingPersistence : PersistenceDefinition
+{
+    internal AcceptanceTestingPersistence()
     {
-        internal AcceptanceTestingPersistence()
+        Supports<StorageType.Sagas>(s =>
         {
-            Supports<StorageType.Sagas>(s =>
-            {
-                s.EnableFeatureByDefault<AcceptanceTestingSagaPersistence>();
-                s.EnableFeatureByDefault<AcceptanceTestingTransactionalStorageFeature>();
-            });
+            s.EnableFeatureByDefault<AcceptanceTestingSagaPersistence>();
+            s.EnableFeatureByDefault<AcceptanceTestingTransactionalStorageFeature>();
+        });
 
-            Supports<StorageType.Subscriptions>(s => s.EnableFeatureByDefault<AcceptanceTestingSubscriptionPersistence>());
+        Supports<StorageType.Subscriptions>(s => s.EnableFeatureByDefault<AcceptanceTestingSubscriptionPersistence>());
 
-            Supports<StorageType.Outbox>(s =>
-            {
-                s.EnableFeatureByDefault<AcceptanceTestingOutboxPersistence>();
-                s.EnableFeatureByDefault<AcceptanceTestingTransactionalStorageFeature>();
-            });
-        }
+        Supports<StorageType.Outbox>(s =>
+        {
+            s.EnableFeatureByDefault<AcceptanceTestingOutboxPersistence>();
+            s.EnableFeatureByDefault<AcceptanceTestingTransactionalStorageFeature>();
+        });
     }
 }

src/NServiceBus.AcceptanceTesting/AcceptanceTestingPersistence/AcceptanceTestingSynchronizedStorageSession.cs

@@ -1,95 +1,94 @@
-namespace NServiceBus.AcceptanceTesting
+namespace NServiceBus.AcceptanceTesting;
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Transactions;
+using Extensibility;
+using Outbox;
+using Persistence;
+using Transport;
+
+class AcceptanceTestingSynchronizedStorageSession : ICompletableSynchronizedStorageSession
 {
-    using System;
-    using System.Threading;
-    using System.Threading.Tasks;
-    using System.Transactions;
-    using Extensibility;
-    using Outbox;
-    using Persistence;
-    using Transport;
-
-    class AcceptanceTestingSynchronizedStorageSession : ICompletableSynchronizedStorageSession
-    {
-        public AcceptanceTestingTransaction Transaction { get; private set; }
+    public AcceptanceTestingTransaction Transaction { get; private set; }
 
-        public void Dispose() => Transaction = null;
+    public void Dispose() => Transaction = null;
 
-        public ValueTask<bool> TryOpen(IOutboxTransaction transaction, ContextBag context,
-            CancellationToken cancellationToken = default)
+    public ValueTask<bool> TryOpen(IOutboxTransaction transaction, ContextBag context,
+        CancellationToken cancellationToken = default)
+    {
+        if (transaction is AcceptanceTestingOutboxTransaction inMemOutboxTransaction)
         {
-            if (transaction is AcceptanceTestingOutboxTransaction inMemOutboxTransaction)
-            {
-                Transaction = inMemOutboxTransaction.Transaction;
-                ownsTransaction = false;
-                return new ValueTask<bool>(true);
-            }
+            Transaction = inMemOutboxTransaction.Transaction;
+            ownsTransaction = false;
+            return new ValueTask<bool>(true);
+        }
+
+        return new ValueTask<bool>(false);
+    }
 
+    public ValueTask<bool> TryOpen(TransportTransaction transportTransaction, ContextBag context,
+        CancellationToken cancellationToken = default)
+    {
+        if (!transportTransaction.TryGet(out Transaction ambientTransaction))
+        {
             return new ValueTask<bool>(false);
         }
 
-        public ValueTask<bool> TryOpen(TransportTransaction transportTransaction, ContextBag context,
-            CancellationToken cancellationToken = default)
-        {
-            if (!transportTransaction.TryGet(out Transaction ambientTransaction))
-            {
-                return new ValueTask<bool>(false);
-            }
+        Transaction = new AcceptanceTestingTransaction();
+        ambientTransaction.EnlistVolatile(new EnlistmentNotification(Transaction), EnlistmentOptions.None);
+        ownsTransaction = true;
+        return new ValueTask<bool>(true);
+    }
 
-            Transaction = new AcceptanceTestingTransaction();
-            ambientTransaction.EnlistVolatile(new EnlistmentNotification(Transaction), EnlistmentOptions.None);
-            ownsTransaction = true;
-            return new ValueTask<bool>(true);
-        }
+    public Task Open(ContextBag context, CancellationToken cancellationToken = default)
+    {
+        ownsTransaction = true;
+        Transaction = new AcceptanceTestingTransaction();
+        return Task.CompletedTask;
+    }
 
-        public Task Open(ContextBag context, CancellationToken cancellationToken = default)
+    public Task CompleteAsync(CancellationToken cancellationToken = default)
+    {
+        if (ownsTransaction)
         {
-            ownsTransaction = true;
-            Transaction = new AcceptanceTestingTransaction();
-            return Task.CompletedTask;
+            Transaction.Commit();
         }
+        return Task.CompletedTask;
+    }
 
-        public Task CompleteAsync(CancellationToken cancellationToken = default)
-        {
-            if (ownsTransaction)
-            {
-                Transaction.Commit();
-            }
-            return Task.CompletedTask;
-        }
+    public void Enlist(Action action) => Transaction.Enlist(action);
 
-        public void Enlist(Action action) => Transaction.Enlist(action);
+    bool ownsTransaction;
 
-        bool ownsTransaction;
+    sealed class EnlistmentNotification : IEnlistmentNotification
+    {
+        public EnlistmentNotification(AcceptanceTestingTransaction transaction) => this.transaction = transaction;
 
-        sealed class EnlistmentNotification : IEnlistmentNotification
+        public void Prepare(PreparingEnlistment preparingEnlistment)
         {
-            public EnlistmentNotification(AcceptanceTestingTransaction transaction) => this.transaction = transaction;
-
-            public void Prepare(PreparingEnlistment preparingEnlistment)
+            try
             {
-                try
-                {
-                    transaction.Commit();
-                    preparingEnlistment.Prepared();
-                }
-                catch (Exception ex)
-                {
-                    preparingEnlistment.ForceRollback(ex);
-                }
+                transaction.Commit();
+                preparingEnlistment.Prepared();
             }
-
-            public void Commit(Enlistment enlistment) => enlistment.Done();
-
-            public void Rollback(Enlistment enlistment)
+            catch (Exception ex)
             {
-                transaction.Rollback();
-                enlistment.Done();
+                preparingEnlistment.ForceRollback(ex);
             }
+        }
 
-            public void InDoubt(Enlistment enlistment) => enlistment.Done();
+        public void Commit(Enlistment enlistment) => enlistment.Done();
 
-            readonly AcceptanceTestingTransaction transaction;
+        public void Rollback(Enlistment enlistment)
+        {
+            transaction.Rollback();
+            enlistment.Done();
         }
+
+        public void InDoubt(Enlistment enlistment) => enlistment.Done();
+
+        readonly AcceptanceTestingTransaction transaction;
     }
 }

src/NServiceBus.AcceptanceTesting/AcceptanceTestingPersistence/AcceptanceTestingTransaction.cs

@@ -1,29 +1,28 @@
-namespace NServiceBus.AcceptanceTesting
-{
-    using System;
-    using System.Collections.Generic;
+namespace NServiceBus.AcceptanceTesting;
 
-    class AcceptanceTestingTransaction
-    {
-        public void Enlist(Action action)
-        {
-            actions.Add(action);
-        }
+using System;
+using System.Collections.Generic;
 
-        public void Commit()
-        {
-            foreach (var action in actions)
-            {
-                action();
-            }
-            actions.Clear();
-        }
+class AcceptanceTestingTransaction
+{
+    public void Enlist(Action action)
+    {
+        actions.Add(action);
+    }
 
-        public void Rollback()
+    public void Commit()
+    {
+        foreach (var action in actions)
         {
-            actions.Clear();
+            action();
         }
+        actions.Clear();
+    }
 
-        List<Action> actions = [];
+    public void Rollback()
+    {
+        actions.Clear();
     }
+
+    List<Action> actions = [];
 }

src/NServiceBus.AcceptanceTesting/AcceptanceTestingPersistence/AcceptanceTestingTransactionalStorageFeature.cs

@@ -1,14 +1,13 @@
-namespace NServiceBus.AcceptanceTesting
-{
-    using Features;
-    using Persistence;
-    using Microsoft.Extensions.DependencyInjection;
+namespace NServiceBus.AcceptanceTesting;
+
+using Features;
+using Persistence;
+using Microsoft.Extensions.DependencyInjection;
 
-    class AcceptanceTestingTransactionalStorageFeature : Feature
+class AcceptanceTestingTransactionalStorageFeature : Feature
+{
+    protected internal override void Setup(FeatureConfigurationContext context)
     {
-        protected internal override void Setup(FeatureConfigurationContext context)
-        {
-            context.Services.AddScoped<ICompletableSynchronizedStorageSession, AcceptanceTestingSynchronizedStorageSession>();
-        }
+        context.Services.AddScoped<ICompletableSynchronizedStorageSession, AcceptanceTestingSynchronizedStorageSession>();
     }
 }

src/NServiceBus.AcceptanceTesting/AcceptanceTestingPersistence/Outbox/AcceptanceTestingOutboxPersistence.cs

@@ -1,64 +1,63 @@
-namespace NServiceBus.AcceptanceTesting
+namespace NServiceBus.AcceptanceTesting;
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Features;
+using Microsoft.Extensions.DependencyInjection;
+using NServiceBus.Outbox;
+
+class AcceptanceTestingOutboxPersistence : Feature
 {
-    using System;
-    using System.Threading;
-    using System.Threading.Tasks;
-    using Features;
-    using Microsoft.Extensions.DependencyInjection;
-    using NServiceBus.Outbox;
+    public AcceptanceTestingOutboxPersistence()
+    {
+        DependsOn<Outbox>();
+        Defaults(s => s.EnableFeature(typeof(AcceptanceTestingTransactionalStorageFeature)));
+    }
 
-    class AcceptanceTestingOutboxPersistence : Feature
+    protected internal override void Setup(FeatureConfigurationContext context)
     {
-        public AcceptanceTestingOutboxPersistence()
-        {
-            DependsOn<Outbox>();
-            Defaults(s => s.EnableFeature(typeof(AcceptanceTestingTransactionalStorageFeature)));
-        }
+        var outboxStorage = new AcceptanceTestingOutboxStorage();
 
-        protected internal override void Setup(FeatureConfigurationContext context)
-        {
-            var outboxStorage = new AcceptanceTestingOutboxStorage();
+        context.Services.AddSingleton(typeof(IOutboxStorage), outboxStorage);
 
-            context.Services.AddSingleton(typeof(IOutboxStorage), outboxStorage);
+        context.RegisterStartupTask(new OutboxCleaner(outboxStorage, TimeSpan.FromDays(5)));
+    }
 
-            context.RegisterStartupTask(new OutboxCleaner(outboxStorage, TimeSpan.FromDays(5)));
+    class OutboxCleaner : FeatureStartupTask
+    {
+        public OutboxCleaner(AcceptanceTestingOutboxStorage storage, TimeSpan timeToKeepDeduplicationData)
+        {
+            this.timeToKeepDeduplicationData = timeToKeepDeduplicationData;
+            acceptanceTestingOutboxStorage = storage;
         }
 
-        class OutboxCleaner : FeatureStartupTask
+        protected override Task OnStart(IMessageSession session, CancellationToken cancellationToken = default)
         {
-            public OutboxCleaner(AcceptanceTestingOutboxStorage storage, TimeSpan timeToKeepDeduplicationData)
-            {
-                this.timeToKeepDeduplicationData = timeToKeepDeduplicationData;
-                acceptanceTestingOutboxStorage = storage;
-            }
-
-            protected override Task OnStart(IMessageSession session, CancellationToken cancellationToken = default)
-            {
-                cleanupTimer = new Timer(PerformCleanup, null, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1));
-                return Task.CompletedTask;
-            }
+            cleanupTimer = new Timer(PerformCleanup, null, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1));
+            return Task.CompletedTask;
+        }
 
-            protected override Task OnStop(IMessageSession session, CancellationToken cancellationToken = default)
+        protected override Task OnStop(IMessageSession session, CancellationToken cancellationToken = default)
+        {
+            using (var waitHandle = new ManualResetEvent(false))
             {
-                using (var waitHandle = new ManualResetEvent(false))
-                {
-                    cleanupTimer.Dispose(waitHandle);
+                cleanupTimer.Dispose(waitHandle);
 
-                    // TODO: Use async synchronization primitive
-                    waitHandle.WaitOne();
-                }
-                return Task.CompletedTask;
+                // TODO: Use async synchronization primitive
+                waitHandle.WaitOne();
             }
+            return Task.CompletedTask;
+        }
 
-            void PerformCleanup(object state)
-            {
-                acceptanceTestingOutboxStorage.RemoveEntriesOlderThan(DateTime.UtcNow - timeToKeepDeduplicationData);
-            }
+        void PerformCleanup(object state)
+        {
+            acceptanceTestingOutboxStorage.RemoveEntriesOlderThan(DateTime.UtcNow - timeToKeepDeduplicationData);
+        }
 
-            readonly AcceptanceTestingOutboxStorage acceptanceTestingOutboxStorage;
-            readonly TimeSpan timeToKeepDeduplicationData;
+        readonly AcceptanceTestingOutboxStorage acceptanceTestingOutboxStorage;
+        readonly TimeSpan timeToKeepDeduplicationData;
 
-            Timer cleanupTimer;
-        }
+        Timer cleanupTimer;
     }
 }