public void Context()
{
HttpContext.Current = FakeHttpContextHelper.GetFakeHttpContext();
var domainEventHandlerFactory = new FakeDomainEventHandlerFactory(domainEvent => _raisedDomainEvent = (TestDomainEvent)domainEvent);
DomainEvents.Initialize(domainEventHandlerFactory);
_volatileResourceManager = new VolatileResourceManager();
var unitOfWorkFactory = IoC.Resolve <IUnitOfWorkFactory>();
TransactionScopeUnitOfWorkHttpModule.Initialize(
unitOfWorkFactory: unitOfWorkFactory,
transactionScopeEnlistmentAction: transactionScope => _volatileResourceManager.EnlistIntoTransactionScope(transactionScope)
);
var transactionScopeUnitOfWorkHttpModule = new TransactionScopeUnitOfWorkHttpModule();
var httpApplication = new FakeHttpApplication();
transactionScopeUnitOfWorkHttpModule.Init(httpApplication);
httpApplication.FireBeginRequest();
_simulateApplicationTransaction();
httpApplication.FireEndRequest();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseStaticFiles();
app.UseRebus();
app.UseMiddleware <TransactionScopeUnitOfWorkDependencyInjectionMiddleware>(System.Transactions.IsolationLevel.ReadCommitted);
app.UseCookiePolicy();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
DomainEvents.Initialize(app.ApplicationServices.GetService <IDomainEventHandlerFactory>());
_BuildDatabase(app);
}
public async Task Context()
{
var specification = new TTransactionScopeUnitOfWorkMiddlewareSpecification();
var domainEventHandlerFactory = new FakeDomainEventHandlerFactory(domainEvent => _raisedDomainEvent = (TestDomainEvent)domainEvent);
DomainEvents.Initialize(domainEventHandlerFactory);
_volatileResourceManager = new VolatileResourceManager();
async Task _requestDelegate(HttpContext context)
{
_entityRepository = IoC.Resolve <IRepository <TestEntityWithDomainEvent> >();
_entity = new TestEntityWithDomainEvent();
_entity.BehaviouralMethodWithRaisingDomainEvent();
await _entityRepository.SaveAsync(_entity);
_volatileResourceManager.SetMemberValue(23);
throw new NotSupportedException("test exception");
}
try
{
await specification.CreateMiddlewareAndInvokeHandling(_requestDelegate, _volatileResourceManager);
}
catch (NotSupportedException) {}
}
public async Task Context()
{
_serviceProvider = new ServiceProviderHelper().BuildServiceProvider();
DomainEvents.Initialize(_serviceProvider.GetService <IDomainEventHandlerFactory>());
_serviceScope = _serviceProvider.CreateScope();
_unitOfWork = _serviceProvider.GetService <NhibernateUnitOfWork>();
_unitOfWork.BeginTransaction();
_shipCountBefore = _GetShipCount();
var manageShipsController = new ManageShipsControllerBuilder(_serviceProvider).Build();
var createNewShipCommand = new CreateNewShipCommand
{
ShipName = "ship name",
Tonnage = 23.4m,
ImoNumber = "IMO 12345"
};
_actionResult = await manageShipsController.CreateNewShip(createNewShipCommand);
_unitOfWork.Flush();
_unitOfWork.Clear();
}
public void Context()
{
HttpContext.Current = FakeHttpContextHelper.GetFakeHttpContext();
var domainEventHandlerFactory = new FakeDomainEventHandlerFactory(domainEvent => _raisedDomainEvent = (TestDomainEvent)domainEvent);
DomainEvents.Initialize(domainEventHandlerFactory, isDelayedDomainEventHandlingEnabled: true);
DomainEvents.ResetDelayedEventsStorage();
var unitOfWorkFactory = IoC.Resolve <IUnitOfWorkFactory>();
UnitOfWorkHttpModule.Initialize(unitOfWorkFactory);
var unitOfWorkHttpModule = new UnitOfWorkHttpModule();
var httpApplication = new FakeHttpApplication();
unitOfWorkHttpModule.Init(httpApplication);
httpApplication.FireBeginRequest();
try
{
_simulateApplicationTransactionWhichThrowsAnException();
}
catch
{
httpApplication.FireError();
}
}
public void Context()
{
DomainEvents.Initialize(A.Fake <IDomainEventHandlerFactory>());
var createNewShipCommand = new CreateNewShipCommand
{
ShipName = "ship name",
Tonnage = 23.45678m,
ImoNumber = "IMO 12345"
};
_shipRepository = A.Fake <IRepository <Ship> >();
A.CallTo(() => _shipRepository.SaveAsync(A <Ship> ._)).Invokes(x =>
{
// when shipRepository.Save() is called, simulate NHibernate assigning Id to the Ship entity
var shipPassedAsParameter = x.GetArgument <Ship>(0);
shipPassedAsParameter.SetPrivateProperty("Id", 23);
});
var createNewShipCommandHandler = new CreateNewShipCommandHandler(_shipRepository);
createNewShipCommandHandler.CommandExecuted += args => _createdShipId = (int)args.Args;
createNewShipCommandHandler.ExecuteAsync(createNewShipCommand).Wait();
}
public async Task Context()
{
var domainEventHandlerFactory = new FakeDomainEventHandlerFactory(domainEvent => _raisedDomainEvent = domainEvent as IDomainEvent);
DomainEvents.Initialize(domainEventHandlerFactory);
_unitOfWork = new NhibernateUnitOfWork(new CoreDddSharedNhibernateConfigurator());
_unitOfWork.BeginTransaction();
var createNewShipCommand = new CreateNewShipCommand
{
ShipName = "ship name",
Tonnage = 23.45678m,
ImoNumber = "IMO 12345"
};
var createNewShipCommandHandler = new CreateNewShipCommandHandler(new NhibernateRepository <Ship>(_unitOfWork));
createNewShipCommandHandler.CommandExecuted += args => _createdShipId = (int)args.Args;
await createNewShipCommandHandler.ExecuteAsync(createNewShipCommand);
_unitOfWork.Flush();
_unitOfWork.Clear();
_persistedShip = _unitOfWork.Get <Ship>(_createdShipId);
}
public void Context()
{
var domainEventHandlerFactory = IoC.Resolve <IDomainEventHandlerFactory>();
DomainEvents.Initialize(domainEventHandlerFactory, isDelayedDomainEventHandlingEnabled: true);
DomainEvents.ResetDelayedEventsStorage();
}
public static void Initialize(TestContext context)
{
_container = new WindsorContainer();
DomainEvents.Initialize(_container);
_placedEventHandlerMock = new Mock <IHandle <OrderPlacedEvent> >();
_cancelledEventHandlerMock = new Mock <IHandle <OrderCancelledEvent> >();
_container.Register(Component.For <IHandle <OrderPlacedEvent> >().Instance(_placedEventHandlerMock.Object));
_container.Register(Component.For <IHandle <OrderCancelledEvent> >().Instance(_cancelledEventHandlerMock.Object));
}
private void _InitializeDomainEvents(WindsorContainer ioCContainer, bool isDelayedDomainEventHandlingEnabled)
{
var domainEventHandlerFactory = ioCContainer.Resolve <IDomainEventHandlerFactory>();
DomainEvents.Initialize(domainEventHandlerFactory, isDelayedDomainEventHandlingEnabled: isDelayedDomainEventHandlingEnabled);
if (isDelayedDomainEventHandlingEnabled)
{
DomainEvents.ResetDelayedEventsStorage();
}
}
private void _RegisterServicesIntoCastleWindsorIoCContainer()
{
_castleWindsorIoCContainer = new WindsorContainer();
CoreDddNhibernateInstaller.SetUnitOfWorkLifeStyle(x => x.PerWebRequest);
_castleWindsorIoCContainer.Install(
FromAssembly.Containing <CoreDddInstaller>(),
FromAssembly.Containing <CoreDddNhibernateInstaller>()
);
_castleWindsorIoCContainer.Register(
Component
.For <INhibernateConfigurator>()
.ImplementedBy <CoreDddSampleNhibernateConfigurator>()
.LifestyleSingleton()
);
// register command handlers
_castleWindsorIoCContainer.Register(
Classes
.FromAssemblyContaining <CreateNewShipCommandHandler>()
.BasedOn(typeof(ICommandHandler <>))
.WithService.FirstInterface()
.Configure(x => x.LifestyleTransient())
);
// register query handlers
_castleWindsorIoCContainer.Register(
Classes
.FromAssemblyContaining <GetShipsByNameQueryHandler>()
.BasedOn(typeof(IQueryHandler <>))
.WithService.FirstInterface()
.Configure(x => x.LifestyleTransient())
);
// register domain event handlers
_castleWindsorIoCContainer.Register(
Classes
.FromAssemblyContaining <ShipUpdatedDomainEventHandler>()
.BasedOn(typeof(IDomainEventHandler <>))
.WithService.FirstInterface()
.Configure(x => x.LifestyleTransient())
);
UnitOfWorkHttpModule.Initialize(
_castleWindsorIoCContainer.Resolve <IUnitOfWorkFactory>(),
isolationLevel: System.Data.IsolationLevel.ReadCommitted
);
DomainEvents.Initialize(
_castleWindsorIoCContainer.Resolve <IDomainEventHandlerFactory>(),
isDelayedDomainEventHandlingEnabled: true
);
IoC.Initialize(new CastleContainer(_castleWindsorIoCContainer));
}
private void _RegisterServicesIntoNinjectIoCContainer()
{
var ninjectIoCContainer = NinjectWebCommon.Bootstrapper.Kernel;
CoreDddNhibernateBindings.SetUnitOfWorkLifeStyle(x => x.InRequestScope());
ninjectIoCContainer.Load(
typeof(CoreDddBindings).Assembly,
typeof(CoreDddNhibernateBindings).Assembly
);
ninjectIoCContainer
.Bind <INhibernateConfigurator>()
.To <CoreDddSampleNhibernateConfigurator>()
.InSingletonScope();
// register controllers
ninjectIoCContainer.Bind(x => x
.FromAssemblyContaining <HomeController>()
.SelectAllClasses()
.InheritedFrom <ControllerBase>()
.BindAllInterfaces()
.Configure(y => y.InTransientScope()));
// register command handlers
ninjectIoCContainer.Bind(x => x
.FromAssemblyContaining <CreateNewShipCommandHandler>()
.SelectAllClasses()
.InheritedFrom(typeof(ICommandHandler <>))
.BindAllInterfaces()
.Configure(y => y.InTransientScope()));
// register query handlers
ninjectIoCContainer.Bind(x => x
.FromAssemblyContaining <GetShipsByNameQueryHandler>()
.SelectAllClasses()
.InheritedFrom(typeof(IQueryHandler <>))
.BindAllInterfaces()
.Configure(y => y.InTransientScope()));
// register domain event handlers
ninjectIoCContainer.Bind(x => x
.FromAssemblyContaining <ShipUpdatedDomainEventHandler>()
.SelectAllClasses()
.InheritedFrom(typeof(IDomainEventHandler <>))
.BindAllInterfaces()
.Configure(y => y.InTransientScope()));
UnitOfWorkHttpModule.Initialize(
ninjectIoCContainer.Get <IUnitOfWorkFactory>(),
isolationLevel: System.Data.IsolationLevel.ReadCommitted
);
DomainEvents.Initialize(
ninjectIoCContainer.Get <IDomainEventHandlerFactory>(),
isDelayedDomainEventHandlingEnabled: true
);
}
public void Context()
{
var domainEventHandlerFactory = new FakeDomainEventHandlerFactory(domainEvent => _raisedDomainEvent = (TestDomainEvent)domainEvent);
DomainEvents.Initialize(domainEventHandlerFactory);
_entity = new TestEntityWithDomainEvent();
_entity.BehaviouralMethodWithRaisingDomainEvent();
}
public static void Initialize(TestContext context)
{
_container = new WindsorContainer();
DomainEvents.Initialize(_container);
_addedEventHandlerMock = new Mock <IHandle <CartLineItemAddedEvent> >();
_updatedEventHandlerMock = new Mock <IHandle <CartLineItemUpdatedEvent> >();
_deletedEventHandlerMock = new Mock <IHandle <CartLineItemDeletedEvent> >();
_container.Register(Component.For <IHandle <CartLineItemAddedEvent> >().Instance(_addedEventHandlerMock.Object));
_container.Register(Component.For <IHandle <CartLineItemUpdatedEvent> >().Instance(_updatedEventHandlerMock.Object));
_container.Register(Component.For <IHandle <CartLineItemDeletedEvent> >().Instance(_deletedEventHandlerMock.Object));
}
public void raising_domain_event_throws_not_initialized()
{
_simulateDomainEventsNotInitialized();
var ex = Should.Throw <InvalidOperationException>(() => new TestEntityWithDomainEvent().BehaviouralMethodWithRaisingDomainEvent());
ex.Message.ToLower().ShouldContain("DomainEvents.Initialize");
void _simulateDomainEventsNotInitialized()
{
DomainEvents.Initialize(domainEventHandlerFactory: null);
}
}
public void Context()
{
_raisedDomainEvent = null;
var domainEventHandlerFactory = new FakeDomainEventHandlerFactory(domainEvent => _raisedDomainEvent = (TestDomainEvent)domainEvent);
DomainEvents.Initialize(domainEventHandlerFactory, isDelayedDomainEventHandlingEnabled: true);
DomainEvents.ResetDelayedEventsStorage();
_entity = new TestEntityWithDomainEvent();
_entity.BehaviouralMethodWithRaisingDomainEvent();
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
_container = IoCConfig.Configure();
LoggingConfig.Configure(Server);
MappingConfig.Configure();
DomainEvents.Initialize(_container);
EagerMigration();
RunTasksOnStartup();
}
public void Context()
{
var domainEventHandlerFactory = new FakeDomainEventHandlerFactory(domainEvent => _raisedDomainEvent = (TestDomainEvent)domainEvent);
DomainEvents.Initialize(domainEventHandlerFactory);
DomainEvents.ResetDelayedEventsStorage();
var unitOfWorkFactory = IoC.Resolve <IUnitOfWorkFactory>();
RebusUnitOfWork.Initialize(
unitOfWorkFactory: unitOfWorkFactory,
isolationLevel: IsolationLevel.ReadCommitted
);
_fakeMessageContext = new FakeMessageContext();
_unitOfWork = RebusUnitOfWork.Create(_fakeMessageContext);
_simulateApplicationTransaction();
RebusUnitOfWork.Commit(_fakeMessageContext, _unitOfWork);
RebusUnitOfWork.Cleanup(_fakeMessageContext, _unitOfWork);
}
public async Task Context()
{
var specification = new TUnitOfWorkMiddlewareSpecification();
var domainEventHandlerFactory = new FakeDomainEventHandlerFactory(domainEvent => _raisedDomainEvent = (TestDomainEvent)domainEvent);
DomainEvents.Initialize(domainEventHandlerFactory, isDelayedDomainEventHandlingEnabled: true);
DomainEvents.ResetDelayedEventsStorage();
async Task _requestDelegate(HttpContext context)
{
_entityRepository = IoC.Resolve <IRepository <TestEntityWithDomainEvent> >();
_entity = new TestEntityWithDomainEvent();
_entity.BehaviouralMethodWithRaisingDomainEvent();
await _entityRepository.SaveAsync(_entity);
}
await specification.CreateMiddlewareAndInvokeHandling(_requestDelegate);
}
public void Context()
{
var domainEventHandlerFactory = new FakeDomainEventHandlerFactory(domainEvent => _raisedDomainEvent = (EmailEnqueuedToBeSentDomainEvent)domainEvent);
DomainEvents.Initialize(domainEventHandlerFactory);
var template = EmailTemplateBuilder.New.Build();
_email = new EmailBuilder()
.WithEmailTemplate(template)
.WithId(EmailId)
.Build();
_recipientOne = new Recipient(ToAddressOne, NameOne);
_recipientTwo = new Recipient(ToAddressTwo, NameTwo);
_email.EnqueueEmailToBeSent(FromAddress,
new HashSet <Recipient>
{
_recipientOne,
_recipientTwo
},
Subject);
}
public async Task Context()
{
_serviceProvider = new ServiceProviderHelper().BuildServiceProvider();
DomainEvents.Initialize(_serviceProvider.GetService <IDomainEventHandlerFactory>());
_unitOfWork = _serviceProvider.GetService <NhibernateUnitOfWork>();
_unitOfWork.BeginTransaction();
var createNewShipCommand = new CreateNewShipCommand
{
ShipName = "ship name",
Tonnage = 23.45678m,
ImoNumber = "IMO 12345"
};
_bus = A.Fake <IBus>();
var createNewShipCommandMessageHandler = new CreateNewShipCommandMessageHandler(_serviceProvider.GetService <ICommandExecutor>(), _bus);
await createNewShipCommandMessageHandler.Handle(createNewShipCommand);
_unitOfWork.Flush();
_unitOfWork.Clear();
}
public async Task Context()
{
var specification = new TUnitOfWorkMiddlewareSpecification();
var domainEventHandlerFactory = new FakeDomainEventHandlerFactory(domainEvent => _raisedDomainEvent = (TestDomainEvent)domainEvent);
DomainEvents.Initialize(domainEventHandlerFactory, isDelayedDomainEventHandlingEnabled: true);
DomainEvents.ResetDelayedEventsStorage();
async Task _requestDelegate(HttpContext context)
{
_entityRepository = IoC.Resolve <IRepository <TestEntityWithDomainEvent> >();
_entity = new TestEntityWithDomainEvent();
await _entityRepository.SaveAsync(_entity);
throw new NotSupportedException("test exception");
}
try
{
await specification.CreateMiddlewareAndInvokeHandling(_requestDelegate);
}
catch (NotSupportedException) {}
}
private void _RegisterServicesIntoCastleWindsorIoCContainer()
{
_castleWindsorIoCContainer = new WindsorContainer();
CoreDddNhibernateInstaller.SetUnitOfWorkLifeStyle(x => x.PerWebRequest);
_castleWindsorIoCContainer.Install(
FromAssembly.Containing <CoreDddInstaller>(),
FromAssembly.Containing <CoreDddNhibernateInstaller>()
);
_castleWindsorIoCContainer.Register(
Component
.For <INhibernateConfigurator>()
.ImplementedBy <CoreDddSampleNhibernateConfigurator>()
.LifestyleSingleton()
);
// register MVC controllers
_castleWindsorIoCContainer.Register(
Classes
.FromAssemblyContaining <HomeController>()
.BasedOn <ControllerBase>()
.Configure(x => x.LifestyleTransient())
);
// register Web API controllers
_castleWindsorIoCContainer.Register(
Classes
.FromAssemblyContaining <ShipController>()
.BasedOn <ApiController>()
.Configure(x => x.LifestyleTransient())
);
// register command handlers
_castleWindsorIoCContainer.Register(
Classes
.FromAssemblyContaining <CreateNewShipCommandHandler>()
.BasedOn(typeof(ICommandHandler <>))
.WithService.FirstInterface()
.Configure(x => x.LifestyleTransient())
);
// register query handlers
_castleWindsorIoCContainer.Register(
Classes
.FromAssemblyContaining <GetShipsByNameQueryHandler>()
.BasedOn(typeof(IQueryHandler <>))
.WithService.FirstInterface()
.Configure(x => x.LifestyleTransient())
);
// register domain event handlers
_castleWindsorIoCContainer.Register(
Classes
.FromAssemblyContaining <ShipUpdatedDomainEventHandler>()
.BasedOn(typeof(IDomainEventHandler <>))
.WithService.FirstInterface()
.Configure(x => x.LifestyleTransient())
);
Action <TransactionScope> transactionScopeEnlistmentAction = transactionScope =>
{
// enlist custom resource manager into the transaction scope
};
TransactionScopeUnitOfWorkHttpModule.Initialize(
_castleWindsorIoCContainer.Resolve <IUnitOfWorkFactory>(),
transactionScopeEnlistmentAction: transactionScopeEnlistmentAction,
isolationLevel: System.Transactions.IsolationLevel.ReadCommitted
);
DomainEvents.Initialize(_castleWindsorIoCContainer.Resolve <IDomainEventHandlerFactory>());
GlobalConfiguration.Configuration.DependencyResolver = new IoCContainerCastleWindsorDependencyResolver(_castleWindsorIoCContainer);
ControllerBuilder.Current.SetControllerFactory(new IoCContainerCastleWindsorControllerFactory(_castleWindsorIoCContainer));
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RegisterGlobalFilters(GlobalFilters.Filters);
RegisterRoutes(RouteTable.Routes);
_windsorContainer = new WindsorContainer();
_configureBus(_windsorContainer);
CoreDddNhibernateInstaller.SetUnitOfWorkLifeStyle(x => x.PerWebRequest);
_windsorContainer.Install(
FromAssembly.Containing <CoreDddInstaller>(),
FromAssembly.Containing <CoreDddNhibernateInstaller>(),
FromAssembly.Containing <ControllerInstaller>(),
FromAssembly.Containing <CommandHandlerInstaller>(),
FromAssembly.Containing <EventHandlerInstaller>(),
FromAssembly.Containing <QueryHandlerInstaller>(),
FromAssembly.Containing <EmailMakerNhibernateInstaller>()
);
_setupTransactionScopeUnitOfWork();
//_setupDelayedDomainEventHandlingForUnitOfWork();
ControllerBuilder.Current.SetControllerFactory(new IoCControllerFactory(_windsorContainer));
ModelBinders.Binders.DefaultBinder = new EnumConverterModelBinder();
_UpgradeDatabase();
void _setupTransactionScopeUnitOfWork()
{
// call this method only when TransactionScopeUnitOfWorkHttpModule is used instead of UnitOfWorkHttpModule (see web.config system.webServer -> modules)
TransactionScopeUnitOfWorkHttpModule.Initialize(
_windsorContainer.Resolve <IUnitOfWorkFactory>(),
transactionScopeEnlistmentAction: transactionScope => transactionScope.EnlistRebus()
);
DomainEvents.Initialize(_windsorContainer.Resolve <IDomainEventHandlerFactory>());
}
void _setupDelayedDomainEventHandlingForUnitOfWork()
{
// call this method only when UnitOfWorkHttpModule is used instead of TransactionScopeUnitOfWorkHttpModule (see web.config system.webServer -> modules)
UnitOfWorkHttpModule.Initialize(_windsorContainer.Resolve <IUnitOfWorkFactory>());
DomainEvents.Initialize(
_windsorContainer.Resolve <IDomainEventHandlerFactory>(),
isDelayedDomainEventHandlingEnabled: true
);
}
void _configureBus(WindsorContainer container)
{
var rebusConfigurer = Configure.With(new CastleWindsorContainerAdapter(container));
var rebusInputQueueName = ConfigurationManager.AppSettings["RebusInputQueueName"];
var rebusTransport = ConfigurationManager.AppSettings["RebusTransport"];
switch (rebusTransport)
{
case "MSMQ":
rebusConfigurer
.Transport(x => x.UseMsmq(rebusInputQueueName))
.Subscriptions(x => x.UseJsonFile($"{Path.GetTempPath()}\\emailmaker_msmq_subscriptions.json"))
;
break;
case "RabbitMQ":
var rebusRabbitMqConnectionString = ConfigurationManager.AppSettings["RebusRabbitMqConnectionString"];
rebusConfigurer.Transport(x => x.UseRabbitMq(rebusRabbitMqConnectionString, rebusInputQueueName));
break;
default:
throw new Exception($"Unknown rebus transport: {rebusTransport}");
}
rebusConfigurer.Start();
}
}
static void Main(string[] args)
{
using (var windsorContainer = new WindsorContainer())
{
CoreDddNhibernateInstaller.SetUnitOfWorkLifeStyle(x => x.PerRebusMessage());
windsorContainer.Install(
FromAssembly.Containing <CoreDddInstaller>(),
FromAssembly.Containing <CoreDddNhibernateInstaller>()
);
windsorContainer.Register(
Component.For <INhibernateConfigurator>()
.ImplementedBy <CoreDddSharedNhibernateConfigurator>()
.LifeStyle.Singleton
);
windsorContainer.Register(
Component.For <IInternationalMaritimeOrganizationVerifier>()
.ImplementedBy <InternationalMaritimeOrganizationVerifier>()
.LifeStyle.Transient
);
// register command handlers
windsorContainer.Register(
Classes
.FromAssemblyContaining <CreateNewShipCommandHandler>()
.BasedOn(typeof(ICommandHandler <>))
.WithService.FirstInterface()
.Configure(x => x.LifestyleTransient()));
// register domain event handlers
windsorContainer.Register(
Classes
.FromAssemblyContaining <ShipCreatedDomainEventHandler>()
.BasedOn(typeof(IDomainEventHandler <>))
.WithService.FirstInterface()
.Configure(x => x.LifestyleTransient()));
windsorContainer.AutoRegisterHandlersFromAssemblyOf <VerifyImoNumberShipCreatedDomainEventMessageHandler>();
DomainEvents.Initialize(windsorContainer.Resolve <IDomainEventHandlerFactory>());
RebusUnitOfWork.Initialize(
unitOfWorkFactory: windsorContainer.Resolve <IUnitOfWorkFactory>(),
isolationLevel: System.Data.IsolationLevel.ReadCommitted
);
var rebusConfigurer = Configure.With(new CastleWindsorContainerAdapter(windsorContainer))
.Transport(x => x.UseRabbitMq("amqp://*****:*****@localhost", "ServiceApp"))
.Options(o =>
{
o.EnableUnitOfWork(
RebusUnitOfWork.Create,
RebusUnitOfWork.Commit,
RebusUnitOfWork.Rollback,
RebusUnitOfWork.Cleanup
);
});
using (var bus = rebusConfigurer.Start())
{
bus.Subscribe <ShipCreatedDomainEventMessage>().Wait();
Console.WriteLine("Press enter to quit");
Console.ReadLine();
}
}
}
public static void _RegisterServicesIntoNinjectIoCContainer()
{
var ninjectIoCContainer = NinjectWebCommon.Bootstrapper.Kernel;
CoreDddNhibernateBindings.SetUnitOfWorkLifeStyle(x => x.InRequestScope());
ninjectIoCContainer.Load(
typeof(CoreDddBindings).Assembly,
typeof(CoreDddNhibernateBindings).Assembly
);
ninjectIoCContainer
.Bind <INhibernateConfigurator>()
.To <CoreDddSampleNhibernateConfigurator>()
.InSingletonScope();
// register MVC controllers
ninjectIoCContainer.Bind(x => x
.FromAssemblyContaining <HomeController>()
.SelectAllClasses()
.InheritedFrom <ControllerBase>()
.BindAllInterfaces()
.Configure(y => y.InTransientScope()));
// register Web API controllers
ninjectIoCContainer.Bind(x => x
.FromAssemblyContaining <ShipController>()
.SelectAllClasses()
.InheritedFrom <ApiController>()
.BindAllInterfaces()
.Configure(y => y.InTransientScope()));
// register command handlers
ninjectIoCContainer.Bind(x => x
.FromAssemblyContaining <CreateNewShipCommandHandler>()
.SelectAllClasses()
.InheritedFrom(typeof(ICommandHandler <>))
.BindAllInterfaces()
.Configure(y => y.InTransientScope()));
// register query handlers
ninjectIoCContainer.Bind(x => x
.FromAssemblyContaining <GetShipsByNameQueryHandler>()
.SelectAllClasses()
.InheritedFrom(typeof(IQueryHandler <>))
.BindAllInterfaces()
.Configure(y => y.InTransientScope()));
// register domain event handlers
ninjectIoCContainer.Bind(x => x
.FromAssemblyContaining <ShipUpdatedDomainEventHandler>()
.SelectAllClasses()
.InheritedFrom(typeof(IDomainEventHandler <>))
.BindAllInterfaces()
.Configure(y => y.InTransientScope()));
Action <TransactionScope> transactionScopeEnlistmentAction = transactionScope =>
{
// enlist custom resource manager into the transaction scope
};
TransactionScopeUnitOfWorkHttpModule.Initialize(
ninjectIoCContainer.Get <IUnitOfWorkFactory>(),
transactionScopeEnlistmentAction: transactionScopeEnlistmentAction,
isolationLevel: System.Transactions.IsolationLevel.ReadCommitted
);
DomainEvents.Initialize(ninjectIoCContainer.Get <IDomainEventHandlerFactory>());
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
var applicationLifetime = app.ApplicationServices.GetRequiredService <IApplicationLifetime>();
applicationLifetime.ApplicationStopping.Register(OnShutdown);
_windsorContainer.GetFacility <AspNetCoreFacility>().RegistersMiddlewareInto(app);
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error/Error");
}
var unitOfWorkMode = AppSettings.Configuration["UnitOfWorkMode"];
switch (unitOfWorkMode)
{
case "TransactionScopeUnitOfWork":
_setupTransactionScopeUnitOfWork();
break;
case "UnitOfWork":
_setupUnitOfWorkWithDelayedDomainEventHandling();
break;
default:
throw new NotSupportedException("Unsupported unit of work mode.");
}
var pathBase = AppSettings.Configuration["PathBase"];
if (!string.IsNullOrWhiteSpace(pathBase))
{
app.UsePathBase(pathBase);
}
app.UseStaticFiles();
app.UseAuthentication();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
_ConfigureBus(_windsorContainer);
_UpgradeDatabase();
void _setupTransactionScopeUnitOfWork()
{
_windsorContainer.Register(
Component.For <TransactionScopeUnitOfWorkMiddleware>()
.DependsOn(Dependency.OnValue <System.Transactions.IsolationLevel>(
System.Transactions.IsolationLevel.ReadCommitted
))
.DependsOn(Dependency.OnValue <Action <System.Transactions.TransactionScope> >(
(Action <System.Transactions.TransactionScope>)(transactionScope => transactionScope.EnlistRebus())
))
.LifestyleSingleton().AsMiddleware()
);
DomainEvents.Initialize(_windsorContainer.Resolve <IDomainEventHandlerFactory>());
}
void _setupUnitOfWorkWithDelayedDomainEventHandling()
{
_windsorContainer.Register(
Component.For <UnitOfWorkMiddleware>()
.DependsOn(Dependency.OnValue <IsolationLevel>(IsolationLevel.ReadCommitted))
.LifestyleSingleton().AsMiddleware()
);
DomainEvents.Initialize(
_windsorContainer.Resolve <IDomainEventHandlerFactory>(),
isDelayedDomainEventHandlingEnabled: true
);
}
}
public static void RegisterHandlers(IServiceContainer container)
{
_store = new DomainEventHandlersStore();
RegisterAllEvents(container);
DomainEvents.Initialize(_store);
}