public MessageBrokerCore(MessagePipeDiagnosticsInfo diagnotics, MessagePipeOptions options)
{
this.handlerGroup = new Dictionary <TKey, HandlerHolder>();
this.diagnotics = diagnotics;
this.handlingSubscribeDisposedPolicy = options.HandlingSubscribeDisposedPolicy;
this.gate = new object();
}
public AsyncMessageBrokerCore(MessagePipeDiagnosticsInfo diagnotics, MessagePipeOptions options)
{
this.handlers = new FreeList <IAsyncMessageHandler <TMessage> >();
this.defaultAsyncPublishStrategy = options.DefaultAsyncPublishStrategy;
this.handlingSubscribeDisposedPolicy = options.HandlingSubscribeDisposedPolicy;
this.diagnotics = diagnotics;
}
public MessagePipeDiagnosticsInfo(MessagePipeOptions options)
{
if (options.EnableCaptureStackTrace)
{
enableCaptureStackTrace = true;
}
}
public static MessagePipeOptions BindMessagePipe(this DiContainer builder, Action <MessagePipeOptions> configure)
{
MessagePipeOptions options = null;
var proxy = new DiContainerProxy(builder);
proxy.AddMessagePipe(x =>
{
configure(x);
options = x;
// Zenject 6 does not allow regsiter multiple singleton, it causes annoying error.
// https://github.com/modesttree/Zenject#upgrade-guide-for-zenject-6
// so force use Scoped.
options.InstanceLifetime = (options.InstanceLifetime == InstanceLifetime.Singleton)
? InstanceLifetime.Scoped
: options.InstanceLifetime;
options.RequestHandlerLifetime = (options.RequestHandlerLifetime == InstanceLifetime.Singleton)
? InstanceLifetime.Scoped
: options.RequestHandlerLifetime;
});
builder.Bind <IServiceProvider>().To <DiContainerProviderProxy>().AsCached();
return(options);
}
public EventFactory(
MessagePipeOptions options,
MessagePipeDiagnosticsInfo diagnosticsInfo,
FilterAttachedMessageHandlerFactory handlerFactory,
FilterAttachedAsyncMessageHandlerFactory asyncHandlerFactory)
{
this.options = options;
this.diagnosticsInfo = diagnosticsInfo;
this.handlerFactory = handlerFactory;
this.asyncHandlerFactory = asyncHandlerFactory;
}
public static MessagePipeOptions RegisterMessagePipe(this IContainerBuilder builder, Action <MessagePipeOptions> configure)
{
MessagePipeOptions options = null;
var proxy = new ContainerBuilderProxy(builder);
proxy.AddMessagePipe(x =>
{
configure(x);
options = x;
});
builder.Register <IServiceProvider, ObjectResolverProxy>(Lifetime.Scoped);
return(options);
}
public ScopedAsyncMessageBrokerCore(MessagePipeDiagnosticsInfo diagnotics, MessagePipeOptions options)
: base(diagnotics, options)
{
}
public FilterAttachedAsyncMessageHandlerFactory(MessagePipeOptions options, AttributeFilterProvider <AsyncMessageHandlerFilterAttribute> filterProvider, IServiceProvider provider)
{
this.options = options;
this.filterProvider = filterProvider;
this.provider = provider;
}
public AsyncRequestAllHandler(IEnumerable <IAsyncRequestHandlerCore <TRequest, TResponse> > handlers, FilterAttachedAsyncRequestHandlerFactory handlerFactory, MessagePipeOptions options)
{
var collection = (handlers as ICollection <IAsyncRequestHandlerCore <TRequest, TResponse> >) ?? handlers.ToArray();
var array = new IAsyncRequestHandlerCore <TRequest, TResponse> [collection.Count];
var i = 0;
foreach (var item in collection)
{
array[i++] = handlerFactory.CreateAsyncRequestHandler(item);
}
this.handlers = array;
this.defaultAsyncPublishStrategy = options.DefaultAsyncPublishStrategy;
}
public SingletonMessageBrokerCore(MessagePipeDiagnosticsInfo diagnotics, MessagePipeOptions options)
: base(diagnotics, options)
{
}
/// <summary>Register IPublisher[TKey, TMessage] and ISubscriber[TKey, TMessage](includes Async) to container builder.</summary>
public static DiContainer BindMessageBroker <TKey, TMessage>(this DiContainer builder, MessagePipeOptions options)
{
var lifetime = options.InstanceLifetime;
var services = new DiContainerProxy(builder);
// keyed PubSub
services.Add(typeof(MessageBrokerCore <TKey, TMessage>), lifetime);
services.Add(typeof(IPublisher <TKey, TMessage>), typeof(MessageBroker <TKey, TMessage>), lifetime);
services.Add(typeof(ISubscriber <TKey, TMessage>), typeof(MessageBroker <TKey, TMessage>), lifetime);
// keyed PubSub async
services.Add(typeof(AsyncMessageBrokerCore <TKey, TMessage>), lifetime);
services.Add(typeof(IAsyncPublisher <TKey, TMessage>), typeof(AsyncMessageBroker <TKey, TMessage>), lifetime);
services.Add(typeof(IAsyncSubscriber <TKey, TMessage>), typeof(AsyncMessageBroker <TKey, TMessage>), lifetime);
return(builder);
}
/// <summary>Register IAsyncRequestHandler[TRequest, TResponse](includes All) to container builder.</summary>
public static IContainerBuilder RegisterAsyncRequestHandler <TRequest, TResponse, THandler>(this IContainerBuilder builder, MessagePipeOptions options)
where THandler : IAsyncRequestHandler
{
var lifetime = GetLifetime(options);
var services = new ContainerBuilderProxy(builder);
services.Add(typeof(IAsyncRequestHandlerCore <TRequest, TResponse>), typeof(THandler), lifetime);
if (!builder.Exists(typeof(IAsyncRequestHandler <TRequest, TResponse>), true))
{
services.Add(typeof(IAsyncRequestHandler <TRequest, TResponse>), typeof(AsyncRequestHandler <TRequest, TResponse>), lifetime);
services.Add(typeof(IAsyncRequestAllHandler <TRequest, TResponse>), typeof(AsyncRequestAllHandler <TRequest, TResponse>), lifetime);
}
return(builder);
}
/// <summary>Register IPublisher[TKey, TMessage] and ISubscriber[TKey, TMessage](includes Async) to container builder.</summary>
public static IContainerBuilder RegisterMessageBroker <TKey, TMessage>(this IContainerBuilder builder, MessagePipeOptions options)
{
var lifetime = GetLifetime(options);
var services = new ContainerBuilderProxy(builder);
// keyed PubSub
services.Add(typeof(MessageBrokerCore <TKey, TMessage>), lifetime);
services.Add(typeof(IPublisher <TKey, TMessage>), typeof(MessageBroker <TKey, TMessage>), lifetime);
services.Add(typeof(ISubscriber <TKey, TMessage>), typeof(MessageBroker <TKey, TMessage>), lifetime);
// keyed PubSub async
services.Add(typeof(AsyncMessageBrokerCore <TKey, TMessage>), lifetime);
services.Add(typeof(IAsyncPublisher <TKey, TMessage>), typeof(AsyncMessageBroker <TKey, TMessage>), lifetime);
services.Add(typeof(IAsyncSubscriber <TKey, TMessage>), typeof(AsyncMessageBroker <TKey, TMessage>), lifetime);
return(builder);
}
static Lifetime GetLifetime(MessagePipeOptions options)
{
return(options.InstanceLifetime == InstanceLifetime.Scoped ? Lifetime.Scoped : Lifetime.Singleton);
}
/// <summary>Register IAsyncRequestHandler[TRequest, TResponse](includes All) to container builder.</summary>
public static DiContainer BindAsyncRequestHandler <TRequest, TResponse, THandler>(this DiContainer builder, MessagePipeOptions options)
where THandler : IAsyncRequestHandler
{
var lifetime = options.InstanceLifetime;
var services = new DiContainerProxy(builder);
services.Add(typeof(IAsyncRequestHandlerCore <TRequest, TResponse>), typeof(THandler), lifetime);
if (!builder.HasBinding <IAsyncRequestHandler <TRequest, TResponse> >())
{
services.Add(typeof(IAsyncRequestHandler <TRequest, TResponse>), typeof(AsyncRequestHandler <TRequest, TResponse>), lifetime);
services.Add(typeof(IAsyncRequestAllHandler <TRequest, TResponse>), typeof(AsyncRequestAllHandler <TRequest, TResponse>), lifetime);
}
return(builder);
}
public MessagePipeDiagnosticsInfo(MessagePipeOptions options)
{
this.options = options;
}
public MessageBrokerCore(MessagePipeDiagnosticsInfo diagnotics, MessagePipeOptions options)
{
this.handlers = new FreeList <IMessageHandler <TMessage> >();
this.handlingSubscribeDisposedPolicy = options.HandlingSubscribeDisposedPolicy;
this.diagnotics = diagnotics;
}
public static IServiceCollection AddMessagePipe(this IServiceCollection services, Action <MessagePipeOptions> configure)
{
var options = new MessagePipeOptions();
configure(options);
services.AddSingleton(options); // add as singleton instance
services.AddSingleton(typeof(MessagePipeDiagnosticsInfo));
services.AddSingleton(typeof(EventFactory));
// filters.
// attribute and order is deterministic at compile, so use Singleton lifetime of cache.
services.AddSingleton(typeof(AttributeFilterProvider <MessageHandlerFilterAttribute>));
services.AddSingleton(typeof(AttributeFilterProvider <AsyncMessageHandlerFilterAttribute>));
services.AddSingleton(typeof(AttributeFilterProvider <RequestHandlerFilterAttribute>));
services.AddSingleton(typeof(AttributeFilterProvider <AsyncRequestHandlerFilterAttribute>));
services.AddSingleton(typeof(FilterAttachedMessageHandlerFactory));
services.AddSingleton(typeof(FilterAttachedAsyncMessageHandlerFactory));
services.AddSingleton(typeof(FilterAttachedRequestHandlerFactory));
services.AddSingleton(typeof(FilterAttachedAsyncRequestHandlerFactory));
foreach (var item in options.GetGlobalFilterTypes())
{
services.TryAddTransient(item); // filter itself is Transient
}
#if !UNITY_2018_3_OR_NEWER
// open generics implemntations(.NET Only)
{
var lifetime = options.InstanceLifetime; // pubsub lifetime
// keyless PubSub
services.Add(typeof(MessageBrokerCore <>), lifetime);
services.Add(typeof(IPublisher <>), typeof(MessageBroker <>), lifetime);
services.Add(typeof(ISubscriber <>), typeof(MessageBroker <>), lifetime);
services.Add(typeof(BufferedMessageBrokerCore <>), lifetime);
services.Add(typeof(IBufferedPublisher <>), typeof(BufferedMessageBroker <>), lifetime);
services.Add(typeof(IBufferedSubscriber <>), typeof(BufferedMessageBroker <>), lifetime);
// keyless PubSub async
services.Add(typeof(AsyncMessageBrokerCore <>), lifetime);
services.Add(typeof(IAsyncPublisher <>), typeof(AsyncMessageBroker <>), lifetime);
services.Add(typeof(IAsyncSubscriber <>), typeof(AsyncMessageBroker <>), lifetime);
services.Add(typeof(BufferedAsyncMessageBrokerCore <>), lifetime);
services.Add(typeof(IBufferedAsyncPublisher <>), typeof(BufferedAsyncMessageBroker <>), lifetime);
services.Add(typeof(IBufferedAsyncSubscriber <>), typeof(BufferedAsyncMessageBroker <>), lifetime);
// keyed PubSub
services.Add(typeof(MessageBrokerCore <,>), lifetime);
services.Add(typeof(IPublisher <,>), typeof(MessageBroker <,>), lifetime);
services.Add(typeof(ISubscriber <,>), typeof(MessageBroker <,>), lifetime);
// keyed PubSub async
services.Add(typeof(AsyncMessageBrokerCore <,>), lifetime);
services.Add(typeof(IAsyncPublisher <,>), typeof(AsyncMessageBroker <,>), lifetime);
services.Add(typeof(IAsyncSubscriber <,>), typeof(AsyncMessageBroker <,>), lifetime);
}
var lifetime2 = options.RequestHandlerLifetime; // requesthandler lifetime
// RequestHandler
services.Add(typeof(IRequestHandler <,>), typeof(RequestHandler <,>), lifetime2);
services.Add(typeof(IAsyncRequestHandler <,>), typeof(AsyncRequestHandler <,>), lifetime2);
// RequestAll
services.Add(typeof(IRequestAllHandler <,>), typeof(RequestAllHandler <,>), lifetime2);
services.Add(typeof(IAsyncRequestAllHandler <,>), typeof(AsyncRequestAllHandler <,>), lifetime2);
// auto registration is .NET only.
if (options.EnableAutoRegistration)
{
// auto register filter and requesthandler
// request handler is option's lifetime, filter is transient
if (options.autoregistrationAssemblies == null && options.autoregistrationTypes == null)
{
AddRequestHandlerAndFilterFromTypes(services, lifetime2, TypeCollector.CollectFromCurrentDomain());
}
else
{
var fromAssemblies = (options.autoregistrationAssemblies != null)
? TypeCollector.CollectFromAssemblies(options.autoregistrationAssemblies)
: Enumerable.Empty <Type>();
var types = options.autoregistrationTypes ?? Enumerable.Empty <Type>();
AddRequestHandlerAndFilterFromTypes(services, lifetime2, fromAssemblies.Concat(types).Distinct());
}
}
#endif
return(services);
}
