I used to call async methods (fire and forgot?) in constructors by
Task.Run(async () => await CallAsync());
I heard it's better to use ICommand to execute it.
ICommand MyCmd => new Command(async () => await CallAsync());
public MyClass()
{
MyCmd.Execute(null);
}
What's the difference between these two methods?
Your post makes not much sense.
If you want to fire-and-forget an async method, then just calling it directly is enough.
public Task RunAsync() { }
public Constructor()
{
RunAsync(); // fire-and-forget by not awaiting and ignoring returned task
}
There is no need to use Task.Run or Command, which technically does nothing on top of running the method.
But this kind of fire-and-forget code is frowned upon, because it makes testing of the code difficult. And starting such code in constructor makes the object creation have unexpected side-effects that are not immediately obvious. It is recommended to have some kind of Initialize method that can be called.
Another issue is that if the method causes an exception, a special handler must be register, otherwise it crashes whole application.
Task.Run is used in the question's first code snippet.
Task.Run(async () => await CallAsync()) can be simplified to Task.Run(CallAsync) without loss of any functionality.
A difference can relate to implementation of your Command class, but it's not shown in your question. There is no difference in the shown fragment. You can implement the Execute method to create a special set of commands.
The comment to the previous answer: 'There is no need to use Task.Run or Command, which technically does nothing on top of running the method' - this statement is not correct. 'Task.Run' creates a new thread while direct method calling doesn't.
HostingEnvironment.QueueBackgroundWorkItemis recommended mostly, take a look at here blog.stephencleary.com/2014/06/fire-and-forget-on-asp-net.htmlasync.