110

I am new to asynchronous programming, so after going through some async sample codes, I thought of writing a simple async code

I created a simple Winform application and inside the Form I wrote the following code. But its just not working

private Task<string> methodAsync() {
    Thread.Sleep(10000);
    return "Hello"; //Error: Cannot implicitly convert type 'string' to 'System.Threading.Tasks.Task<string>'
}

private async void button1_Click(object sender, EventArgs e)
{
    string s = await methodAsync();
    MessageBox.Show(s);
}

Could someone please put some light here..

Improve this question

5 Answers 5

Reset to default
170

The listed return type of the method is Task<string>. You're trying to return a string. They are not the same, nor is there an implicit conversion from string to Task<string>, hence the error.

You're likely confusing this with an async method in which the return value is automatically wrapped in a Task by the compiler. Currently that method is not an async method. You almost certainly meant to do this:

private async Task<string> methodAsync() 
{
    await Task.Delay(10000);
    return "Hello";
}

There are two key changes. First, the method is marked as async, which means the return type is wrapped in a Task, making the method compile. Next, we don't want to do a blocking wait. As a general rule, when using the await model always avoid blocking waits when you can. Task.Delay is a task that will be completed after the specified number of milliseconds. By await-ing that task we are effectively performing a non-blocking wait for that time (in actuality the remainder of the method is a continuation of that task).

If you prefer a 4.0 way of doing it, without using await , you can do this:

private Task<string> methodAsync() 
{
    return Task.Delay(10000)
        .ContinueWith(t => "Hello");
}

The first version will compile down to something that is more or less like this, but it will have some extra boilerplate code in their for supporting error handling and other functionality of await we aren't leveraging here.

If your Thread.Sleep(10000) is really meant to just be a placeholder for some long running method, as opposed to just a way of waiting for a while, then you'll need to ensure that the work is done in another thread, instead of the current context. The easiest way of doing that is through Task.Run:

private Task<string> methodAsync() 
{
    return Task.Run(()=>
        {
            SomeLongRunningMethod();
            return "Hello";
        });
}

Or more likely:

private Task<string> methodAsync() 
{
    return Task.Run(()=>
        {
            return SomeLongRunningMethodThatReturnsAString();
        });
}
Improve this answer
Sign up to request clarification or add additional context in comments.

13 Comments

how can I explicitly wrap string in Task? OR isn't there any way to return Task or Task<T> without using async and await in the method being called(methodAsync in this case)?
@Aniket No, you're wrong, there are plenty of ways of explicitly wrapping a string in a task. I'll edit a solution in.
@Servy: suppose if I am not using the delay and some other code instead, which is causing the same delay in methodAsync, how shall I return the result string by wrapping it in Task?
You can use Task.FromResult to wrap a string in a Task.
@dotNETbeginner Well, you can try it for yourself if you don't believe me. await means, start that task, once it's started add a continuation to that task and continue on with the method where I left off once the async task finishes. If you just used Sleep and then Task.FromResult in the async method it would spend the entire 10 seconds just starting the task, never returning back to the caller until it's completed, thus blocking the UI thread the whole time and effectively running the entire thing synchronously.
|
79

Use FromResult Method

public async Task<string> GetString()
{
   System.Threading.Thread.Sleep(5000);
   return await Task.FromResult("Hello");
}
Improve this answer

3 Comments

thanks this is exactly what I needed, which none of the other answers provided.
As far as I can tell this answer is the best way to implement an interface defined with a Task<T> with an implementation that is synchronous
Isn't it possible to avoid the "async" and "await"? public Task<string> GetString() { System.Threading.Thread.Sleep(5000); return Task.FromResult("Hello"); }
30

Beyond the problematic use of async as pointed out by @Servy, the other issue is that you need to explicitly get T from Task<T> by calling Task.Result. Note that the Result property will block async code, and should be used carefully.

Try:

private async void button1_Click(object sender, EventArgs e)
{
    var s = await methodAsync();
    MessageBox.Show(s.Result);
}
Improve this answer

1 Comment

While this may not be highly recommended, there was an instance where I wanted to get back Task<string> content within catch {}. I couldn't await and .ToString() produced incorrect results. This fit the bill.
-2

In my case.

        string ip = _GetStoreIpaddress().Result;


    private async Task<string> _GetStoreIpaddress()
    {
        string _store_iP = "";
        var Ip_address = await App.SQLiteDb.GetItemsAsync();
        if (Ip_address != null)
        {
            _store_iP = Ip_address.ToString();
        }

        return _store_iP;
    }
Improve this answer

1 Comment

Firstly, this does not answer the question asked. Secondly, this code has really a lot of issues. Very weird notation, which is not even consistent across this tiny method. Showing the Result() call as a part of solution is another big issue.
-3 
    //source    
    public async Task<string> methodName()
            {
             return Data;
             }

    //Consumption
     methodName().Result;

Hope this helps :)

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.