Strong typing improvements on the persistence seam

src/NServiceBus.AcceptanceTesting/AcceptanceTestingPersistence/AcceptanceTestingPersistence.cs

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

src/NServiceBus.AcceptanceTests/Core/Outbox/When_outbox_enabled_without_persister_supporting_it.cs

@@ -19,24 +19,21 @@ public void Should_fail_to_start()
         Assert.That(exception.Message, Does.Contain("The selected persistence doesn't have support for outbox storage"));
     }
 
-    public class Context : ScenarioContext
-    {
-    }
+    public class Context : ScenarioContext;
 
     public class Endpoint : EndpointConfigurationBuilder
     {
-        public Endpoint()
-        {
+        public Endpoint() =>
             EndpointSetup<ServerWithNoDefaultPersistenceDefinitions>(c =>
             {
                 c.EnableOutbox();
                 c.ConfigureTransport().TransportTransactionMode = TransportTransactionMode.ReceiveOnly;
                 c.UsePersistence<FakeNoOutboxSupportPersistence>();
             });
-        }
     }
 
-    class FakeNoOutboxSupportPersistence : PersistenceDefinition
+    class FakeNoOutboxSupportPersistence : PersistenceDefinition, IPersistenceDefinitionFactory<FakeNoOutboxSupportPersistence>
     {
+        public static FakeNoOutboxSupportPersistence Create() => new();
     }
 }

src/NServiceBus.AcceptanceTests/Core/Persistence/When_a_persistence_does_not_provide_synchronized_storage_session.cs

@@ -6,6 +6,7 @@
 using AcceptanceTesting;
 using EndpointTemplates;
 using Extensibility;
+using Features;
 using Microsoft.Extensions.DependencyInjection;
 using NServiceBus.Persistence;
 using NUnit.Framework;
@@ -18,69 +19,58 @@ public class When_a_persistence_does_not_provide_synchronized_storage_session :
     // is not altered by Fody to throw an ObjectDisposedException if it was disposed
     [Test]
     [Repeat(2)]
-    public async Task ReceiveFeature_should_work_without_ISynchronizedStorage()
-    {
+    public async Task ReceiveFeature_should_work_without_ISynchronizedStorage() =>
         await Scenario.Define<Context>()
             .WithEndpoint<NoSyncEndpoint>(e => e.When(b => b.SendLocal(new MyMessage())))
             .Done(c => c.MessageReceived)
             .Run();
-    }
 
-    class FakeNoSynchronizedStorageSupportPersistence : PersistenceDefinition
+    class FakeNoSynchronizedStorageSupportPersistence : PersistenceDefinition, IPersistenceDefinitionFactory<FakeNoSynchronizedStorageSupportPersistence>
     {
-        public FakeNoSynchronizedStorageSupportPersistence()
+        FakeNoSynchronizedStorageSupportPersistence()
+        {
+            Supports<StorageType.Sagas, FakeStorage>();
+            Supports<StorageType.Subscriptions, FakeStorage>();
+        }
+
+        public static FakeNoSynchronizedStorageSupportPersistence Create() => new();
+
+        sealed class FakeStorage : Feature
         {
-            Supports<StorageType.Sagas>(s => { });
-            Supports<StorageType.Subscriptions>(s => { });
+            protected override void Setup(FeatureConfigurationContext context)
+            {
+            }
         }
     }
 
     class NoOpISubscriptionStorage : ISubscriptionStorage
     {
-        public Task<IEnumerable<Subscriber>> GetSubscriberAddressesForMessage(IEnumerable<MessageType> messageTypes, ContextBag context, CancellationToken cancellationToken = default)
-        {
-            return Task.FromResult<IEnumerable<Subscriber>>(null);
-        }
+        public Task<IEnumerable<Subscriber>> GetSubscriberAddressesForMessage(IEnumerable<MessageType> messageTypes, ContextBag context, CancellationToken cancellationToken = default) => Task.FromResult<IEnumerable<Subscriber>>(null);
 
-        public Task Subscribe(Subscriber subscriber, MessageType messageType, ContextBag context, CancellationToken cancellationToken = default)
-        {
-            return Task.CompletedTask;
-        }
+        public Task Subscribe(Subscriber subscriber, MessageType messageType, ContextBag context, CancellationToken cancellationToken = default) => Task.CompletedTask;
 
-        public Task Unsubscribe(Subscriber subscriber, MessageType messageType, ContextBag context, CancellationToken cancellationToken = default)
-        {
-            return Task.CompletedTask;
-        }
+        public Task Unsubscribe(Subscriber subscriber, MessageType messageType, ContextBag context, CancellationToken cancellationToken = default) => Task.CompletedTask;
     }
 
     class NoSyncEndpoint : EndpointConfigurationBuilder
     {
-        public NoSyncEndpoint()
-        {
+        public NoSyncEndpoint() =>
             EndpointSetup<ServerWithNoDefaultPersistenceDefinitions>(c =>
             {
                 // The subscription storage is needed because at this stage we have no way of DisablingPublishing on the non-generic version of ConfigureTransport
                 c.RegisterComponents(container => container.AddSingleton<ISubscriptionStorage, NoOpISubscriptionStorage>());
                 c.UsePersistence<FakeNoSynchronizedStorageSupportPersistence>();
             });
-        }
     }
 
