protected void CallAllHandlers(HandlerDelegate dlgt)
{
foreach (AuraEffectHandler handler in m_handlers)
{
dlgt(handler);
}
}
async Task ICommandDispatcher.DispatchAsync <TCommand>(TCommand command, CancellationToken cancellationToken)
{
Ensure.Argument.NotNull(command, nameof(command));
var handler = handlerRegistry.GetCommandHandler <TCommand>();
var wrappers = handlerRegistry.GetCommandHandlerWrappers <TCommand>();
try
{
await ExecutePipeline().WithoutCapturingContext();
}
catch (Exception exception)
{
logger.LogWarning(exception, "Unhandled exception during command dispatch: {ExceptionMessage}", exception.Message);
throw;
}
Task ExecutePipeline()
{
HandlerDelegate pipeline = () => handler.HandleAsync(command, cancellationToken);
foreach (var wrapper in wrappers.OrderBy(wrapper => (wrapper as IPrioritizable)?.Priority ?? Priorities.Normal))
{
pipeline = Pipe(pipeline, wrapper);
}
return(pipeline());
}
HandlerDelegate Pipe(HandlerDelegate next, ICommandHandlerWrapper <TCommand> wrapper) => () => wrapper.HandleAsync(command, next, cancellationToken);
}
public LoggerMiddleware(HandlerDelegate next) : base(next)
{
_grpcLogger = ObjectContainer.Resolve <IGrpcLoggerFactory>().Create("GrpcLoggerMiddleware");
_logger = ObjectContainer.Resolve <ILoggerFactory>().Create("GrpcLoggerMiddleware");
_jsonSerializer = ObjectContainer.Resolve <IJsonSerializer>();
_startCallTimerDic = new Dictionary <Guid, DateTime>();
}
private async Task RunAsync(HandlerDelegate handlerDelegate, CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
CloudQueueMessage message = null;
try {
message = await queue.GetMessageAsync();
var context = new AzureStorageQueueMessageContext {
MessageId = message.Id,
MessageHeaders = new Dictionary <string, string>()
};
await handlerDelegate(message.AsString, context);
await queue.DeleteMessageAsync(message);
} catch (StorageException exception) {
if (exception.IsNotFoundQueueNotFound() ||
exception.IsConflictQueueBeingDeletedOrDisabled() ||
exception.IsServerSideError())
{
await queue.DeleteMessageAsync(message);
}
else
{
throw;
}
} catch (Exception e) {
exceptionHandler.HandleException(ExceptionDispatchInfo.Capture(e));
}
await Task.Delay(delayStrategy.Next(message != null), cancellationToken);
}
}
//game objects
public static void AddGameObjectHandler(GameObject go, HandlerDelegate handler, IDroppableItem detacher, int type = MouseEventHandlerType.Click0)
{
List <HandlerDelegate> list;
if (_goHandlers[type].TryGetValue(go, out list))
{
list.Add(handler);
}
else
{
_goHandlers[type].Add(go, new List <HandlerDelegate> {
handler
});
}
ModifyMask(type, go.layer, true);
if (detacher != null)
{
detacher.onDrop += obj =>
{
RemoveGameObjectHandler(go, handler, type);
};
}
}
private void WithHandler(HandlerType type, HandlerPriority priority, HandlerDelegate handler)
{
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
lock (_handlers)
{
if (!_handlers.ContainsKey(type))
{
_handlers[type] = new Dictionary <HandlerPriority, ICollection <HandlerDelegate> >()
{
{ priority, new List <HandlerDelegate> {
handler
} }
};
}
else
{
var handlersForType = _handlers[type];
if (!handlersForType.ContainsKey(priority))
{
handlersForType[priority] = new List <HandlerDelegate> {
handler
};
}
else
{
handlersForType[priority].Add(handler);
}
}
}
}
async Task <TResult> IQueryDispatcher.DispatchAsync <TResult>(IQuery <TResult> query, CancellationToken cancellationToken)
{
Ensure.Argument.NotNull(query, nameof(query));
var handler = new ReflectedQueryHandler <TResult>(query.GetType(), handlerRegistry);
var wrappers = new ReflectedQueryHandlerWrappers <TResult>(query.GetType(), handlerRegistry);
try
{
return(await ExecutePipeline().WithoutCapturingContext());
}
catch (Exception exception)
{
logger.LogWarning(exception, "Unhandled exception during query dispatch: {ExceptionMessage}", exception.Message);
throw;
}
Task <TResult> ExecutePipeline()
{
HandlerDelegate <TResult> pipeline = () => handler.HandleAsync(query, cancellationToken);
foreach (var wrapper in wrappers.OrderBy(wrapper => wrapper.Priority))
{
pipeline = Pipe(pipeline, wrapper);
}
return(pipeline());
}
HandlerDelegate <TResult> Pipe(HandlerDelegate <TResult> next, ReflectedQueryHandlerWrapper <TResult> wrapper) => () => wrapper.HandleAsync(query, next, cancellationToken);
}
public void AddHandler(UriTemplate uriTemplate, HandlerDelegate handler)
{
_uriHandlers.Add(new UriHandler()
{
UriTemplate = uriTemplate,
Handler = handler
});
}
private ErrorHandler()
{
// set up default
handlers_ = new HandlerDelegate[3];
handlers_[0] = new HandlerDelegate(HandleError);
handlers_[1] = new HandlerDelegate(HandleError);
handlers_[2] = new HandlerDelegate(HandleError);
}
public AzureStorageQueueListener(CloudQueue queue, CloudQueue poisonQueue, IDelayStrategy delayStrategy, HandlerDelegate messageHandlerDelegate, IExceptionHandler exceptionHandler)
{
this.queue = queue;
this.poisonQueue = poisonQueue;
this.delayStrategy = delayStrategy;
this.messageHandlerDelegate = messageHandlerDelegate;
this.exceptionHandler = exceptionHandler;
}
/// <summary>
/// Create a new invoker with the given callback
/// </summary>
/// <param name="callback">The callback that is invoked during <System.Web.IHttpHandler.ProcessRequest/>.</param>
public HandlerInvoker(HandlerDelegate callback)
{
if (callback == null)
{
throw new ArgumentNullException();
}
this.callback = callback;
}
public ExceptionHandlerAttribute(string channel, string target, string exception, string delegateName)
{
this._channel = channel;
this._target = target;
this._exception = exception;
this._delegate = (HandlerDelegate)Delegate.CreateDelegate(Type.GetType("AssemblyToProcessMapping"),
Type.GetType("AssemblyToProcessMapping").GetMethod(delegateName));
}
public override Task HandleAsync(HandlerContext context, HandlerDelegate next)
{
if (DoHandle(context))
{
SendMessage(context);
}
return(next.Invoke(context));
}
public void TestDefaultListenerMethod()
{
var called = new AtomicBoolean(false);
var handlerDelegate = new HandlerDelegate(called);
this.adapter.HandlerObject = handlerDelegate;
this.adapter.OnMessage(new Message(Encoding.UTF8.GetBytes("foo"), this.messageProperties));
Assert.True(handlerDelegate.Called);
}
private void AddCommand(string command, HandlerDelegate function, string helpMessage)
{
this.commands.Add(
command, new CommandInfo(function)
{
HelpMessage = helpMessage, ShowInHelp = true,
}
);
}
// ---------------------------------------------------------------------
public Option(string name, HandlerDelegate handlers = null, params string [] parameters)
{
this.name = name;
if (handlers != null)
{
this.handlers = handlers;
}
setParameters(parameters);
}
/// <summary>
/// 添加一个下载对象到下载队列
/// </summary>
/// <param name="downloadType">下载的类型</param>
/// <param name="url">url地址</param>
/// <param name="callBack">回调的对象</param>
/// <returns></returns>
public void addDownload(DownloadType downloadType, String url, HandlerDelegate callBack)
{
DownloadItem downloadItem = new DownloadItem();
downloadItem.downloadType = downloadType;
downloadItem.url = url;
downloadItem.callBack = callBack;
downloadList.Add(downloadItem);
}
public HandlerInfo(object instance, HandlerDelegate func, RuleInfo[] rules, byte priority, bool inline)
{
Type = instance.GetType();
Instance = instance;
Func = func;
Rules = rules;
Priority = priority;
Inline = inline;
}
/// <summary>
/// 注册key
/// </summary>
/// <param name="key">按键值</param>
/// <param name="handler">回调</param>
/// <param name="type">是否是按下</param>
/// <returns></returns>
public static void registerKey(KeyCode key, HandlerDelegate handler, bool type)
{
if (keyUpDict == null) keyUpDict = new Dictionary<KeyCode, List<HandlerDelegate>>();
if (keyDownDict == null) keyDownDict = new Dictionary<KeyCode, List<HandlerDelegate>>();
List<HandlerDelegate> list;
Dictionary<KeyCode, List<HandlerDelegate>> dict = type ? keyDownDict : keyUpDict;
if (!dict.ContainsKey(key)) dict[key] = new List<HandlerDelegate>();
list = dict[key];
list.Add(handler);
}
public Task <Message> HandleAsync(GetMessageById query, HandlerDelegate <Message> next, CancellationToken cancellationToken)
{
output.Add($"{nameof(GetMessageByIdHandlerWrapper)}.{nameof(HandleAsync)}_Before");
var taskResult = next();
output.Add($"{nameof(GetMessageByIdHandlerWrapper)}.{nameof(HandleAsync)}_After");
return(taskResult);
}
public void SetCallBack(int msec, HandlerDelegate callBack)
{
HandlerClass hc = new HandlerClass();
hc.Handler = callBack;
IntPtr p = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(IntPtr)));
Marshal.StructureToPtr(hc, p, false);
window3.setTimeout(p, msec, "JScript");
}
private Task <TResponse> Handle <TRequest, TResponse>(TRequest request)
where TRequest : IRequest <TResponse>
{
var handler = _serviceProvider.GetRequiredService <IRequestHandler <TRequest, TResponse> >();
var middlewares = _serviceProvider.GetServices <IMiddleware <TRequest, TResponse> >();
HandlerDelegate <TResponse> handlerDelegate = () => handler.HandleAsync(request);
var resultDelegate = middlewares.Aggregate(handlerDelegate, (next, middleware) => () => middleware.HandleAsync(request, next));
return(resultDelegate());
}
/// <summary>
/// 注册消息处理委托
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="MessageType"></param>
/// <param name="handle"></param>
public void RegisterHandle <T>(HandlerDelegate <T> handle) where T : IProtocol, new()
{
var MessageType = new T().MessageType;
if (DicHandles.ContainsKey(MessageType))
{
throw new ArgumentException($"{MessageType}消息句柄已被注册!");
}
DicHandles.Add(MessageType, new NetworkHandleBase <T>(new HandlerDelegate <T>(handle)));
}
public Task HandleAsync(TCommand command, HandlerDelegate next, CancellationToken cancellationToken)
{
output.Add($"{nameof(InnerCommandHandlerWrapper<TCommand>)}.{nameof(HandleAsync)}_Before");
var taskResult = next();
output.Add($"{nameof(InnerCommandHandlerWrapper<TCommand>)}.{nameof(HandleAsync)}_After");
return(taskResult);
}
public Task HandleAsync(CreateMessage command, HandlerDelegate next, CancellationToken cancellationToken)
{
output.Add($"{nameof(CreateMessageHandlerWrapper)}.{nameof(HandleAsync)}_Before");
var taskResult = next();
output.Add($"{nameof(CreateMessageHandlerWrapper)}.{nameof(HandleAsync)}_After");
return(taskResult);
}
public Task <TResult> HandleAsync(TQuery query, HandlerDelegate <TResult> next, CancellationToken cancellationToken)
{
output.Add($"{nameof(OuterQueryHandlerWrapper<TQuery, TResult>)}.{nameof(HandleAsync)}_Before");
var taskResult = next();
output.Add($"{nameof(OuterQueryHandlerWrapper<TQuery, TResult>)}.{nameof(HandleAsync)}_After");
return(taskResult);
}
/// <summary>
/// 添加一个http请求
/// </summary>
/// <param name="url">请求地址</param>
/// <param name="requestParams">请求参数</param>
/// <param name="callBack">请求回调</param>
public void addHttpRequest(String url, String requestParams, HandlerDelegate callBack)
{
DownloadItem downloadItem = new DownloadItem();
downloadItem.downloadType = DownloadType.type_url;
downloadItem.url = url;
downloadItem.callBack = callBack;
downloadItem.requestParams = UTF8Encoding.UTF8.GetBytes(requestParams);
downloadList.Add(downloadItem);
}
/// <inheritdoc/>
public async Task SendAsync <TMessage>(TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
var handler = GetHandler <IMessageHandler <TMessage> >();
if (handler == null)
{
throw new InvalidOperationException(string.Format(HandlerNotFound, typeof(TMessage)));
}
HandlerDelegate <TMessage> handlerDelegate = handler.HandleAsync;
await handlerDelegate.Invoke(message, cancellationToken);
}
public HandlerDelegate Build()
{
var handlerDelegate = _last;
foreach (var delegateItem in _delegates.Reverse())
{
handlerDelegate = delegateItem(handlerDelegate);
}
DelegateProxy = handlerDelegate;
return(handlerDelegate);
}
public Task <TResult> HandleAsync(IQuery <TResult> query, HandlerDelegate <TResult> next, CancellationToken cancellationToken)
{
try
{
return((Task <TResult>)handleMethod.Invoke(wrapper, new object[] { query, next, cancellationToken }));
}
catch (TargetInvocationException exception)
{
ExceptionDispatchInfo.Capture(exception.InnerException).Throw();
return(Task.FromException <TResult>(exception.InnerException));
}
}
public async Task <TResponse> HandleAsync(TRequest request, HandlerDelegate <TResponse> next)
{
var count = await _dbContext.Orders.CountAsync(
x => x.UserEmail == _currentUserService.Email && x.Id == request.Id);
if (count != 1)
{
throw new NotFoundException();
}
return(await next());
}
public async Task <Result <TResponse> > HandleAsync(TRequest request, HandlerDelegate <Result <TResponse> > next)
{
var count = await _dbContext.Orders.CountAsync(
x => x.UserEmail == _currentUserService.Email && x.Id == request.Id);
if (count != 1)
{
return(Result <TResponse> .Fail());
}
return(await next());
}
/// <summary>
/// Sets up a keyboard hook to trap all keystrokes without
/// passing any to other applications.
/// </summary>
public KeyboardHook()
{
kProc = new HandlerDelegate(HookCallbackKey);
mProc = new HandlerDelegate(HookCallbackMouse);
using (Process curProcess = Process.GetCurrentProcess())
using (ProcessModule curModule = curProcess.MainModule)
{
hookKeyID = NativeMethods.SetWindowsHookEx(WH_KEYBOARD_LL, kProc,
NativeMethods.GetModuleHandle(curModule.ModuleName), 0);
//hookMouseID = NativeMethods.SetWindowsHookEx(WH_MOUSE_LL, mProc,
// NativeMethods.GetModuleHandle(curModule.ModuleName), 0);
}
}
public HandlerDelegate Build()
{
HandlerDelegate app = context =>
{
return(Task.CompletedTask);
};
foreach (var component in _components.Reverse())
{
app = component(app);
}
return(app);
}
/// <summary>
/// 添加消息观察者
/// </summary>
/// <param name="name">消息名称</param>
/// <param name="handler">消息的回调</param>
/// <returns></returns>
public void addObserver(String name, HandlerDelegate handler)
{
List<HandlerDelegate> delegateList;
if (!this.dict.ContainsKey(name))
{
//根据消息名称创建回调列表
delegateList = new List<HandlerDelegate>();
delegateList.Add(handler);
this.dict.Add(name, delegateList);
}
else
{
//已经创建了回调列表则直接使用
delegateList = this.dict[name];
delegateList.Add(handler);
}
}
/// <summary>
/// Create a new invoker with the given callback
/// </summary>
/// <param name="callback">The callback that is invoked during <System.Web.IHttpHandler.ProcessRequest/>.</param>
public HandlerInvoker (HandlerDelegate callback)
{
if (callback == null)
throw new ArgumentNullException ();
this.callback = callback;
}
public CommandHandler(PlayerCheckDelegate[] playerChecks, HandlerDelegate handler)
{
PlayerChecks = playerChecks;
Handler = handler;
}
