compile time warnings fixed

marcwittke · marcwittke · commit 864bfacdca98 · 2021-08-26T15:44:35.000-03:00
ICanFlush vs. IPersistenceSession
diff --git a/src/abstractions/Backend.Fx/Environment/MultiTenancy/TenantActivated.cs b/src/abstractions/Backend.Fx/Environment/MultiTenancy/TenantActivated.cs
@@ -2,8 +2,8 @@
 {
     public class TenantActivated : TenantStatusChanged
     {
-        public TenantActivated(int tenantId, string name, string description, bool isDemoTenant) 
-            : base(tenantId, name, description, isDemoTenant)
+        public TenantActivated(string name, string description, bool isDemoTenant) 
+            : base(name, description, isDemoTenant)
         {
         }
     }
diff --git a/src/abstractions/Backend.Fx/Environment/MultiTenancy/TenantDeactivated.cs b/src/abstractions/Backend.Fx/Environment/MultiTenancy/TenantDeactivated.cs
@@ -2,8 +2,8 @@
 {
     public class TenantDeactivated : TenantStatusChanged
     {
-        public TenantDeactivated(int tenantId, string name, string description, bool isDemoTenant)
-            : base(tenantId, name, description, isDemoTenant)
+        public TenantDeactivated(string name, string description, bool isDemoTenant)
+            : base(name, description, isDemoTenant)
         {
         }
     }
diff --git a/src/abstractions/Backend.Fx/Environment/MultiTenancy/TenantService.cs b/src/abstractions/Backend.Fx/Environment/MultiTenancy/TenantService.cs
@@ -64,7 +64,7 @@ public TenantId CreateTenant(string name, string description, bool isDemonstrati
             var tenant = new Tenant(name, description, isDemonstrationTenant) {Configuration = configuration};
             _tenantRepository.SaveTenant(tenant);
             var tenantId = new TenantId(tenant.Id);
-            _messageBus.Publish(new TenantActivated(tenant.Id, tenant.Name, tenant.Description, tenant.IsDemoTenant));
+            _messageBus.Publish(new TenantActivated(tenant.Name, tenant.Description, tenant.IsDemoTenant));
             return tenantId;
         }
 
@@ -74,7 +74,7 @@ public void ActivateTenant(TenantId tenantId)
             Tenant tenant = _tenantRepository.GetTenant(tenantId);
             tenant.State = TenantState.Active;
             _tenantRepository.SaveTenant(tenant);
-            _messageBus.Publish(new TenantActivated(tenant.Id, tenant.Name, tenant.Description, tenant.IsDemoTenant));
+            _messageBus.Publish(new TenantActivated(tenant.Name, tenant.Description, tenant.IsDemoTenant));
         }
 
         public void DeactivateTenant(TenantId tenantId)
@@ -83,7 +83,7 @@ public void DeactivateTenant(TenantId tenantId)
             Tenant tenant = _tenantRepository.GetTenant(tenantId);
             tenant.State = TenantState.Inactive;
             _tenantRepository.SaveTenant(tenant);
-            _messageBus.Publish(new TenantDeactivated(tenant.Id, tenant.Name, tenant.Description, tenant.IsDemoTenant));
+            _messageBus.Publish(new TenantDeactivated(tenant.Name, tenant.Description, tenant.IsDemoTenant));
         }
 
         public void DeleteTenant(TenantId tenantId)