-    public class MyMessageHandler : IHandleMessages<MyMessage>
+    public class MyMessageHandler(Context testContext) : IHandleMessages<MyMessage>
     {
-        public MyMessageHandler(Context context)
-        {
-            testContext = context;
-        }
-
         public Task Handle(MyMessage message, IMessageHandlerContext context)
         {
             testContext.MessageReceived = true;
 
             return Task.CompletedTask;
         }
-
-        Context testContext;
     }
 
     public class Context : ScenarioContext
@@ -89,7 +79,5 @@ public class Context : ScenarioContext
         public bool MessageReceived { get; set; }
     }
 
-    public class MyMessage : ICommand
-    {
-    }
+    public class MyMessage : ICommand;
 }

src/NServiceBus.AcceptanceTests/Core/PublishSubscribe/When_configuring_subscription_authorizer.cs

@@ -100,38 +100,25 @@ public PublisherWithAuthorizer()
         }
         class StorageAccessor : FeatureStartupTask
         {
-            public StorageAccessor(ISubscriptionStorage subscriptionStorage, Context testContext)
-            {
-                testContext.SubscriptionStorage = (FakePersistence.FakeSubscriptionStorage)subscriptionStorage;
-            }
+            public StorageAccessor(ISubscriptionStorage subscriptionStorage, Context testContext) => testContext.SubscriptionStorage = (FakePersistence.FakeSubscriptionStorage)subscriptionStorage;
 
             protected override Task OnStart(IMessageSession session, CancellationToken cancellationToken = default) => Task.CompletedTask;
 
             protected override Task OnStop(IMessageSession session, CancellationToken cancellationToken = default) => Task.CompletedTask;
         }
     }
 
-    public class AllowedEvent : IEvent
-    {
-    }
+    public class AllowedEvent : IEvent;
 
-    public class ForbiddenEvent : IEvent
-    {
-    }
+    public class ForbiddenEvent : IEvent;
 
-    class FakePersistence : PersistenceDefinition
+    class FakePersistence : PersistenceDefinition, IPersistenceDefinitionFactory<FakePersistence>
     {
-        public FakePersistence()
-        {
-            Supports<StorageType.Subscriptions>(s => s.EnableFeatureByDefault(typeof(SubscriptionStorageFeature)));
-        }
+        FakePersistence() => Supports<StorageType.Subscriptions, SubscriptionStorageFeature>();
 
         class SubscriptionStorageFeature : Feature
         {
-            protected override void Setup(FeatureConfigurationContext context)
-            {
-                context.Services.AddSingleton<ISubscriptionStorage>(new FakeSubscriptionStorage());
-            }
+            protected override void Setup(FeatureConfigurationContext context) => context.Services.AddSingleton<ISubscriptionStorage>(new FakeSubscriptionStorage());
         }
 
         public class FakeSubscriptionStorage : ISubscriptionStorage
@@ -148,5 +135,7 @@ public Task Subscribe(Unicast.Subscriptions.MessageDrivenSubscriptions.Subscribe
 
             public Task<IEnumerable<Unicast.Subscriptions.MessageDrivenSubscriptions.Subscriber>> GetSubscriberAddressesForMessage(IEnumerable<MessageType> messageTypes, ContextBag context, CancellationToken cancellationToken = default) => throw new NotImplementedException();
         }
+
+        public static FakePersistence Create() => new();
     }
 }

src/NServiceBus.AcceptanceTests/Core/Routing/MessageDrivenSubscriptions/Pub_from_sendonly.cs

@@ -6,14 +6,15 @@
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 using NServiceBus;
-using NServiceBus.AcceptanceTesting;
-using NServiceBus.AcceptanceTests.EndpointTemplates;
-using NServiceBus.Extensibility;
-using NServiceBus.Features;
+using AcceptanceTesting;
+using EndpointTemplates;
+using Extensibility;
+using Features;
 using NServiceBus.Persistence;
-using NServiceBus.Unicast.Subscriptions;
+using Unicast.Subscriptions;
 using NServiceBus.Unicast.Subscriptions.MessageDrivenSubscriptions;
 using NUnit.Framework;
+using Settings;
 using Conventions = AcceptanceTesting.Customization.Conventions;
 
 public class Pub_from_sendonly : NServiceBusAcceptanceTest
