public async Task HandleEventAsync(EventCallbackWorkItem item, object arg) { SetShowModal(); await item.InvokeAsync(arg); _action.Invoke(); }
/// <summary> /// Internal method to track the render event /// </summary> /// <param name="callback"></param> /// <param name="arg"></param> /// <returns></returns> Task IHandleEvent.HandleEventAsync(EventCallbackWorkItem callback, object arg) { var task = callback.InvokeAsync(arg); var shouldAwaitTask = task.Status != TaskStatus.RanToCompletion && task.Status != TaskStatus.Canceled; InvokeAsync(Render); return(shouldAwaitTask ? CallRenderOnAsyncCompletion(task) : Task.CompletedTask); }
/// <summary> /// Invokes the delegate associated with this binding and dispatches an event notification to the /// appropriate component. /// </summary> /// <param name="arg">The argument.</param> /// <returns>A <see cref="Task"/> which completes asynchronously once event processing has completed.</returns> public Task InvokeAsync(object?arg) { if (Receiver == null) { return(EventCallbackWorkItem.InvokeAsync <object?>(Delegate, arg)); } return(Receiver.HandleEventAsync(new EventCallbackWorkItem(Delegate), arg)); }
Task IHandleEvent.HandleEventAsync(EventCallbackWorkItem callback, object arg) { var task = callback.InvokeAsync(arg); // skclusive commented. moved to CallStateHasChangedOnAsyncCompletion. // After each event, we synchronously re-render (unless !ShouldRender()) // This just saves the developer the trouble of putting "StateHasChanged();" // at the end of every event callback. // StateHasChanged(); return(CallStateHasChangedOnAsyncCompletion(task, parameterChanged: false)); }
public static async Task HandleEventAsync(EventCallbackWorkItem binding, object args, Action stateHasChanged) { try { await binding.InvokeAsync(args); stateHasChanged(); } catch (Exception e) { HandlingException.HandleException(e); throw; } }
async Task IHandleEvent.HandleEventAsync(EventCallbackWorkItem binding, object args) { try { await binding.InvokeAsync(args); StateHasChanged(); } catch (Exception e) { HandleException(e); throw; } }
Task IHandleEvent.HandleEventAsync(EventCallbackWorkItem callback, object?arg) { var task = callback.InvokeAsync(arg); var shouldAwaitTask = task.Status != TaskStatus.RanToCompletion && task.Status != TaskStatus.Canceled; // After each event, we synchronously re-render (unless !ShouldRender()) // This just saves the developer the trouble of putting "StateHasChanged();" // at the end of every event callback. StateHasChanged(); return(shouldAwaitTask ? CallStateHasChangedOnAsyncCompletion(task) : Task.CompletedTask); }
Task IHandleEvent.HandleEventAsync(EventCallbackWorkItem callback, object?arg) { // This code provides support for EnableStateHasChangedCallAfterEvent option // See https://github.com/dotnet/aspnetcore/issues/18919#issuecomment-803005864 var task = callback.InvokeAsync(arg); var shouldAwaitTask = task.Status != TaskStatus.RanToCompletion && task.Status != TaskStatus.Canceled; if (shouldAwaitTask) { return(CallStateHasChangedOnAsyncCompletion(task)); } if (EnableStateHasChangedCallAfterEvent) { StateHasChanged(); } return(Task.CompletedTask); }
Task IHandleEvent.HandleEventAsync(EventCallbackWorkItem callback, object?arg) { // This code is copied from ComponentBase // Remove this implementation when 'MustTriggerStateHasChangedOnEvent' becomes a regular Blazor feature // https://github.com/dotnet/aspnetcore/issues/18919#issuecomment-803005864 var task = callback.InvokeAsync(arg); var shouldAwaitTask = task.Status != TaskStatus.RanToCompletion && task.Status != TaskStatus.Canceled; if (shouldAwaitTask) { return(CallStateHasChangedOnAsyncCompletion(task)); } if (EnableStateHasChangedCallAfterEvent) { StateHasChanged(); } return(Task.CompletedTask); }
public Task HandleEventAsync(EventCallbackWorkItem item, object arg) { Count++; return(item.InvokeAsync(arg)); }
public Task HandleEventAsync(EventCallbackWorkItem item, object arg) => item.InvokeAsync(arg);
Task IHandleEvent.HandleEventAsync(EventCallbackWorkItem callback, object arg) { return(callback.InvokeAsync(arg)); }