Develop Reference

How can an "async" task return an integer and not a public one?

I just had following piece of code, which did not compile:
public Task<int> Handle
{
var result = <do_something_returning_an_int>();
...
return result;
}
This gives compiler error `cannot implicitly convert type 'int' to 'System.Threading.Thread.Task'.
When I change this into:
async Task<int> Handle
{
var result = <do_something_returning_an_int>();
...
return result;
}
... no compiler error.
I know that async means that the task does not need to wait for the answer to arrive, but what does this have to do with typecasting?

If you're not awaiting anything in your asynchronous method you omit the async keyword and return a Task instead of the result directly.
public Task<int> Handle
{
var result = <do_something_returning_an_int>();
...
return Task.FromResult(result);
}
As far as I can tell, doing that only makes sense if other code strictly expects a Task from your method.
This has of course nothing to do with access modifiers, you can combine async with public or any other access modifier.
I'd also recommend taking a look at the documentation

(By request, promoted from a comment.)
This is by design of the async logic in the C# Language Specification. See the section Async Functions.
You can also read the programming guide, Async return types (C#) § Task<TResult>.
The point is that a method without the async keyword, like
public Task<int> HandleAsync()
{
...
Task<int> result = ...;
...
return result;
}
must return what it says it returns, just as with all other types. In this case, you could create a Task<> that can be awaited, in your own manual way, like:
Task<int> result = Task.Run(GetLastDigitOfSmallestTwinPrimeWithMoreThan1000000Digits);
The caller can await the task you return, even if your method is written like above.
But if you use the async keyword, and if your return type is, say, Task<int>, then you must return a plain int, and the C# compiler will write the needed logic for you.
Usually, you would use await somewhere in the body (otherwise, why async). So something like:
public async Task<int> HandleAsync()
{
...
int result = await GetLastDigitOfSmallestTwinPrimeWithMoreThan1000000DigitsAsync();
...
return result;
}
Related question here: Why is it not necessary to return a Task when the signature is public async Task MethodName?

try using task result and then iterate the results
Task<int> Handle
{
return Task.Run(()=>
{
var result = <do_something_returning_an_int>();
...
return result;
}
}
List<Task<int>> tasks = new List<Task<int>>();
tasks.Add(Handle);
Task.WaitAll(tasks.ToArray());
for(int ctr = 0; ctr < tasks.Count; ctr++) {
if (tasks[ctr].Status == TaskStatus.Faulted)
output.WriteLine(" Task fault occurred");
else
{
output.WriteLine("test sent {0}",
tasks[ctr].Result);
Assert.True(true);
}
}
or
Task<int> Handle
{
return Task.FromResult(do_something_returning_an_int);
}

Why returning Task.CompletedTask failed to compile in an async method?

I'm using VS2019 and dotnetcore 3.1 for a simple console application, I've this code piece:
public static async Task F()
{
await Task.Delay(1000);
return Task.CompletedTask; // error
}
It doesn't compile. I just with to create a method that is (1) async, and (2) returns a Task. Why this return statement doesn't compile? How to fix it to fulfill my requirement of (1) and (2)?
Thanks a lot.

Your method could functionally be condensed down to this.
public static Task F()
{
return Task.Delay(1000);
}
Returning an Task.CompletedTask instance is only useful if these apply:
you do not want to use async/await
your method returns a Task (effectively void if you were to make it not asynchronous)
your code has logic where a task might not be returned
Example:
public static Task F()
{
if (someConditionToShortCircutTheMethod)
return Task.CompletedTask;
// rest of logic
return Task.Delay(1000);
}
As soon as you make your method async then the fact that a Task is actually being returned is abstracted. This can make the code easier to work with especially if there are multiple points where the code waits for I/O operations to complete.
public static async Task F()
{
if (someConditionToShortCircutTheMethod)
return;
// rest of logic
await Task.Delay(1000);
await Task.Delay(1000);
// no return necessary, async Task has a similar flow as return type void
}
I also recommend reviewing these previous questions:
How and when to use ‘async’ and ‘await’
Understanding async / await in C#

await Task.Delay(1000); method already creates and returns a Task, so you could write
public static async Task F()
{
await Task.Delay(1000);
}
Or use await with Task.CompletedTask;
public static async Task F()
{
await Task.Delay(1000);
await Task.CompletedTask;
}
Otherwise you should update return type to Task<Task>, which doesn't make a lot of sense
public static async Task<Task> F()
{
await Task.Delay(1000);
return Task.CompletedTask;
}

It doesn't compile. I just with to create a method that is (1) async, and (2) returns a Task. Why this return statement doesn't compile? How to fix it to fulfill my requirement of (1) and (2)?
The async keyword will instruct the compiler to create a state machine, and it is the job of that state machine to create the Task returned from this method. So you don't need to return a Task if you're using async:
public static async Task F()
{
await Task.Delay(1000);
return;
}
or equivalently:
public static async Task F()
{
await Task.Delay(1000);
}

C# Async Task Method Without Await or Return

I have an Interface I that is implemented in two places like:
interface I
{
Task DoSomething();
}
The interface has async Task DoSomething method API that is then implemented in class A like:
class A : I {....}
class B : I {....}
In class A, the implementation of DoSomething is like below and that is OK:
public async Task DoSomething()
{
if (...)
{
await DoIt();
}
}
However, in class B, the implementation of DoSomething() should not do anything.
So, its implementation looks like this:
public async Task DoSomething()
{
// nothing
}
This compiles but I am not sure how correct it is do do something like this beside the fact that the method is useless.
But being "useless" in this case is ok in this case since it is implemented just because it is required by class B implementing the interface I.
I wonder if this is a correct way to implement a method that returns async Task but has no await or return? I know that this method will simple do nothing and execute synchronously as there is no call to await.
UPDATE: Similar questions have been asked here on SO and I have checked all of them before asking this one. None is asking what I am asking though

public Task DoSomething()
{
return Task.CompletedTask;
}
No need for the async.
If you're using an older version of .NET, use this:
public Task DoSomething()
{
return Task.FromResult(0);
}
If you find you need to return a result but you still dont need to await anything, try;
public Task<Result> DoSomething()
{
return Task.FromResult(new Result())
}
or, if you really want to use async (not recommended);
public async Task<Result> DoSomething()
{
return new Result();
}

I see that most people prefer to leave out the async and use Task.ComletedTask instead. But even if await is not used, there is still a big difference in exception handling
Consider the following example
static async Task Main(string[] args)
{
Task task = test(); // Will throw exception here
await task;
Task taskAsync = testWithAsync();
await taskAsync; // Will throw exception here
}
static Task test()
{
throw new Exception();
return Task.CompletedTask; //Unreachable, but left in for the example
}
static async Task testWithAsync()
{
throw new Exception();
}
Using
test().ContinueWith(...); or Task.WhenAll(test())
may result in unexpected behaviour.
Therefore, I prefer async instead of Task.CompletedTask or Task.FromResult.

What's the best way to wrap a Task as a Task<TResult>

I am writing some async helper methods and I have APIs to support both Task and Task<T>. To re-use code, I'd like the Task-based API to wrap the given task as a Task<T> and just call through to the Task<T> API.
One way I can do this is:
private static async Task<bool> Convert(this Task #this)
{
await #this.ConfigureAwait(false);
return false;
}
However, I'm wondering: is there there is a better/builtin way to do this?

There is no existing Task method that does exactly this, no. Your method is fine, and is likely about as simple as you'll be able to get.
Implementing the proper error propagating/cancellation semantics using any other method is deceptively hard.

Updated, the following propagates exceptions and cancellation:
public static class TaskExt
{
public static Task<Empty> AsGeneric(this Task #this)
{
return #this.IsCompleted ?
CompletedAsGeneric(#this) :
#this.ContinueWith<Task<Empty>>(CompletedAsGeneric,
TaskContinuationOptions.ExecuteSynchronously).Unwrap();
}
static Task<Empty> CompletedAsGeneric(Task completedTask)
{
try
{
if (completedTask.Status != TaskStatus.RanToCompletion)
// propagate exceptions
completedTask.GetAwaiter().GetResult();
// return completed task
return Task.FromResult(Empty.Value);
}
catch (OperationCanceledException ex)
{
// propagate cancellation
if (completedTask.IsCanceled)
// return cancelled task
return new Task<Empty>(() => Empty.Value, ex.CancellationToken);
throw;
}
}
}
public struct Empty
{
public static readonly Empty Value = default(Empty);
}

I've had the same requirement recently and I solved it with my own helper extension method, which allows the user to effectively wrap a Task with a Task<T>:
public static async Task<TResult> WithCompletionResult<TResult>(
this Task sourceTask,
TResult result
)
{
await sourceTask;
return result;
}
In your example call with:
Task<bool> task = myTask.WithCompletionResult<bool>(false);
If the result of Task<T> does not matter, I will use:
Task<object> task = myTask.WithCompletionResult<object>(null);
I hope this helps. If anyone knows of a pitfall with this approach let me know!

Using await seems a bit overkill here. No need for the state machine here, just use a ContinueWith
private static Task<bool> Convert(this Task #this)
{
return #this.ContinueWith(p => { p.Wait(); return false;});
}
Note: This will result in an AggregateException being wrapped unfortunately

create a custom async function (that is not calling another .net async method)

seems that all async examples end up calling a .net async method,
is it possible to create a custom async method that is not calling a .net async method ?
this is where I got so far:
[Test]
public void Test()
{
TestAsync();
}
public async void TestAsync()
{
await DoStuffAsync(1);
Task.Run(() => DoStuffAsync(73));
await Task.WhenAll(DoStuffAsync(2), DoStuffAsync(3));
}
public async Task DoStuffAsync(int n)
{
Thread.Sleep(1000);
Console.WriteLine("done stuff " + n);
}
the only problem with this is that VS says that async keyword in DoStuffAsync is useless (cuz there's no await), but I don't need await, I just need the possibility to await this method

The primary purpose of the async keyword is to enable the await keyword. An async method without an await doesn't make much sense, hence the compiler warning.
You can implement a Task-returning method without async, as such:
public Task DoStuffAsync(int n)
{
return Task.Delay(1000);
}
If you want to create your own Tasks from scratch, use Task.Run or TaskCompletionSource<T> (or one of its shortcuts such as Task.FromResult or TaskFactory.FromAsync).
P.S. You generally want to avoid async void; use async Task instead.

public async void TestAsync()
{
await DoStuffAsync(1);
await DoStuffAsync(73);
await Task.WhenAll(DoStuffAsync(2), DoStuffAsync(3));
}
public async Task DoStuffAsync(int n)
{
await Task.Delay(1000);
Console.WriteLine("done stuff " + n);
}