@@ -39,88 +40,65 @@ public class Context : ScenarioContext
 
     public class SendOnlyPublisher : EndpointConfigurationBuilder
     {
-        public SendOnlyPublisher()
-        {
+        public SendOnlyPublisher() =>
             EndpointSetup<DefaultPublisher>(b =>
             {
                 b.SendOnly();
-                b.UsePersistence(typeof(HardCodedPersistence));
+                b.UsePersistence<HardCodedPersistence>();
                 b.DisableFeature<AutoSubscribe>();
             }, metadata => metadata.RegisterSelfAsPublisherFor<MyEvent>(this));
-        }
     }
 
     public class Subscriber : EndpointConfigurationBuilder
     {
-        public Subscriber()
-        {
-            EndpointSetup<DefaultServer>(c => c.DisableFeature<AutoSubscribe>());
-        }
+        public Subscriber() => EndpointSetup<DefaultServer>(c => c.DisableFeature<AutoSubscribe>());
 
-        public class MyHandler : IHandleMessages<MyEvent>
+        public class MyHandler(Context testContext) : IHandleMessages<MyEvent>
         {
-            public MyHandler(Context context)
-            {
-                testContext = context;
-            }
-
             public Task Handle(MyEvent messageThatIsEnlisted, IMessageHandlerContext context)
             {
                 testContext.SubscriberGotTheEvent = true;
 
                 return Task.CompletedTask;
             }
-
-            Context testContext;
         }
     }
 
 
-    public class MyEvent : IEvent
-    {
-    }
+    public class MyEvent : IEvent;
 
-    public class HardCodedPersistence : PersistenceDefinition
+    public class HardCodedPersistence : PersistenceDefinition, IPersistenceDefinitionFactory<HardCodedPersistence>
     {
-        internal HardCodedPersistence()
-        {
-            Supports<StorageType.Subscriptions>(s => s.EnableFeatureByDefault<HardCodedPersistenceFeature>());
-        }
+        HardCodedPersistence() => Supports<StorageType.Subscriptions, HardCodedPersistenceFeature>();
+
+        public static HardCodedPersistence Create() => new();
     }
 
-    public class HardCodedPersistenceFeature : Feature
+    class HardCodedPersistenceFeature : Feature
     {
-        protected override void Setup(FeatureConfigurationContext context)
-        {
-            context.Services.AddSingleton(typeof(ISubscriptionStorage), typeof(HardcodedSubscriptionManager));
-        }
+        protected override void Setup(FeatureConfigurationContext context) =>
+            context.Services.AddSingleton<ISubscriptionStorage, HardcodedSubscriptionManager>();
     }
 
-    public class HardcodedSubscriptionManager : ISubscriptionStorage
+    class HardcodedSubscriptionManager : ISubscriptionStorage
     {
-        public HardcodedSubscriptionManager()
-        {
-            addressTask = Task.FromResult(new[]
-            {
-                new Unicast.Subscriptions.MessageDrivenSubscriptions.Subscriber(Conventions.EndpointNamingConvention(typeof(Subscriber)), null)
-            }.AsEnumerable());
-        }
-
-        public Task Subscribe(Unicast.Subscriptions.MessageDrivenSubscriptions.Subscriber subscriber, MessageType messageType, ContextBag context, CancellationToken cancellationToken = default)
-        {
-            return Task.CompletedTask;
-        }
+        public Task Subscribe(Unicast.Subscriptions.MessageDrivenSubscriptions.Subscriber subscriber,
+            MessageType messageType, ContextBag context, CancellationToken cancellationToken = default) =>
+            Task.CompletedTask;
 
-        public Task Unsubscribe(Unicast.Subscriptions.MessageDrivenSubscriptions.Subscriber subscriber, MessageType messageType, ContextBag context, CancellationToken cancellationToken = default)
-        {
-            return Task.CompletedTask;
-        }
+        public Task Unsubscribe(Unicast.Subscriptions.MessageDrivenSubscriptions.Subscriber subscriber,
+            MessageType messageType, ContextBag context, CancellationToken cancellationToken = default) =>
+            Task.CompletedTask;
 
-        public Task<IEnumerable<Unicast.Subscriptions.MessageDrivenSubscriptions.Subscriber>> GetSubscriberAddressesForMessage(IEnumerable<MessageType> messageTypes, ContextBag context, CancellationToken cancellationToken = default)
-        {
-            return addressTask;
-        }
+        public Task<IEnumerable<Unicast.Subscriptions.MessageDrivenSubscriptions.Subscriber>>
+            GetSubscriberAddressesForMessage(IEnumerable<MessageType> messageTypes, ContextBag context,
+                CancellationToken cancellationToken = default) => addressTask;
 
-        Task<IEnumerable<Unicast.Subscriptions.MessageDrivenSubscriptions.Subscriber>> addressTask;
+        readonly Task<IEnumerable<Unicast.Subscriptions.MessageDrivenSubscriptions.Subscriber>> addressTask =
+            Task.FromResult(new[]
+            {
+                new Unicast.Subscriptions.MessageDrivenSubscriptions.Subscriber(
+                    Conventions.EndpointNamingConvention(typeof(Subscriber)), null)
+            }.AsEnumerable());
     }
 }

src/NServiceBus.AcceptanceTests/Recoverability/Cross_q_tx_msg_moved_to_error_q.cs

@@ -1,7 +1,6 @@
 namespace NServiceBus.AcceptanceTests.Recoverability;
 
 using System;
-using System.Linq;
 using System.Threading.Tasks;
 using AcceptanceTesting;
 using AcceptanceTesting.Customization;