diff --git a/src/abstractions/Backend.Fx/Environment/MultiTenancy/TenantStatusChanged.cs b/src/abstractions/Backend.Fx/Environment/MultiTenancy/TenantStatusChanged.cs
@@ -4,7 +4,7 @@ namespace Backend.Fx.Environment.MultiTenancy
 {
     public abstract class TenantStatusChanged : IntegrationEvent
     {
-        protected TenantStatusChanged(int tenantId, string name, string description, bool isDemoTenant) : base(tenantId)
+        protected TenantStatusChanged(string name, string description, bool isDemoTenant)
         {
             Name = name;
             Description = description;
diff --git a/src/abstractions/Backend.Fx/Environment/Persistence/IPersistenceSession.cs b/src/abstractions/Backend.Fx/Environment/Persistence/IPersistenceSession.cs
@@ -0,0 +1,15 @@
+using System.Security.Principal;
+using Backend.Fx.Environment.DateAndTime;
+using Backend.Fx.Patterns.DependencyInjection;
+
+namespace Backend.Fx.Environment.Persistence
+{
+    public interface IPersistenceSession : ICanFlush
+    {
+        ICurrentTHolder<IIdentity> IdentityHolder { get; }
+        
+        IClock Clock { get; }
+
+        void MakeReadonly();
+    }
+}
diff --git a/src/abstractions/Backend.Fx/Patterns/DataGeneration/DataGenerated.cs b/src/abstractions/Backend.Fx/Patterns/DataGeneration/DataGenerated.cs
@@ -6,9 +6,5 @@ namespace Backend.Fx.Patterns.DataGeneration
     /// Will appear on the message bus when the data generation process has been completed
     /// </summary>
     public class DataGenerated : IntegrationEvent
-    {
-        public DataGenerated(int tenantId) : base(tenantId)
-        {
-        }
-    }
+    { }
 }
diff --git a/src/abstractions/Backend.Fx/Patterns/DataGeneration/GenerateDataOnBoot.cs b/src/abstractions/Backend.Fx/Patterns/DataGeneration/GenerateDataOnBoot.cs
@@ -61,14 +61,14 @@ private void SeedDataForAllActiveTenants()
                 foreach (TenantId prodTenantId in prodTenantIds)
                 {
                     DataGenerationContext.SeedDataForTenant(prodTenantId, false);
-                    _application.MessageBus.Publish(new DataGenerated(prodTenantId.Value));
+                    _application.MessageBus.Publish(new DataGenerated());
                 }
 
                 var demoTenantIds = _tenantIdProvider.GetActiveDemonstrationTenantIds();
                 foreach (TenantId demoTenantId in demoTenantIds)
                 {
                     DataGenerationContext.SeedDataForTenant(demoTenantId, true);
-                    _application.MessageBus.Publish(new DataGenerated(demoTenantId.Value));
+                    _application.MessageBus.Publish(new DataGenerated());
                 }
             }
         }
