public async ValueTask <IConsumerScopeContext> GetScope(ConsumeContext context)
{
if (context.TryGetPayload <Scope>(out var existingScope))
{
existingScope.UpdateScope(context);
return(new ExistingConsumerScopeContext(context));
}
var scope = AsyncScopedLifestyle.BeginScope(_container);
try
{
var scopeContext = new ConsumeContextScope(context, scope, scope.Container);
scope.UpdateScope(scopeContext);
return(new CreatedConsumerScopeContext <Scope>(scope, scopeContext));
}
catch
{
await scope.DisposeScopeAsync().ConfigureAwait(false);
throw;
}
}
public async ValueTask<IConsumerScopeContext> GetScope(ConsumeContext context)
{
if (context.TryGetPayload<IKernel>(out var kernel))
{
kernel.UpdateScope(context);
return new ExistingConsumerScopeContext(context);
}
var scope = _kernel.CreateNewOrUseExistingMessageScope();
try
{
var scopeContext = new ConsumeContextScope(context, _kernel);
_kernel.UpdateScope(scopeContext);
foreach (Action<ConsumeContext> scopeAction in _scopeActions)
scopeAction(scopeContext);
return new CreatedConsumerScopeContext<IDisposable>(scope, scopeContext);
}
catch
{
scope?.Dispose();
throw;
}
}
public ISagaScopeContext <T> GetScope <T>(ConsumeContext <T> context)
where T : class
{
if (context.TryGetPayload <IContainer>(out var existingContainer))
{
existingContainer.Inject <ConsumeContext>(context);
return(new ExistingSagaScopeContext <T>(context));
}
var nestedContainer = _container?.CreateNestedContainer(context) ?? _context?.CreateNestedContainer(context);
try
{
var proxy = new ConsumeContextScope <T>(context, nestedContainer);
foreach (Action <ConsumeContext> scopeAction in _scopeActions)
{
scopeAction(proxy);
}
return(new CreatedSagaScopeContext <IContainer, T>(nestedContainer, proxy));
}
catch
{
nestedContainer.Dispose();
throw;
}
}
public IConsumerScopeContext GetScope(ConsumeContext context)
{
if (context.TryGetPayload <IKernel>(out var kernel))
{
kernel.UpdateScope(context);
return(new ExistingConsumerScopeContext(context));
}
var scope = _kernel.CreateNewOrUseExistingMessageScope(context);
try
{
var proxy = new ConsumeContextScope(context, _kernel);
foreach (Action <ConsumeContext> scopeAction in _scopeActions)
{
scopeAction(proxy);
}
return(new CreatedConsumerScopeContext <IDisposable>(scope, proxy));
}
catch
{
scope?.Dispose();
throw;
}
}
IConsumerScopeContext IConsumerScopeProvider.GetScope(ConsumeContext context)
{
if (context.TryGetPayload<IServiceScope>(out var existingServiceScope))
{
existingServiceScope.UpdateScope(context);
return new ExistingConsumerScopeContext(context);
}
if (!context.TryGetPayload(out IServiceProvider serviceProvider))
serviceProvider = _serviceProvider;
var serviceScope = serviceProvider.GetRequiredService<IServiceScopeFactory>().CreateScope();
try
{
serviceScope.UpdateScope(context);
var consumeContext = new ConsumeContextScope(context, serviceScope, serviceScope.ServiceProvider);
return new CreatedConsumerScopeContext<IServiceScope>(serviceScope, consumeContext);
}
catch
{
serviceScope.Dispose();
throw;
}
}
Task Send <T>(ConsumeContext <T> context, Func <ConsumeContext <T>, ISagaRepositoryContextFactory <TSaga>, Task> send)
where T : class
{
if (context.TryGetPayload <ILifetimeScope>(out var existingScope))
{
context.GetOrAddPayload(() => existingScope.ResolveOptional <IStateMachineActivityFactory>() ?? AutofacStateMachineActivityFactory.Instance);
var factory = existingScope.Resolve <ISagaRepositoryContextFactory <TSaga> >();
return(send(context, factory));
}
var parentLifetimeScope = _scopeProvider.GetLifetimeScope(context);
async Task CreateScope()
{
await using var scope = parentLifetimeScope.BeginLifetimeScope(_name, builder =>
{
builder.ConfigureScope(context);
_configureScope?.Invoke(builder, context);
});
var activityFactory = scope.ResolveOptional <IStateMachineActivityFactory>() ?? AutofacStateMachineActivityFactory.Instance;
var consumeContextScope = new ConsumeContextScope <T>(context, scope, activityFactory);
var factory = scope.Resolve <ISagaRepositoryContextFactory <TSaga> >();
await send(consumeContextScope, factory).ConfigureAwait(false);
}
return(CreateScope());
}
Task Send <T>(ConsumeContext <T> context, Func <ConsumeContext <T>, ISagaRepositoryContextFactory <TSaga>, Task> send)
where T : class
{
if (context.TryGetPayload <INestedContainer>(out var existingContainer))
{
existingContainer.Inject <ConsumeContext>(context);
context.GetOrAddPayload(() => existingContainer.TryGetInstance <IStateMachineActivityFactory>()
?? LamarStateMachineActivityFactory.Instance);
var factory = existingContainer.GetInstance <ISagaRepositoryContextFactory <TSaga> >();
return(send(context, factory));
}
async Task CreateNestedContainer()
{
using var nestedContainer = _container.GetNestedContainer(context);
var activityFactory = nestedContainer.TryGetInstance <IStateMachineActivityFactory>()
?? LamarStateMachineActivityFactory.Instance;
var consumeContextScope = new ConsumeContextScope <T>(context, nestedContainer, activityFactory);
var factory = nestedContainer.GetInstance <ISagaRepositoryContextFactory <TSaga> >();
await send(consumeContextScope, factory).ConfigureAwait(false);
}
return(CreateNestedContainer());
}
public ISagaScopeContext <T> GetScope <T>(ConsumeContext <T> context)
where T : class
{
if (context.TryGetPayload <INestedContainer>(out var existingNestedContainer))
{
existingNestedContainer.Inject <ConsumeContext>(context);
return(new ExistingSagaScopeContext <T>(context));
}
var nestedContainer = _container.GetNestedContainer(context);
try
{
IStateMachineActivityFactory factory = new LamarStateMachineActivityFactory();
var proxy = new ConsumeContextScope <T>(context, nestedContainer, factory);
foreach (Action <ConsumeContext> scopeAction in _scopeActions)
{
scopeAction(proxy);
}
return(new CreatedSagaScopeContext <INestedContainer, T>(nestedContainer, proxy));
}
catch
{
nestedContainer.Dispose();
throw;
}
}
public IConsumerScopeContext GetScope(ConsumeContext context)
{
if (context.TryGetPayload <Scope>(out var existingScope))
{
existingScope.UpdateScope(context);
return(new ExistingConsumerScopeContext(context));
}
var scope = AsyncScopedLifestyle.BeginScope(_container);
try
{
var scopeContext = new ConsumeContextScope(context, scope, scope.Container);
scope.UpdateScope(scopeContext);
return(new CreatedConsumerScopeContext <Scope>(scope, scopeContext));
}
catch
{
scope.Dispose();
throw;
}
}
public IMessageScopeContext <T> GetScope <T>(ConsumeContext <T> context)
where T : class
{
if (context.TryGetPayload <IServiceScope>(out var existingServiceScope))
{
existingServiceScope.SetCurrentConsumeContext(context);
return(new ExistingMessageScopeContext <T>(context));
}
if (!context.TryGetPayload(out IServiceProvider serviceProvider))
{
serviceProvider = _serviceProvider;
}
var serviceScope = serviceProvider.CreateScope();
try
{
var scopeServiceProvider = new DependencyInjectionScopeServiceProvider(serviceScope.ServiceProvider);
var scopeContext = new ConsumeContextScope <T>(context, serviceScope, serviceScope.ServiceProvider, scopeServiceProvider);
serviceScope.SetCurrentConsumeContext(scopeContext);
return(new CreatedMessageScopeContext <IServiceScope, T>(serviceScope, scopeContext));
}
catch
{
serviceScope.Dispose();
throw;
}
}
public ISagaScopeContext <T> GetScope <T>(ConsumeContext <T> context)
where T : class
{
if (context.TryGetPayload <Scope>(out var existingScope))
{
existingScope.UpdateScope(context);
return(new ExistingSagaScopeContext <T>(context));
}
var scope = AsyncScopedLifestyle.BeginScope(_container);
try
{
scope.UpdateScope(context);
var proxy = new ConsumeContextScope <T>(context, scope, scope.Container);
foreach (Action <ConsumeContext> scopeAction in _scopeActions)
{
scopeAction(proxy);
}
return(new CreatedSagaScopeContext <Scope, T>(scope, proxy));
}
catch
{
scope.Dispose();
throw;
}
}
public async ValueTask <IMessageScopeContext <T> > GetScope <T>(ConsumeContext <T> context)
where T : class
{
if (context.TryGetPayload <ILifetimeScope>(out _))
{
return(new ExistingMessageScopeContext <T>(context));
}
var parentLifetimeScope = _scopeProvider.GetLifetimeScope(context);
var lifetimeScope = parentLifetimeScope.BeginLifetimeScope(_name, builder =>
{
builder.ConfigureScope(context);
_configureScope?.Invoke(builder, context);
});
try
{
var proxy = new ConsumeContextScope <T>(context, lifetimeScope);
return(new CreatedMessageScopeContext <ILifetimeScope, T>(lifetimeScope, proxy));
}
catch
{
await lifetimeScope.DisposeAsync().ConfigureAwait(false);
throw;
}
}
ISagaScopeContext <T> ISagaScopeProvider <TSaga> .GetScope <T>(ConsumeContext <T> context)
{
if (context.TryGetPayload <ILifetimeScope>(out _))
{
return(new ExistingSagaScopeContext <T>(context));
}
var parentLifetimeScope = _scopeProvider.GetLifetimeScope(context);
var lifetimeScope = parentLifetimeScope.BeginLifetimeScope(_name, builder =>
{
builder.ConfigureScope(context);
_configureScope?.Invoke(builder, context);
});
try
{
var proxy = new ConsumeContextScope <T>(context, lifetimeScope);
foreach (Action <ConsumeContext> scopeAction in _scopeActions)
{
scopeAction(proxy);
}
return(new CreatedSagaScopeContext <ILifetimeScope, T>(lifetimeScope, proxy));
}
catch
{
lifetimeScope.Dispose();
throw;
}
}
IConsumerScopeContext IConsumerScopeProvider.GetScope(ConsumeContext context)
{
if (context.TryGetPayload <ILifetimeScope>(out _))
{
return(new ExistingConsumerScopeContext(context));
}
var parentLifetimeScope = _scopeProvider.GetLifetimeScope(context);
var lifetimeScope = parentLifetimeScope.BeginLifetimeScope(_name, builder =>
{
builder.ConfigureScope(context);
_configureScope?.Invoke(builder, context);
});
try
{
var scopeContext = new ConsumeContextScope(context, lifetimeScope);
return(new CreatedConsumerScopeContext <ILifetimeScope>(lifetimeScope, scopeContext));
}
catch
{
lifetimeScope.Dispose();
throw;
}
}
IConsumerScopeContext IConsumerScopeProvider.GetScope(ConsumeContext context)
{
if (context.TryGetPayload <IServiceScope>(out var existingServiceScope))
{
existingServiceScope.UpdateScope(context);
return(new ExistingConsumerScopeContext(context));
}
if (!context.TryGetPayload(out IServiceProvider serviceProvider))
{
serviceProvider = _serviceProvider;
}
var serviceScope = serviceProvider.CreateScope();
try
{
var scopeContext = new ConsumeContextScope(context, serviceScope, serviceScope.ServiceProvider);
serviceScope.UpdateScope(scopeContext);
return(new CreatedConsumerScopeContext <IServiceScope>(serviceScope, scopeContext));
}
catch
{
serviceScope.Dispose();
throw;
}
}
public IMessageScopeContext <T> GetScope <T>(ConsumeContext <T> context)
where T : class
{
if (context.TryGetPayload <IServiceScope>(out var existingServiceScope))
{
existingServiceScope.UpdateScope(context);
return(new ExistingMessageScopeContext <T>(context));
}
if (!context.TryGetPayload(out IServiceProvider serviceProvider))
{
serviceProvider = _serviceProvider;
}
var serviceScope = serviceProvider.CreateScope();
try
{
serviceScope.UpdateScope(context);
var consumeContext = new ConsumeContextScope <T>(context, serviceScope, serviceScope.ServiceProvider);
return(new CreatedMessageScopeContext <IServiceScope, T>(serviceScope, consumeContext));
}
catch
{
serviceScope.Dispose();
throw;
}
}
public ISagaScopeContext <T> GetScope <T>(ConsumeContext <T> context)
where T : class
{
if (context.TryGetPayload <IKernel>(out var kernel))
{
kernel.UpdateScope(context);
return(new ExistingSagaScopeContext <T>(context));
}
var scope = _kernel.CreateNewOrUseExistingMessageScope(context);
try
{
var proxy = new ConsumeContextScope <T>(context, _kernel, _factory);
foreach (Action <ConsumeContext> scopeAction in _scopeActions)
{
scopeAction(proxy);
}
return(new CreatedSagaScopeContext <IDisposable, T>(scope, proxy));
}
catch
{
scope?.Dispose();
throw;
}
}
async ValueTask <IConsumerScopeContext <TConsumer, T> > IConsumerScopeProvider.GetScope <TConsumer, T>(ConsumeContext <T> context)
{
if (context.TryGetPayload <IServiceScope>(out var existingServiceScope))
{
existingServiceScope.SetCurrentConsumeContext(context);
var consumer = existingServiceScope.ServiceProvider.GetService <TConsumer>();
if (consumer == null)
{
throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'.");
}
var consumerContext = new ConsumerConsumeContextScope <TConsumer, T>(context, consumer);
return(new ExistingConsumerScopeContext <TConsumer, T>(consumerContext));
}
if (!context.TryGetPayload(out IServiceProvider serviceProvider))
{
serviceProvider = _serviceProvider;
}
var serviceScope = serviceProvider.CreateScope();
try
{
var scopeServiceProvider = new DependencyInjectionScopeServiceProvider(serviceScope.ServiceProvider);
var scopeContext = new ConsumeContextScope <T>(context, serviceScope, serviceScope.ServiceProvider, scopeServiceProvider);
serviceScope.SetCurrentConsumeContext(scopeContext);
var consumer = scopeServiceProvider.GetService <TConsumer>();
if (consumer == null)
{
throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'.");
}
var consumerContext = new ConsumerConsumeContextScope <TConsumer, T>(scopeContext, consumer);
return(new CreatedConsumerScopeContext <IServiceScope, TConsumer, T>(serviceScope, consumerContext));
}
catch
{
if (serviceScope is IAsyncDisposable asyncDisposable)
{
await asyncDisposable.DisposeAsync().ConfigureAwait(false);
}
else
{
serviceScope.Dispose();
}
throw;
}
}
Task Send <T>(ConsumeContext <T> context, Func <ConsumeContext <T>, ISagaRepositoryContextFactory <TSaga>, Task> send)
where T : class
{
if (!context.TryGetPayload(out IServiceProvider serviceProvider))
{
serviceProvider = _serviceProvider;
}
if (context.TryGetPayload <IServiceScope>(out var existingScope))
{
existingScope.SetCurrentConsumeContext(context);
context.GetOrAddPayload(() => existingScope.ServiceProvider.GetService <IStateMachineActivityFactory>()
?? DependencyInjectionStateMachineActivityFactory.Instance);
var factory = existingScope.ServiceProvider.GetRequiredService <ISagaRepositoryContextFactory <TSaga> >();
return(send(context, factory));
}
async Task CreateScope()
{
var serviceScope = serviceProvider.CreateScope();
try
{
var scopeServiceProvider = new DependencyInjectionScopeServiceProvider(serviceScope.ServiceProvider);
var scopeContext = new ConsumeContextScope <T>(context, serviceScope, serviceScope.ServiceProvider, scopeServiceProvider);
serviceScope.SetCurrentConsumeContext(scopeContext);
var activityFactory = serviceScope.ServiceProvider.GetService <IStateMachineActivityFactory>()
?? DependencyInjectionStateMachineActivityFactory.Instance;
var consumeContextScope = new ConsumeContextScope <T>(scopeContext, activityFactory);
var factory = serviceScope.ServiceProvider.GetRequiredService <ISagaRepositoryContextFactory <TSaga> >();
await send(consumeContextScope, factory).ConfigureAwait(false);
}
finally
{
if (serviceScope is IAsyncDisposable asyncDisposable)
{
await asyncDisposable.DisposeAsync().ConfigureAwait(false);
}
else
{
serviceScope.Dispose();
}
}
}
return(CreateScope());
}
public IConsumerScopeContext <TConsumer, T> GetScope <TConsumer, T>(ConsumeContext <T> context)
where TConsumer : class
where T : class
{
if (context.TryGetPayload <IKernel>(out var kernel))
{
kernel.UpdateScope(context);
var consumer = kernel.Resolve <TConsumer>();
if (consumer == null)
{
throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'.");
}
var consumerContext = new ConsumerConsumeContextScope <TConsumer, T>(context, consumer);
return(new ExistingConsumerScopeContext <TConsumer, T>(consumerContext, ReleaseComponent));
}
var scope = _kernel.CreateNewOrUseExistingMessageScope();
try
{
var scopeContext = new ConsumeContextScope <T>(context, _kernel);
_kernel.UpdateScope(scopeContext);
var consumer = _kernel.Resolve <TConsumer>();
if (consumer == null)
{
throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'.");
}
var consumerContext = new ConsumerConsumeContextScope <TConsumer, T>(scopeContext, consumer);
foreach (Action <ConsumeContext> scopeAction in _scopeActions)
{
scopeAction(consumerContext);
}
return(new CreatedConsumerScopeContext <IDisposable, TConsumer, T>(scope, consumerContext, ReleaseComponent));
}
catch
{
scope?.Dispose();
throw;
}
}
IConsumerScopeContext <TConsumer, T> IConsumerScopeProvider.GetScope <TConsumer, T>(ConsumeContext <T> context)
{
if (context.TryGetPayload <IServiceScope>(out var existingServiceScope))
{
existingServiceScope.UpdateScope(context);
var consumer = existingServiceScope.ServiceProvider.GetService <TConsumer>();
if (consumer == null)
{
throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'.");
}
var consumerContext = new ConsumerConsumeContextScope <TConsumer, T>(context, consumer);
return(new ExistingConsumerScopeContext <TConsumer, T>(consumerContext));
}
if (!context.TryGetPayload(out IServiceProvider serviceProvider))
{
serviceProvider = _serviceProvider;
}
var serviceScope = serviceProvider.CreateScope();
try
{
var scopeContext = new ConsumeContextScope <T>(context, serviceScope, serviceScope.ServiceProvider);
serviceScope.UpdateScope(scopeContext);
var consumer = serviceScope.ServiceProvider.GetService <TConsumer>();
if (consumer == null)
{
throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'.");
}
var consumerContext = new ConsumerConsumeContextScope <TConsumer, T>(scopeContext, consumer);
return(new CreatedConsumerScopeContext <IServiceScope, TConsumer, T>(serviceScope, consumerContext));
}
catch
{
serviceScope.Dispose();
throw;
}
}
internal MessageContext(MassTransit.MessageContext ctx)
{
_context = ctx as ConsumeContextScope <TMessage>;
Message = _context.Message;
Host = _context.Host;
Headers = _context.Headers;
SentTime = _context.SentTime;
FaultAddress = _context.FaultAddress;
ResponseAddress = _context.ResponseAddress;
DestinationAddress = _context.DestinationAddress;
SourceAddress = _context.SourceAddress;
ExpirationTime = _context.ExpirationTime;
InitiatorId = _context.InitiatorId;
ConversationId = _context.ConversationId;
CorrelationId = _context.CorrelationId;
RequestId = _context.RequestId;
MessageId = _context.MessageId;
}
public IConsumerScopeContext <TConsumer, T> GetScope <TConsumer, T>(ConsumeContext <T> context)
where TConsumer : class
where T : class
{
if (context.TryGetPayload <Scope>(out var existingScope))
{
existingScope.UpdateScope(context);
var consumer = existingScope.Container.GetInstance <TConsumer>();
if (consumer == null)
{
throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'.");
}
var consumerContext = new ConsumerConsumeContextScope <TConsumer, T>(context, consumer);
return(new ExistingConsumerScopeContext <TConsumer, T>(consumerContext));
}
var scope = AsyncScopedLifestyle.BeginScope(_container);
try
{
var scopeContext = new ConsumeContextScope <T>(context, scope, scope.Container);
scope.UpdateScope(scopeContext);
var consumer = scope.Container.GetInstance <TConsumer>();
if (consumer == null)
{
throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'.");
}
var consumerContext = new ConsumerConsumeContextScope <TConsumer, T>(scopeContext, consumer);
return(new CreatedConsumerScopeContext <Scope, TConsumer, T>(scope, consumerContext));
}
catch
{
scope.Dispose();
throw;
}
}
Task Send <T>(ConsumeContext <T> context, Func <ConsumeContext <T>, ISagaRepositoryContextFactory <TSaga>, Task> send)
where T : class
{
if (!context.TryGetPayload(out IServiceProvider serviceProvider))
{
serviceProvider = _serviceProvider;
}
if (context.TryGetPayload <IServiceScope>(out var existingScope))
{
existingScope.UpdateScope(context);
context.GetOrAddPayload(() => existingScope.ServiceProvider.GetService <IStateMachineActivityFactory>()
?? DependencyInjectionStateMachineActivityFactory.Instance);
var factory = existingScope.ServiceProvider.GetRequiredService <ISagaRepositoryContextFactory <TSaga> >();
return(send(context, factory));
}
async Task CreateScope()
{
using var serviceScope = serviceProvider.CreateScope();
var scopeServiceProvider = serviceScope.ServiceProvider;
var scopeContext = new ConsumeContextScope <T>(context, serviceScope, scopeServiceProvider);
serviceScope.UpdateScope(scopeContext);
var activityFactory = scopeServiceProvider.GetService <IStateMachineActivityFactory>()
?? DependencyInjectionStateMachineActivityFactory.Instance;
var consumeContextScope = new ConsumeContextScope <T>(scopeContext, activityFactory);
var factory = scopeServiceProvider.GetRequiredService <ISagaRepositoryContextFactory <TSaga> >();
await send(consumeContextScope, factory).ConfigureAwait(false);
}
return(CreateScope());
}
Task Send <T>(ConsumeContext <T> context, Func <ConsumeContext <T>, ISagaRepositoryContextFactory <TSaga>, Task> send)
where T : class
{
if (context.TryGetPayload <Scope>(out var existingScope))
{
existingScope.UpdateScope(context);
context.GetOrAddPayload(() => existingScope.TryGetInstance <IStateMachineActivityFactory>()
?? SimpleInjectorStateMachineActivityFactory.Instance);
var factory = existingScope.GetInstance <ISagaRepositoryContextFactory <TSaga> >();
return(send(context, factory));
}
var scope = AsyncScopedLifestyle.BeginScope(_container);
async Task CreateNestedContainer()
{
try
{
var scopeContext = new ConsumeContextScope <T>(context, scope);
scope.UpdateScope(scopeContext);
var activityFactory = scope.TryGetInstance <IStateMachineActivityFactory>()
?? SimpleInjectorStateMachineActivityFactory.Instance;
var consumeContextScope = new ConsumeContextScope <T>(scopeContext, activityFactory);
var factory = scope.GetInstance <ISagaRepositoryContextFactory <TSaga> >();
await send(consumeContextScope, factory).ConfigureAwait(false);
}
finally
{
scope.Dispose();
}
}
return(CreateNestedContainer());
}
public async ValueTask <IMessageScopeContext <T> > GetScope <T>(ConsumeContext <T> context)
where T : class
{
if (context.TryGetPayload <IServiceScope>(out var existingServiceScope))
{
existingServiceScope.SetCurrentConsumeContext(context);
return(new ExistingMessageScopeContext <T>(context));
}
if (!context.TryGetPayload(out IServiceProvider serviceProvider))
{
serviceProvider = _serviceProvider;
}
var serviceScope = serviceProvider.CreateScope();
try
{
var scopeServiceProvider = new DependencyInjectionScopeServiceProvider(serviceScope.ServiceProvider);
var scopeContext = new ConsumeContextScope <T>(context, serviceScope, serviceScope.ServiceProvider, scopeServiceProvider);
serviceScope.SetCurrentConsumeContext(scopeContext);
return(new CreatedMessageScopeContext <IServiceScope, T>(serviceScope, scopeContext));
}
catch
{
if (serviceScope is IAsyncDisposable asyncDisposable)
{
await asyncDisposable.DisposeAsync().ConfigureAwait(false);
}
else
{
serviceScope.Dispose();
}
throw;
}
}
Task Send <T>(ConsumeContext <T> context, Func <ConsumeContext <T>, ISagaRepositoryContextFactory <TSaga>, Task> send)
where T : class
{
if (context.TryGetPayload <IKernel>(out var existingKernel))
{
existingKernel.UpdateScope(context);
context.GetOrAddPayload(() => existingKernel.TryResolve <IStateMachineActivityFactory>() ?? WindsorStateMachineActivityFactory.Instance);
var factory = existingKernel.Resolve <ISagaRepositoryContextFactory <TSaga> >();
return(send(context, factory));
}
var scope = _kernel.CreateNewOrUseExistingMessageScope();
async Task CreateMessageScope()
{
try
{
var scopeContext = new ConsumeContextScope <T>(context, _kernel);
_kernel.UpdateScope(scopeContext);
var activityFactory = _kernel.TryResolve <IStateMachineActivityFactory>() ?? WindsorStateMachineActivityFactory.Instance;
var consumeContextScope = new ConsumeContextScope <T>(scopeContext, activityFactory);
var factory = _kernel.Resolve <ISagaRepositoryContextFactory <TSaga> >();
await send(consumeContextScope, factory).ConfigureAwait(false);
}
finally
{
scope.Dispose();
}
}
return(CreateMessageScope());
}
ISagaScopeContext <T> ISagaScopeProvider <TSaga> .GetScope <T>(ConsumeContext <T> context)
{
if (context.TryGetPayload <IUnityContainer>(out var existingScope))
{
return(new ExistingSagaScopeContext <T>(context));
}
var scope = _container.CreateChildContainer();
try
{
var proxy = new ConsumeContextScope <T>(context, scope);
return(new CreatedSagaScopeContext <IUnityContainer, T>(scope, proxy));
}
catch
{
scope.Dispose();
throw;
}
}
public IConsumerScopeContext GetScope(ConsumeContext context)
{
if (context.TryGetPayload <IUnityContainer>(out var existingScope))
{
return(new ExistingConsumerScopeContext(context));
}
var scope = _container.CreateChildContainer();
try
{
var proxy = new ConsumeContextScope(context, scope);
return(new CreatedConsumerScopeContext <IUnityContainer>(scope, proxy));
}
catch
{
scope.Dispose();
throw;
}
}
public IConsumerScopeContext GetScope(ConsumeContext context)
{
if (context.TryGetPayload <IContainer>(out var existingContainer))
{
existingContainer.Inject(context);
return(new ExistingConsumerScopeContext(context));
}
var nestedContainer = _container?.CreateNestedContainer(context) ?? _context?.CreateNestedContainer(context);
try
{
var proxy = new ConsumeContextScope(context, nestedContainer);
return(new CreatedConsumerScopeContext <IContainer>(nestedContainer, proxy));
}
catch
{
nestedContainer.Dispose();
throw;
}
}
