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)
{
this.Execute(null);
return(Task.CompletedTask);
}
public Task HandleEventAsync(EventCallbackWorkItem item, object arg)
{
Count++;
return(item.InvokeAsync(arg));
}
Task IHandleEvent.HandleEventAsync(EventCallbackWorkItem binding, object args) => Based.HandleEventExtensions.HandleEventAsync(binding, args, StateHasChanged);
public Task HandleEventAsync(EventCallbackWorkItem item, object arg)
{
throw new NotImplementedException();
}
public Task HandleEventAsync(EventCallbackWorkItem item, object arg) => item.InvokeAsync(arg);
Task IHandleEvent.HandleEventAsync(EventCallbackWorkItem callback, object arg)
{
return(callback.InvokeAsync(arg));
}
