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; }