/// <summary> /// Specify that the service bus should load the StateMachineSagas from the container passed as argument /// </summary> /// <param name="configurator"></param> /// <param name="container"></param> public static void LoadStateMachineSagas(this IReceiveEndpointConfigurator configurator, IKernel container) { if (configurator == null) { throw new ArgumentNullException(nameof(configurator)); } if (container == null) { throw new ArgumentNullException(nameof(container)); } var registrationConfigurator = new RegistrationConfigurator(); container.Register(Component.For <ISagaStateMachineFactory>().Instance(new WindsorSagaStateMachineFactory(container))); container.Register(Component.For <IStateMachineActivityFactory>().Instance(new WindsorStateMachineActivityFactory())); container.Register(Component.For <ISagaRepositoryFactory>().Instance(new WindsorSagaRepositoryFactory(container))); IEnumerable <Type> sagaTypes = FindStateMachineSagaTypes(container); foreach (var sagaType in sagaTypes) { SagaStateMachineRegistrationCache.AddSagaStateMachine(registrationConfigurator, sagaType); } var registration = registrationConfigurator.CreateRegistration(new WindsorConfigurationServiceProvider(container)); registration.ConfigureSagas(configurator); }
/// <summary> /// Add the state machine sagas in the specified assembly to the service collection /// </summary> /// <param name="builder"></param> public static void RegisterSagaStateMachine <TStateMachine, TInstance>(this ContainerBuilder builder) where TStateMachine : class, SagaStateMachine <TInstance> where TInstance : class, SagaStateMachineInstance { var registrar = new AutofacSagaStateMachineRegistrar(builder); SagaStateMachineRegistrationCache.Register(typeof(TStateMachine), registrar); }
/// <summary> /// Add the state machine sagas in the specified assembly to the service collection /// </summary> /// <param name="collection"></param> public static void RegisterSagaStateMachine <TStateMachine, TInstance>(this IServiceCollection collection) where TStateMachine : class, SagaStateMachine <TInstance> where TInstance : class, SagaStateMachineInstance { var registrar = new DependencyInjectionSagaStateMachineRegistrar(collection); SagaStateMachineRegistrationCache.Register(typeof(TStateMachine), registrar); }
public static void RegisterSagaStateMachines(this IContainerRegistrar registrar, params Type[] types) { foreach (var type in types) { if (!type.HasInterface(typeof(SagaStateMachine <>))) { throw new ArgumentException($"The type is not a saga state machine: {TypeMetadataCache.GetShortName(type)}", nameof(types)); } SagaStateMachineRegistrationCache.Register(type, registrar); } }
/// <summary> /// Adds SagaStateMachines to the registry, using the factory method, and updates the registrar prior to registering so that the default /// saga registrar isn't notified. /// </summary> /// <param name="configurator"></param> /// <param name="registrar"></param> /// <param name="types">The state machine types to add</param> public static void AddSagaStateMachines(this IRegistrationConfigurator configurator, ISagaStateMachineRegistrar registrar, params Type[] types) { IEnumerable <Type> sagaTypes = types.Where(x => x.HasInterface(typeof(SagaStateMachine <>))); IEnumerable <Type> sagaDefinitionTypes = types.Where(x => x.HasInterface(typeof(ISagaDefinition <>))); var sagas = from c in sagaTypes join d in sagaDefinitionTypes on c.GetClosingArguments(typeof(SagaStateMachine <>)).Single() equals d.GetClosingArguments(typeof(ISagaDefinition <>)).Single() into dc from d in dc.DefaultIfEmpty() select new { SagaType = c, DefinitionType = d }; foreach (var saga in sagas) { SagaStateMachineRegistrationCache.AddSagaStateMachine(configurator, saga.SagaType, saga.DefinitionType, registrar); } }
/// <summary> /// Adds a SagaStateMachine to the registry, using the factory method, and updates the registrar prior to registering so that the default /// saga registrar isn't notified. /// </summary> /// <param name="configurator"></param> /// <param name="registrar"></param> /// <param name="sagaDefinitionType"></param> /// <typeparam name="TStateMachine"></typeparam> /// <typeparam name="TInstance"></typeparam> public static ISagaRegistrationConfigurator <TInstance> AddSagaStateMachine <TStateMachine, TInstance>(this IRegistrationConfigurator configurator, ISagaStateMachineRegistrar registrar, Type sagaDefinitionType = null) where TStateMachine : class, SagaStateMachine <TInstance> where TInstance : class, SagaStateMachineInstance { ISagaRegistration Factory(IContainerRegistrar containerRegistrar) { SagaStateMachineRegistrationCache.Register(typeof(TStateMachine), registrar); if (sagaDefinitionType != null) { SagaDefinitionRegistrationCache.Register(sagaDefinitionType, containerRegistrar); } return(new SagaStateMachineRegistration <TInstance>()); } return(configurator.AddSaga <TInstance>(Factory)); }
/// <summary> /// Add the state machine sagas in the specified assembly to the service collection /// </summary> /// <param name="builder"></param> /// <param name="type">The state machine saga type</param> public static void RegisterSagaStateMachine(this ContainerBuilder builder, Type type) { var registrar = new AutofacSagaStateMachineRegistrar(builder); SagaStateMachineRegistrationCache.Register(type, registrar); }
/// <summary> /// Add the state machine sagas in the specified assembly to the service collection /// </summary> /// <param name="collection"></param> /// <param name="type">The state machine saga type</param> public static void RegisterSagaStateMachine(this IServiceCollection collection, Type type) { var registrar = new DependencyInjectionSagaStateMachineRegistrar(collection); SagaStateMachineRegistrationCache.Register(type, registrar); }