How to define, raise and handle async events in ASP NET Core-CodePudding

The

I really don't understand how to use async events and generally how to properly define, use and handle events. Please explain it and give me easy example. Thank you in advance.

CodePudding user response：

In ASP.NET Core, you can use the EventBus pattern to define, raise, and handle async events,the EventBus is a service that acts as a message broker between different parts of your application,you can use it to register events and handlers, and then raise events as needed.

CodePudding user response：

Async

When working with async methods, you usually return a Task to the caller to wait for.

async Task MyAsyncMethod() { // async will implicitly create a new task and return it. return; } var task = MyAsyncMethod(); // execute the task await task; // the task is done

If you don't, the async keyword will execute the method because it can't create a task.

async void MyAsyncMethod() { return; } // the method execution is started, because it's async MyAsyncMethod();

Events

Usually, the event source (MyAppEvents) only cares about raising events, it doesn't know how many listeners there are, so it can't excepted them a return value.

To define an event, you need 2 things

the event handlers signature

the event definition (its name basically)

// event handlers signature public delegate SomeReturnValueType MyEventDelegate(FirstArgType arg1); // event definition public event MyEventDelegate MyEventName;

You could think that you could use SomeReturnValueType to return values from the handlers, but if you do so

var result = MyEventName.Invoke();

result would be set to the last handler's return value.

Mixing both

If you define your handlers to return a Task and try to await them when raising the event, you'll only await the last handler's task.

// task only represents the last handler var task = MyAsyncEvent.Invoke(); await task;

Doing this may leads to confusion, so I'd recommand to define the handlers delegate to not return a Task, so nobody is attempted to await.

public delegate void MyAsyncMethod();

When raising an event, the execution will continue as the event source doesn't (and shouldn't) know about the handlers.