diff --git a/src/abstractions/Backend.Fx/Patterns/DependencyInjection/Pure/ScopedServices.cs b/src/abstractions/Backend.Fx/Patterns/DependencyInjection/Pure/ScopedServices.cs
@@ -21,7 +21,7 @@ namespace Backend.Fx.Patterns.DependencyInjection.Pure
     /// It is very useful in testing scenarios.</remarks>
     public interface IScopedServices : IDisposable
     {
-        ICanFlush CanFlush { get; }
+        IPersistenceSession PersistenceSession { get; }
         AdjustableClock Clock { get; }
         IDomainEventAggregator EventAggregator { get; }
         IMessageBusScope MessageBusScope { get; }
@@ -34,7 +34,7 @@ public interface IScopedServices : IDisposable
     public abstract class ScopedServices : IScopedServices
     {
         private readonly Assembly[] _domainAssemblies;
-        private readonly Lazy<ICanFlush> _canFlush;
+        private readonly Lazy<IPersistenceSession> _persistenceSession;
         private bool _doAutoFlush = true;
 
         protected ScopedServices(
@@ -48,10 +48,12 @@ protected ScopedServices(
             TenantIdHolder = CurrentTenantIdHolder.Create(tenantId);
             IdentityHolder = CurrentIdentityHolder.Create(identity);
             CorrelationHolder = new CurrentCorrelationHolder();
-            _canFlush = new Lazy<ICanFlush>(CreateCanFlush);
+            _persistenceSession = new Lazy<IPersistenceSession>(() => CreatePersistenceSession());
         }
 
-        public ICanFlush CanFlush => _canFlush.Value;
+        public ICanFlush CanFlush => _persistenceSession.Value;
+        
+        public IPersistenceSession PersistenceSession => _persistenceSession.Value;
 
         public ICurrentTHolder<TenantId> TenantIdHolder { get; }
 
@@ -96,7 +98,7 @@ public T GetRandom<T>() where T : AggregateRoot
 
         public void Flush()
         {
-            CanFlush.Flush();
+            PersistenceSession.Flush();
         }
 
         public void Complete()
@@ -150,9 +152,9 @@ protected object GetAggregateAuthorization(ICurrentTHolder<IIdentity> identityHo
                     continue;
                 }
 
-                constructorParameterTypes[i] = ProvideInstance(constructorParameterTypes[i].ParameterType);
+                constructorParameters[i] = ProvideInstance(constructorParameterTypes[i].ParameterType);
 
-                if (constructorParameterTypes[i] == null)
+                if (constructorParameters[i] == null)
                 {
                     throw new InvalidOperationException($"No implementation for {constructorParameterTypes[i].ParameterType.Name} provided");
                 }
@@ -170,6 +172,6 @@ protected virtual void Dispose(bool disposing)
         {
         }
 
-        protected abstract ICanFlush CreateCanFlush();
+        protected abstract IPersistenceSession CreatePersistenceSession();
     }
 }
diff --git a/src/environments/Backend.Fx.AspNetCore/BackendFxApplicationStartup.cs b/src/environments/Backend.Fx.AspNetCore/BackendFxApplicationStartup.cs
@@ -5,6 +5,7 @@
 using Backend.Fx.Patterns.DependencyInjection;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Mvc.Controllers;
+using Microsoft.AspNetCore.Mvc.ViewComponents;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 
@@ -17,8 +18,8 @@ public static void AddBackendFxApplication<THostedService>(this IServiceCollecti
         {
             services.AddSingleton<THostedService>();
             services.AddSingleton<IHostedService>(provider => provider.GetRequiredService<THostedService>());
-            services.AddSingleton(provider => provider.GetRequiredService<THostedService>().Application);
             services.AddSingleton<IControllerActivator, BackendFxApplicationControllerActivator>();
+            services.AddSingleton<IViewComponentActivator, BackendFxApplicationViewComponentActivator>();
         }
 
         public static void UseBackendFxApplication<THostedService, TTenantMiddleware>(this IApplicationBuilder app)
@@ -28,19 +29,23 @@ public static void UseBackendFxApplication<THostedService, TTenantMiddleware>(th
 
             app.Use(async (context, requestDelegate) =>
             {
-                IBackendFxApplication application = app.ApplicationServices.GetRequiredService<THostedService>().Application;
-                application.WaitForBoot();
-
-                // set the instance provider for the controller activator
-                context.SetCurrentInstanceProvider(application.CompositionRoot.InstanceProvider);
-
                 // the ambient tenant id has been set before by a TenantMiddleware
                 var tenantId = context.GetTenantId();
 
                 // the invoking identity has been set before by an AuthenticationMiddleware
                 IIdentity actingIdentity = context.User.Identity;
+                
+                IBackendFxApplication application = app.ApplicationServices.GetRequiredService<THostedService>().Application;
+                application.WaitForBoot();
+
+                await application.AsyncInvoker.InvokeAsync(ip =>
+                {
+                    // set the instance provider for activators being called inside the requestDelegate (everything related to MVC
+                    // for example, like ControllerActivator and ViewComponentActivator etc.)
+                    context.SetCurrentInstanceProvider(ip);
 
-                await application.AsyncInvoker.InvokeAsync(_ => requestDelegate.Invoke(), actingIdentity, tenantId);
+                    return requestDelegate.Invoke();
+                }, actingIdentity, tenantId);
             });
         }
     }
diff --git a/src/implementations/Backend.Fx.EfCorePersistence/EfCorePersistenceSession.cs b/src/implementations/Backend.Fx.EfCorePersistence/EfCorePersistenceSession.cs
@@ -15,14 +15,24 @@
 
 namespace Backend.Fx.EfCorePersistence
 {
-    public class EfFlush : ICanFlush
+    public class EfCorePersistenceSession : IPersistenceSession
     {
-        private static readonly ILogger Logger = LogManager.Create<EfFlush>();
+        private static readonly ILogger Logger = LogManager.Create<EfCorePersistenceSession>();
+        private bool _isReadonly;
         public DbContext DbContext { get; }
+    
         public ICurrentTHolder<IIdentity> IdentityHolder { get; }
         public IClock Clock { get; }
+        
+        public void MakeReadonly()
+        {
+            Logger.Debug("Making this DbContext readonly. Changes won't be detected when flushing.");
+            DbContext.ChangeTracker.AutoDetectChangesEnabled = false;
+            DbContext.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
+            _isReadonly = true;
+        }
 
-        public EfFlush(DbContext dbContext, ICurrentTHolder<IIdentity> identityHolder, IClock clock)
+        public EfCorePersistenceSession(DbContext dbContext, ICurrentTHolder<IIdentity> identityHolder, IClock clock)
         {
             DbContext = dbContext;
             Logger.Debug("Disabling auto detect changes on this DbContext. Changes will be detected explicitly when flushing.");
@@ -33,6 +43,12 @@ public EfFlush(DbContext dbContext, ICurrentTHolder<IIdentity> identityHolder, I
 
         public void Flush()
         {
+            if (_isReadonly)
+            {
+                Logger.Info("skipping flush because this instance was marked as readonly");
+                return;
+            }
+            
             DetectChanges();
             UpdateTrackingProperties();
             DbContext.TraceChangeTrackerState();
diff --git a/src/implementations/Backend.Fx.EfCorePersistence/EfCoreScopedServices.cs b/src/implementations/Backend.Fx.EfCorePersistence/EfCoreScopedServices.cs
@@ -56,7 +56,7 @@ private object GetRepository(Type aggregateRootType)
             Type efRepositoryType = typeof(EfRepository<>).MakeGenericType(aggregateRootType);
             return Activator.CreateInstance(
                 efRepositoryType,
-                ((EfFlush)CanFlush).DbContext,
+                ((EfCorePersistenceSession)CanFlush).DbContext,
                 GetAggregateMapping(aggregateRootType),
                 TenantIdHolder,
                 aggregateAuthorization);
diff --git a/src/implementations/Backend.Fx.InMemoryPersistence/InMemoryFlush.cs b/src/implementations/Backend.Fx.InMemoryPersistence/InMemoryFlush.cs
diff --git a/src/implementations/Backend.Fx.InMemoryPersistence/InMemoryPersistenceSession.cs b/src/implementations/Backend.Fx.InMemoryPersistence/InMemoryPersistenceSession.cs
@@ -0,0 +1,26 @@
+using System.Security.Principal;
+using Backend.Fx.Environment.DateAndTime;
+using Backend.Fx.Environment.Persistence;
+using Backend.Fx.Patterns.DependencyInjection;
+
+namespace Backend.Fx.InMemoryPersistence
+{
+    public class InMemoryPersistenceSession : IPersistenceSession
+    {
+        public InMemoryPersistenceSession(ICurrentTHolder<IIdentity> identityHolder, AdjustableClock clock)
+        {
+            IdentityHolder = identityHolder;
+            Clock = clock;
+        }
+
+        public void Flush()
+        { }
+
+        public ICurrentTHolder<IIdentity> IdentityHolder { get; }
+        
+        public IClock Clock { get; }
+        
+        public void MakeReadonly()
+        { }
+    }
+}
diff --git a/src/implementations/Backend.Fx.InMemoryPersistence/InMemoryScopedServices.cs b/src/implementations/Backend.Fx.InMemoryPersistence/InMemoryScopedServices.cs
@@ -19,9 +19,9 @@ protected InMemoryScopedServices(IClock clock, IIdentity identity, TenantId tena
             _inMemoryStores = inMemoryStores;
         }
 
-        protected override ICanFlush CreateCanFlush()
+        protected override IPersistenceSession CreatePersistenceSession()
         {
-            return new InMemoryFlush();
+            return new InMemoryPersistenceSession(IdentityHolder, Clock);
         }
 
         public override IRepository<TAggregateRoot> GetRepository<TAggregateRoot>()
diff --git a/tests/Backend.Fx.EfCorePersistence.Tests/DummyImpl/Persistence/TestScopedServices.cs b/tests/Backend.Fx.EfCorePersistence.Tests/DummyImpl/Persistence/TestScopedServices.cs
@@ -21,9 +21,9 @@ public TestScopedServices(TestDbContext dbContext, IClock clock, IIdentity ident
         
         public override IMessageBusScope MessageBusScope { get; } = A.Fake<IMessageBusScope>();
         
-        protected override ICanFlush CreateCanFlush()
+        protected override IPersistenceSession CreatePersistenceSession()
         {
-            return new EfFlush(DbContext, IdentityHolder, Clock);
+            return new EfCorePersistenceSession(DbContext, IdentityHolder, Clock);
         }
     }
 }
diff --git a/tests/Backend.Fx.RabbitMq.Tests/TheRabbitMqMessageBus.cs b/tests/Backend.Fx.RabbitMq.Tests/TheRabbitMqMessageBus.cs
@@ -75,12 +75,12 @@ public void Handle(TestIntegrationEvent eventData)
 
         public class TestIntegrationEvent : IntegrationEvent
         {
-            public TestIntegrationEvent(int sequencenumber) : base(999)
+            public TestIntegrationEvent(int sequenceNumber)
             {
-                Sequencenumber = sequencenumber;
+                SequenceNumber = sequenceNumber;
             }
 
-            public int Sequencenumber { get; }
+            public int SequenceNumber { get; }
         }
     }
 }
diff --git a/tests/Backend.Fx.SimpleInjectorDependencyInjection.Tests/DummyImpl/ASimpleDomain/AnIntegrationEvent.cs b/tests/Backend.Fx.SimpleInjectorDependencyInjection.Tests/DummyImpl/ASimpleDomain/AnIntegrationEvent.cs
@@ -6,7 +6,7 @@ namespace Backend.Fx.SimpleInjectorDependencyInjection.Tests.DummyImpl.ASimpleDo
     [UsedImplicitly]
     public class AnIntegrationEvent : IntegrationEvent
     {
-        public AnIntegrationEvent(int tenantId, int whatever) : base(tenantId)
+        public AnIntegrationEvent(int whatever)
         {
             Whatever = whatever;
         }
diff --git a/tests/Backend.Fx.SimpleInjectorDependencyInjection.Tests/TheSimpleInjectorCompositionRoot.cs b/tests/Backend.Fx.SimpleInjectorDependencyInjection.Tests/TheSimpleInjectorCompositionRoot.cs
@@ -160,9 +160,9 @@ public void CanProvideEventHandlers()
                 domainEventAggregator.RaiseEvents();
             }
             
-            Assert.True(aDomainEvent.HandledBy.Contains(typeof(ADomainEventHandler1)));
-            Assert.True(aDomainEvent.HandledBy.Contains(typeof(ADomainEventHandler2)));
-            Assert.True(aDomainEvent.HandledBy.Contains(typeof(ADomainEventHandler3)));
+            Assert.Contains(typeof(ADomainEventHandler1), aDomainEvent.HandledBy);
+            Assert.Contains(typeof(ADomainEventHandler2), aDomainEvent.HandledBy);
+            Assert.Contains(typeof(ADomainEventHandler3), aDomainEvent.HandledBy);
         }
         
         public void Dispose()
diff --git a/tests/Backend.Fx.Tests/Patterns/EventAggregation/Domain/TestIntegrationEvent.cs b/tests/Backend.Fx.Tests/Patterns/EventAggregation/Domain/TestIntegrationEvent.cs
@@ -6,7 +6,7 @@ namespace Backend.Fx.Tests.Patterns.EventAggregation.Domain
     [UsedImplicitly]
     public class TestIntegrationEvent : IntegrationEvent
     {
-        public TestIntegrationEvent(int whatever, int tenantId) : base(tenantId)
+        public TestIntegrationEvent(int whatever)
         {
             Whatever = whatever;
         }
diff --git a/tests/Backend.Fx.Tests/Patterns/EventAggregation/Integration/TestIntegrationEvent.cs b/tests/Backend.Fx.Tests/Patterns/EventAggregation/Integration/TestIntegrationEvent.cs
@@ -5,7 +5,7 @@ namespace Backend.Fx.Tests.Patterns.EventAggregation.Integration
 {
     public class TestIntegrationEvent : IntegrationEvent
     {
-        public TestIntegrationEvent(int intParam, string stringParam) : base(55)
+        public TestIntegrationEvent(int intParam, string stringParam)
         {
             IntParam = intParam;
             StringParam = stringParam;
diff --git a/tests/Backend.Fx.Tests/Patterns/EventAggregation/Integration/TheMessageBusScope.cs b/tests/Backend.Fx.Tests/Patterns/EventAggregation/Integration/TheMessageBusScope.cs
diff --git a/tests/Backend.Fx.Tests/Patterns/MultiTenancy/TheTenantService.cs b/tests/Backend.Fx.Tests/Patterns/MultiTenancy/TheTenantService.cs

Original file line number	Diff line number	Diff line change
`@@ -2,8 +2,8 @@`
`2`	`2`	`{`
`3`	`3`	`public class TenantActivated : TenantStatusChanged`
`4`	`4`	`{`
`5`		`- public TenantActivated(int tenantId, string name, string description, bool isDemoTenant)`
`6`		`- : base(tenantId, name, description, isDemoTenant)`
	`5`	`+ public TenantActivated(string name, string description, bool isDemoTenant)`
	`6`	`+ : base(name, description, isDemoTenant)`
`7`	`7`	`{`
`8`	`8`	`}`
`9`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,8 +2,8 @@`
`2`	`2`	`{`
`3`	`3`	`public class TenantDeactivated : TenantStatusChanged`
`4`	`4`	`{`
`5`		`- public TenantDeactivated(int tenantId, string name, string description, bool isDemoTenant)`
`6`		`- : base(tenantId, name, description, isDemoTenant)`
	`5`	`+ public TenantDeactivated(string name, string description, bool isDemoTenant)`
	`6`	`+ : base(name, description, isDemoTenant)`
`7`	`7`	`{`
`8`	`8`	`}`
`9`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ namespace Backend.Fx.Environment.MultiTenancy`
`4`	`4`	`{`
`5`	`5`	`public abstract class TenantStatusChanged : IntegrationEvent`
`6`	`6`	`{`
`7`		`- protected TenantStatusChanged(int tenantId, string name, string description, bool isDemoTenant) : base(tenantId)`
	`7`	`+ protected TenantStatusChanged(string name, string description, bool isDemoTenant)`
`8`	`8`	`{`
`9`	`9`	`Name = name;`
`10`	`10`	`Description = description;`
Original file line number	Diff line number	Diff line change
`@@ -61,14 +61,14 @@ private void SeedDataForAllActiveTenants()`
`61`	`61`	`foreach (TenantId prodTenantId in prodTenantIds)`
`62`	`62`	`{`
`63`	`63`	`DataGenerationContext.SeedDataForTenant(prodTenantId, false);`
`64`		`- _application.MessageBus.Publish(new DataGenerated(prodTenantId.Value));`
	`64`	`+ _application.MessageBus.Publish(new DataGenerated());`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`var demoTenantIds = _tenantIdProvider.GetActiveDemonstrationTenantIds();`
`68`	`68`	`foreach (TenantId demoTenantId in demoTenantIds)`
`69`	`69`	`{`
`70`	`70`	`DataGenerationContext.SeedDataForTenant(demoTenantId, true);`
`71`		`- _application.MessageBus.Publish(new DataGenerated(demoTenantId.Value));`
	`71`	`+ _application.MessageBus.Publish(new DataGenerated());`
`72`	`72`	`}`
`73`	`73`	`}`
`74`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ namespace Backend.Fx.Patterns.DependencyInjection.Pure`
`21`	`21`	`/// It is very useful in testing scenarios.</remarks>`
`22`	`22`	`public interface IScopedServices : IDisposable`
`23`	`23`	`{`
`24`		`- ICanFlush CanFlush { get; }`
	`24`	`+ IPersistenceSession PersistenceSession { get; }`
`25`	`25`	`AdjustableClock Clock { get; }`
`26`	`26`	`IDomainEventAggregator EventAggregator { get; }`
`27`	`27`	`IMessageBusScope MessageBusScope { get; }`
`@@ -34,7 +34,7 @@ public interface IScopedServices : IDisposable`
`34`	`34`	`public abstract class ScopedServices : IScopedServices`
`35`	`35`	`{`
`36`	`36`	`private readonly Assembly[] _domainAssemblies;`
`37`		`- private readonly Lazy<ICanFlush> _canFlush;`
	`37`	`+ private readonly Lazy<IPersistenceSession> _persistenceSession;`
`38`	`38`	`private bool _doAutoFlush = true;`
`39`	`39`
`40`	`40`	`protected ScopedServices(`
`@@ -48,10 +48,12 @@ protected ScopedServices(`
`48`	`48`	`TenantIdHolder = CurrentTenantIdHolder.Create(tenantId);`
`49`	`49`	`IdentityHolder = CurrentIdentityHolder.Create(identity);`
`50`	`50`	`CorrelationHolder = new CurrentCorrelationHolder();`
`51`		`- _canFlush = new Lazy<ICanFlush>(CreateCanFlush);`
	`51`	`+ _persistenceSession = new Lazy<IPersistenceSession>(() => CreatePersistenceSession());`
`52`	`52`	`}`
`53`	`53`
`54`		`- public ICanFlush CanFlush => _canFlush.Value;`
	`54`	`+ public ICanFlush CanFlush => _persistenceSession.Value;`
	`55`	`+`
	`56`	`+ public IPersistenceSession PersistenceSession => _persistenceSession.Value;`
`55`	`57`
`56`	`58`	`public ICurrentTHolder<TenantId> TenantIdHolder { get; }`
`57`	`59`
`@@ -96,7 +98,7 @@ public T GetRandom<T>() where T : AggregateRoot`
`96`	`98`
`97`	`99`	`public void Flush()`
`98`	`100`	`{`
`99`		`- CanFlush.Flush();`
	`101`	`+ PersistenceSession.Flush();`
`100`	`102`	`}`
`101`	`103`
`102`	`104`	`public void Complete()`
`@@ -150,9 +152,9 @@ protected object GetAggregateAuthorization(ICurrentTHolder<IIdentity> identityHo`
`150`	`152`	`continue;`
`151`	`153`	`}`
`152`	`154`
`153`		`- constructorParameterTypes[i] = ProvideInstance(constructorParameterTypes[i].ParameterType);`
	`155`	`+ constructorParameters[i] = ProvideInstance(constructorParameterTypes[i].ParameterType);`
`154`	`156`
`155`		`- if (constructorParameterTypes[i] == null)`
	`157`	`+ if (constructorParameters[i] == null)`
`156`	`158`	`{`
`157`	`159`	`throw new InvalidOperationException($"No implementation for {constructorParameterTypes[i].ParameterType.Name} provided");`
`158`	`160`	`}`
`@@ -170,6 +172,6 @@ protected virtual void Dispose(bool disposing)`
`170`	`172`	`{`
`171`	`173`	`}`
`172`	`174`
`173`		`- protected abstract ICanFlush CreateCanFlush();`
	`175`	`+ protected abstract IPersistenceSession CreatePersistenceSession();`
`174`	`176`	`}`
`175`	`177`	`}`