How to execute async await task on writemultiplecoilsasync?

Question

1.00/5 (1 vote)

See more:

, +

I could use some help getting the WriteMultipleCoilsAsync task to run. I'm getting the error message Cannot assign void to an implicitly-typed variable on the Task.Run statement. I need to capture the response message from WriteMultipleCoilsAsync.

Here the code:

C#

private async void btnWriteMultipleCoils_Click(object? sender, EventArgs e)
    {
        string discretes = "true,false,true";
        bool[] diarray = Array.ConvertAll(discretes.Split(','), bool.Parse);
        var response = await Task.Run(() => master.WriteMultipleCoilsAsync(0, diarray));
        await Task.CompletedTask;
    }

Here is the WriteMultipleCoilsAsync task:

C#

public Task WriteMultipleCoilsAsync(ushort startAddress, bool[] data)
    {
        return WriteMultipleCoilsAsync(0, startAddress, data);
    }

Here is the WriteMultipleCoilsAsync task:

C#

public Task WriteMultipleCoilsAsync(byte slaveAddress, ushort startAddress, bool[] data)
    {
        ValidateData("data", data, 1968);
        WriteMultipleCoilsRequest request = new WriteMultipleCoilsRequest(slaveAddress, startAddress, new DiscreteCollection(data));
        return PerformWriteRequestAsync<WriteMultipleCoilsResponse>(request);
    }

What I have tried:

Numerous attempts, but nothing working so far.

Posted 16-Nov-22 11:55am

Paul Dietz

Updated 16-Nov-22 22:50pm

v2

Add a Solution

2 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Graeme_Grant · Answer 1 · 2022-11-16T13:17:00

There is a lot wrong here.
1. The method that you want to await is not marked as async
2. The asynchronous call to PerformWriteRequestAsync in method WriteMultipleCoilsAsync is not awaited.

You should have:

C#

private async void btnWriteMultipleCoils_Click(object? sender, EventArgs e)
{
	string discretes = "true,false,true";
	bool[] diarray = Array.ConvertAll(discretes.Split(','), bool.Parse);
	.. bad! following two lines will lock the UI negating the benefits of asychronous programming
	// var response = await Task.Run(() => master.WriteMultipleCoilsAsync(0, diarray));
	// await Task.CompletedTask;
	
	// asynchronous call + force off UI thread
	var response = await master.WriteMultipleCoilsAsync(0, diarray).ConfigureAwait(false);
}

public async Task<WriteMultipleCoilsResponse> WriteMultipleCoilsAsync(ushort startAddress, bool[] data)
{
	return await WriteMultipleCoilsAsync(0, startAddress, data).ConfigureAwait(false);
}

public async Task<WriteMultipleCoilsResponse> WriteMultipleCoilsAsync(byte slaveAddress, ushort startAddress, bool[] data)
{
	ValidateData("data", data, 1968);
	WriteMultipleCoilsRequest request = new WriteMultipleCoilsRequest(slaveAddress, startAddress, new DiscreteCollection(data));
	return await PerformWriteRequestAsync<WriteMultipleCoilsResponse>(request).ConfigureAwait(false);
}

WARNING
async void is dangerous. It is a call and forget asynchronous call. If you want the UI to wait until the call is completed, then you need a isBusy boolean variable or a callback method, depending on your requirements, to track and manage the call state.

You can read more here: Asynchronous programming in C# | Microsoft Learn[^] or watch this video: Async Best Practices for C# and Visual Basic - YouTube[^] - the video goes into the issues and how to fix them. Mads is one of the C# language designers, so he is the best to learn from.

Hope this helps!

Richard Deeming · Answer 2 · 2022-11-16T22:50:00

Solution 2

Graeme (Solution 1) is correct that you should avoid async void[^] wherever possible. Unfortunately, that doesn't address the actual problem.

Your two WriteMultipleCoilsAsync methods return Task, not Task<T>. That means there is no result returned from the Task. You can await it to know when it has completed, but there is nothing to store in your response variable.

Assuming your PerformWriteRequestAsync<WriteMultipleCoilsResponse> method returns a Task<WriteMultipleCoilsResponse>, you simply need to update both overloads of the WriteMultipleCoilsAsync method to return the same:

C#

public Task<WriteMultipleCoilsResponse> WriteMultipleCoilsAsync(ushort startAddress, bool[] data)
{
    return WriteMultipleCoilsAsync(0, startAddress, data);
}

