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; } }
IConsumerScopeContext IConsumerScopeProvider.GetScope(ConsumeContext context) { if (context.TryGetPayload <IServiceScope>(out var existingServiceScope)) { existingServiceScope.SetCurrentConsumeContext(context); return(new ExistingConsumerScopeContext(context)); } if (!context.TryGetPayload(out IServiceProvider serviceProvider)) { serviceProvider = _serviceProvider; } var serviceScope = serviceProvider.CreateScope(); try { var scopeServiceProvider = new DependencyInjectionScopeServiceProvider(serviceScope.ServiceProvider); var scopeContext = new ConsumeContextScope(context, serviceScope, serviceScope.ServiceProvider, scopeServiceProvider); serviceScope.SetCurrentConsumeContext(scopeContext); return(new CreatedConsumerScopeContext <IServiceScope>(serviceScope, scopeContext)); } catch { serviceScope.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 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; } }