/// <summary>
/// 注册订阅器。
/// </summary>
/// <param name="serviceProvider">应用程序服务实例。</param>
/// <param name="subscribeMgr">指定订阅管理器。</param>
/// <param name="types">可被注册为订阅器的类型集合。</param>
/// <param name="activator">创建订阅器实例的方法，一般是从 <paramref name="serviceProvider"/> 里获取。</param>
internal static void RegisterSubscribers(IServiceProvider serviceProvider, ISubscribeManager subscribeMgr, IEnumerable <Type> types, Func <IServiceProvider, Type, object> activator)
{
foreach (var type in types)
{
Type subType = null;
if ((subType = type.GetInterfaces().FirstOrDefault(s => s.IsGenericType && s.GetGenericTypeDefinition() == typeof(ISubscriber <>))) != null)
{
subType = subType.GetGenericArguments()[0];
subscribeMgr.AddSubscriber(subType, new Action <object>(o =>
{
var method = type.GetMethod(nameof(ISubscriber <string> .Accept));
if (method != null)
{
using var scope = serviceProvider.TryCreateScope();
var instance = activator(scope?.ServiceProvider ?? serviceProvider, type);
if (instance != null)
{
method.FastInvoke(instance, new[] { o });
}
instance.TryDispose();
}
}));
}
else if (type.IsImplementInterface(typeof(ISubscribeHandler)))
{
foreach (var method in type.GetMethods(BindingFlags.Public | BindingFlags.Instance))
{
if (method.DeclaringType != type)
{
continue;
}
var parameters = method.GetParameters();
if (parameters.Length != 1)
{
continue;
}
subscribeMgr.AddSubscriber(parameters[0].ParameterType, new Action <object>(o =>
{
using var scope = serviceProvider.TryCreateScope();
var instance = activator(scope?.ServiceProvider ?? serviceProvider, type);
if (instance != null)
{
method.FastInvoke(instance, new[] { o });
instance.TryDispose();
}
}));
}
}
}
}
public override void Initialize(WebSocketAcceptContext acceptContext)
{
base.Initialize(acceptContext);
_aliveKey = acceptContext.Option.AliveKey;
//开启消息订阅，使用aliveKey作为通道
_subscribeMgr = acceptContext.ServiceProvider.TryGetService <ISubscribeManager>();
_cacheMgr = acceptContext.ServiceProvider.TryGetService <IDistributedCacheManager>();
if (_cacheMgr == null)
{
throw new NotSupportedException("必须使用分布式缓存组件。");
}
_subscribeMgr.AddSubscriber <DistributedInvokeMessage>(_aliveKey, msg =>
{
try
{
//收到消息后，在本地查找连接，并发送消息
Clients(msg.Connections.ToArray()).SendAsync(msg.Message.Method, msg.Message.Arguments);
}
catch { }
});
}
/// <summary>
/// 添加一个订阅者实例。
/// </summary>
/// <typeparam name="TSubject"></typeparam>
/// <param name="subscribeMgr"><see cref="ISubscribeManager"/> 实例。</param>
/// <param name="subscriber">主题订阅者。</param>
/// <returns></returns>
public static ISubscribeManager AddSubscriber <TSubject>(this ISubscribeManager subscribeMgr, ISubscriber <TSubject> subscriber) where TSubject : class
{
Guard.ArgumentNull(subscribeMgr, nameof(subscribeMgr));
Guard.ArgumentNull(subscriber, nameof(subscriber));
subscribeMgr.AddSubscriber <TSubject>(subject => subscriber.Accept(subject));
return(subscribeMgr);
}
/// <summary>
/// 在指定的程序集中发现 <see cref="ISubscriber<TSubject>"/> 的实现。
/// </summary>
/// <typeparam name="TSubject"></typeparam>
/// <param name="subscribeMgr"><see cref="ISubscribeManager"/> 实例。</param>
/// <param name="assembly">指定的程序集。</param>
/// <returns></returns>
public static ISubscribeManager Discovery <TSubject>(this ISubscribeManager subscribeMgr, Assembly assembly) where TSubject : class
{
Guard.ArgumentNull(subscribeMgr, nameof(subscribeMgr));
Guard.ArgumentNull(assembly, nameof(assembly));
foreach (var type in assembly.GetExportedTypes().Where(s => !s.IsInterface && !s.IsAbstract && s.IsImplementInterface(typeof(ISubscriber <TSubject>))))
{
subscribeMgr.AddSubscriber <TSubject>(subject => type.New <ISubscriber <TSubject> >().Accept(subject));
}
return(subscribeMgr);
}
/// <summary>
/// 添加一个读取实体持久化消息的方法。
/// </summary>
/// <param name="subscriber"></param>
public void AddSubscriber(Action <PersistentSubject> subscriber)
{
subMgr.AddSubscriber(subscriber);
}