public Task<WriteMultipleCoilsResponse> WriteMultipleCoilsAsync(byte slaveAddress, ushort startAddress, bool[] data)
{
    ValidateData("data", data, 1968);
    WriteMultipleCoilsRequest request = new WriteMultipleCoilsRequest(slaveAddress, startAddress, new DiscreteCollection(data));
    return PerformWriteRequestAsync<WriteMultipleCoilsResponse>(request);
}

To avoid the async void, you will want to move the code that calls this into a separate Task-returning method:

C#

private async Task WriteMultipleCoilsAsync()
{
    string discretes = "true,false,true";
    bool[] diarray = Array.ConvertAll(discretes.Split(','), bool.Parse);
    
    // Or, more simply:
    // bool[] diarray = { true, false, true };

    var response = await master.WriteMultipleCoilsAsync(0, diarray);
    // Do something with the response here...
}

You can then "fire and forget" this task-returning async method from the event handler, using a "discard" to avoid the compiler warning:

C#

private void btnWriteMultipleCoils_Click(object? sender, EventArgs e)
{
    _ = WriteMultipleCoilsAsync();
}

Posted 16-Nov-22 22:50pm

Richard Deeming

Comments

Graeme_Grant 17-Nov-22 5:07am

This is still Fire and Forget just pushed to another method. The OP still needs to consider how to manage the result of the call or the time that the async call executes. This I mention in my original answer and is a point that you missed.

Richard Deeming 17-Nov-22 5:13am

Yes, it's still "fire and forget"; but it doesn't have the same associated problems as an async void method. And it's one approach suggested in David Fowler's async guidance[^], so it's a valid approach.

The alternative would be to use something like Marc Gravell's "fire and forget" code[^]; but that adds even more complexity when we're trying to stick to the basics. :)

Graeme_Grant 17-Nov-22 5:16am

Again, you're pushing more advanced techniques onto a novice. Running before walking. You totally missed the more important part of the section of my answer clearly labeled WARNING.

Richard Deeming 17-Nov-22 5:19am

No, I'm not pushing the more advanced technique. I'm just suggesting the code that needs to be async should be in a task-returning method. The discard is just there to suppress the compiler warning. :)

Graeme_Grant 17-Nov-22 5:19am

Again, This is still Fire and Forget. Keep it KISS...

Richard Deeming 17-Nov-22 5:17am

Interestingly, David Fowler's guidance page suggests that you should prefer using async / await over directly returning the Task[^]. But it also mentions that this adds extra overhead, and it wouldn't have much benefit here.

Graeme_Grant 17-Nov-22 5:18am

Yes, that is why I applied the KISS principle, the best approach for teaching novices and not showing off my advanced knowledge! I could have done that too... ;)

Richard Deeming 17-Nov-22 5:22am

Well, I'd still argue that telling the OP they have to write their code in a more complicated way, when what they already have is actually OK, is more likely to confuse them. :)

But ignoring that argument, it's the fact that the methods returned Task rather than Task<T> that was the actual problem.

Graeme_Grant 17-Nov-22 5:24am

"Well, I'd still argue.." - that you are! :P
Replacing Fire and Forget with a different Fire and Forget is not a better solution, it's cleaner coding. This still does not address the main issue that the OP faces with Fire and Forget coding.

Richard Deeming 17-Nov-22 5:26am

But it does address the main issue that the OP was posting about: the code not compiling. 🤣

Graeme_Grant 17-Nov-22 5:28am

And that I addressed in my answer before you injected. :P

Richard Deeming 17-Nov-22 5:31am

Where? Nowhere in your answer did you address the fact that WriteMultipleCoilsAsync returns Task rather than Task<T>. The code in your answer still won't compile. You have the equivalent of:

public void DoIt() { ... }
var result = DoIt();

Graeme_Grant 17-Nov-22 5:52am

Granted, something that I missed when I hand-coded the answer, but amusing that it took you so long after peddling your concepts! LMAO! Fixed.

Richard Deeming 17-Nov-22 6:06am

"So long" - a whole 10 minutes between my first comment on your answer and my suggestion that you should address this exact issue in your solution. 🤣 (Although I see you've since edited the comment I was replying to.)

And then another 10 minutes between my comment trying to help you improve your solution and posting my solution. Wow, I'm really slow today, right? 😁

Graeme_Grant 17-Nov-22 6:10am

ummm ... you started over 2 hours ago... but oh well ... I'm sure the OP is over this convo, just like me. I hope that he accepts the KISS answer and watched the video... lots of helpful information there ;)