public void Subscribe(SubscribeMode mode)
{
EventManager.ManageSubscriber(mode, this, EventActorCreate.EventName);
EventManager.ManageSubscriber(mode, this, EventActorComponentFindFromID.EventName);
EventManager.ManageSubscriber(mode, this, EventActorComponentComputeID.EventName);
EventManager.ManageSubscriber(mode, this, EventActorLoaded.EventName);
}
/// <summary>
/// Subscribes to a queue asynchronously
/// </summary>
/// <param name="queueName"></param>
/// <param name="mode"></param>
/// <returns></returns>
public async Task <bool> SubscribeAsync(string queueName, SubscribeMode mode = SubscribeMode.TemporaryConsumer)
{
return(await SendMessageAsync(InitMessage(new SubscriptionMessage()
{
QueueName = queueName,
Mode = mode
})) != null);
}
public void Subscribe(SubscribeMode mode)
{
EventManager.ManageSubscriber(mode, this, EventWorkspaceSwitch.EventName);
EventManager.ManageSubscriber(mode, this, EventWorkspaceLoad.EventName);
EventManager.ManageSubscriber(mode, this, EventWorkspaceSave.EventName);
EventManager.ManageSubscriber(mode, this, EventWorkspaceNew.EventName);
EventManager.ManageSubscriber(mode, this, EventWorkspaceClear.EventName);
}
/// <summary>
/// Subscribes to a queue
/// </summary>
/// <param name="queueName"></param>
/// <param name="mode"></param>
/// <returns></returns>
public bool Subscribe(string queueName, SubscribeMode mode = SubscribeMode.TemporaryConsumer)
{
return(SendMessage(InitMessage(new SubscriptionMessage()
{
QueueName = queueName,
Mode = mode
})) != null);
}
/// <summary>
/// 订阅消息
/// </summary>
/// <param name="bus"></param>
/// <param name="topic">消息主题</param>
/// <param name="mode"></param>
/// <param name="handler">处理器</param>
/// <returns></returns>
public static IDisposable Subscribe(this IMessageBus bus, string topic, SubscribeMode mode, Action handler)
{
Guard.NotNull(bus, "bus");
Guard.NotNull(handler, "handler");
//return bus.Subscribe(topic, null, mode, ObserverHandler.Create(handler));
return(bus.Subscribe(new SubscribeInfo(handler)
{
Topic = topic, Mode = mode
}));
}
/// <summary>
///
/// </summary>
/// <typeparam name="TData"></typeparam>
/// <typeparam name="TResult"></typeparam>
/// <param name="bus"></param>
/// <param name="mode"></param>
/// <param name="handler">处理器</param>
/// <returns></returns>
public static IDisposable Subscribe <TData, TResult>(this IMessageBus bus, SubscribeMode mode, Func <object, TData, TResult> handler)
{
Guard.NotNull(bus, "bus");
Guard.NotNull(handler, "handler");
//return bus.Subscribe(null, typeof(TData), mode, ObserverHandler.CreateC<TData, TResult>(handler));
return(bus.Subscribe(new SubscribeInfo <TData, TResult>(handler)
{
Mode = mode
}));
}
/// <summary>
/// Either adds or removes a listener from the subscribed event
/// </summary>
/// <param name="mode"></param>
/// <param name="listener"></param>
/// <param name="eventName"></param>
/// <returns></returns>
public static bool ManageSubscriber(SubscribeMode mode, IEventListener listener, string eventName)
{
if (mode == SubscribeMode.Subscribe)
{
AddListener(listener, eventName);
return(true);
}
return(DetachListener(listener, eventName));
}
public StaticActionSubscribeProvider(MethodInfo method, string topic, SubscribeMode mode)
{
Method = method;
Factory = (instance) =>
{
var handler = Delegate.CreateDelegate(ActionType, method);
var messageHandler = ObserverHandler.Create((Action)handler);
return new SubscribeInfo(null, messageHandler) { Topic = topic, Mode = mode };
};
}
/// <summary>
/// Either adds or removes a listener from the subscribed event
/// </summary>
/// <param name="mode"></param>
/// <param name="listener"></param>
/// <param name="eventName"></param>
/// <returns></returns>
public static bool ManageSubscriber(SubscribeMode mode, IEventListener listener, string eventName)
{
switch (mode)
{
case SubscribeMode.Subscribe:
return(AddListener(listener, eventName));
case SubscribeMode.Unsubscribe:
default:
return(DetachListener(listener, eventName));
}
}
public Action1SubscribeProvider(MethodInfo method, ParameterInfo[] ps, string topic, SubscribeMode mode)
{
Method = method;
var msgType = ps[0].ParameterType;
var handlerType = Action1Type.MakeGenericType(msgType);
Factory = instance =>
{
var handler = Delegate.CreateDelegate(handlerType, instance, method);
var messageHandler = (IObserverHandler<IMessage>)Create1HandlerMethod.MakeGenericMethod(msgType).FastFuncInvoke(null, handler);
return new SubscribeInfo(msgType, messageHandler) { Topic = topic, Mode = mode };
};
}
public StaticActionSubscribeProvider(MethodInfo method, string topic, SubscribeMode mode)
{
Method = method;
Factory = (instance) =>
{
var handler = Delegate.CreateDelegate(ActionType, method);
var messageHandler = ObserverHandler.Create((Action)handler);
return(new SubscribeInfo(null, messageHandler)
{
Topic = topic, Mode = mode
});
};
}
public void Subscribe(Guid id, SubscribeMode mode)
{
Subscribers.AddOrUpdate(id, new Subscriber {
Id = id, Mode = mode
}, (s, u) => new Subscriber {
Id = id, Mode = mode
});
if (mode == SubscribeMode.PermanentConsumer)
{
Persistence.SaveQueue(this);
}
}
public StaticFuncSubscribeProvider(MethodInfo method, string topic, SubscribeMode mode)
{
Method = method;
var handlerType = FuncAType.MakeGenericType(method.ReturnType);
Factory = instance =>
{
var handler = Delegate.CreateDelegate(handlerType, method);
var messageHandler = (IObserverHandler <IMessage>)CreateAHandlerMethod.MakeGenericMethod(method.ReturnType).FastFuncInvoke(null, handler);
return(new SubscribeInfo(null, messageHandler)
{
Topic = topic, Mode = mode
});
};
}
public void SubscribeStock(string exchange, string symbol, SubscribeMode mode)
{
if (SubscribedStocks == null)
{
SubscribedStocks = new List <SubscribedStockInfo>();
}
if (!SubscribedStocks.Any(s => s.Exchange == exchange && s.Symbol == symbol))
{
SubscribedStocks.Add(new SubscribedStockInfo()
{
Exchange = exchange,
Symbol = symbol,
Mode = mode
});
}
}
public IDisposable Subscribe(SubscribeMode mode, IObserverHandler<IMessage> handler)
{
if (handler == null
|| observers.ContainsKey(handler))
return Disposable.Empty;
if (mode == SubscribeMode.Async)
IsAsync = true;
var observer = handler.Target;
lock (observers)
{
//ListnerManager.OnObserverAdding(observer, Name, Type);
observers.Add(handler, mode);
//ListnerManager.OnObserverAdded(observer, Name, Type);
}
return Disposable.Create(() => Unsubscribe(handler));
}
public IDisposable Subscribe(SubscribeMode mode, IObserverHandler <IMessage> handler)
{
if (handler == null ||
observers.ContainsKey(handler))
{
return(Disposable.Empty);
}
if (mode == SubscribeMode.Async)
{
IsAsync = true;
}
var observer = handler.Target;
lock (observers)
{
//ListnerManager.OnObserverAdding(observer, Name, Type);
observers.Add(handler, mode);
//ListnerManager.OnObserverAdded(observer, Name, Type);
}
return(Disposable.Create(() => Unsubscribe(handler)));
}
public void Subscribe(SubscribeMode mode)
{
EventManager.ManageSubscriber(mode, this, EventActorPrefabFromID.EventName);
}
/// <summary>
/// Adds or removes the listener for the EventObjectAwake event.
/// </summary>
/// <param name="mode">Whether its adding or removing the events.</param>
public void Subscribe(SubscribeMode mode)
{
EventManager.ManageSubscriber(mode, this, EventObjectAwake.EventName);
}
public void Subscribe(SubscribeMode mode)
{
EventManager.ManageSubscriber(mode, this, EventOnInputRecieved.EventName);
}
protected override void ReadMessageInternal(BinaryReader reader)
{
base.ReadMessageInternal(reader);
Mode = (SubscribeMode)reader.ReadInt32();
}
public Action1SubscribeProvider(MethodInfo method, ParameterInfo[] ps, string topic, SubscribeMode mode)
{
Method = method;
var msgType = ps[0].ParameterType;
var handlerType = Action1Type.MakeGenericType(msgType);
Factory = instance =>
{
var handler = Delegate.CreateDelegate(handlerType, instance, method);
var messageHandler = (IObserverHandler <IMessage>)Create1HandlerMethod.MakeGenericMethod(msgType).FastFuncInvoke(null, handler);
return(new SubscribeInfo(msgType, messageHandler)
{
Topic = topic, Mode = mode
});
};
}
public void Subscribe(SubscribeMode mode)
{
EventManager.ManageSubscriber(mode, this, EventRequestPrimaryWeaponFire.EventName);
}
public void Subscribe(SubscribeMode mode)
{
EventManager.ManageSubscriber(mode, this, EventRequestPlayerMove.EventName);
}
public StaticFuncSubscribeProvider(MethodInfo method, string topic, SubscribeMode mode)
{
Method = method;
var handlerType = FuncAType.MakeGenericType(method.ReturnType);
Factory = instance =>
{
var handler = Delegate.CreateDelegate(handlerType, method);
var messageHandler = (IObserverHandler<IMessage>)CreateAHandlerMethod.MakeGenericMethod(method.ReturnType).FastFuncInvoke(null, handler);
return new SubscribeInfo(null, messageHandler) { Topic = topic, Mode = mode };
};
}
/// <summary>
///
/// </summary>
/// <typeparam name="TData"></typeparam>
/// <param name="bus"></param>
/// <param name="topic">消息主题</param>
/// <param name="mode"></param>
/// <param name="handler">处理器</param>
/// <returns></returns>
public static IDisposable Subscribe <TData>(this IMessageBus bus, string topic, SubscribeMode mode, Action <object, TData> handler)
{
Guard.NotNull(bus, "bus");
Guard.NotNull(handler, "handler");
//return bus.Subscribe(topic, typeof(TData), mode, ObserverHandler.Create2<TData>(handler));
return(bus.Subscribe(new SubscribeInfo <TData>(handler)
{
Topic = topic, Mode = mode
}));
}
/// <summary>
/// Adds or removes the listener for the EventNotification event.
/// </summary>
/// <param name="mode">Whether its adding or removing these settings.</param>
public void Subscribe(SubscribeMode mode)
{
EventManager.ManageSubscriber(mode, this, EventNotification.EventName);
}
/// <summary>
/// Adds or removes the listener for the EventPersistantSettingChange event.
/// </summary>
/// <param name="mode">Whether its adding or removing these settings.</param>
public void Subscribe(SubscribeMode mode)
{
EventManager.ManageSubscriber(mode, this, EventPersistantSettingChange.EventName);
}
public void Subscribe(SubscribeMode mode)
{
EventManager.ManageSubscriber(mode, this, EventOnWorkspaceSwitched.EventName);
}
