tcs | Toyota Code Sprint @ PCL | 3D Printing library

Can anyone explain this to me?

Sure. The problem doesn't have anything to do with WhenAny. Rather, the problem is that the code assumes a method is asynchronous when it's synchronous.

This is a relatively easy mistake to make. But as a general rule, a method with an asynchronous signature may be asynchronous; it does not have to be asynchronous.

As I describe on my blog, asynchronous methods begin executing synchronously, just like synchronous methods. It is only when they hit an await that they may run asynchronously (and even then, they may continue synchronously).

So, the new version of LongCompuationAsync is synchronous, and it executes the entire method before returning the task to StartAsync, which then passes it to WhenAny.

i would like to convert EAP pattern to TAP pattern.

That would work, if the API was written with the EAP pattern. But it's not. Instead, it's doing its own kind of subscription pattern, using a delegate to trigger updates.

So, your options are:

1. Map the custom subscription pattern into a standard Observable pattern.
2. Build a buffer (e.g., System.Threading.Channels), have the event handler add items to the buffer, and then consume them as an asynchronous stream.

With both of these options, be sure to handle the "unsubscription" logic as well.

Below is an example of how you could implement this approach for your model:

It’s setTimeout. There is considerable indirection between that and QueueUserWorkItem, but this is where it bottoms out.

Most of the WebAssembly-specific machinery can be seen in PR 38029. The WebAssembly implementation of RequestWorkerThread calls a private method named QueueCallback, which is implemented in C code as mono_wasm_queue_tp_cb. This in invokes mono_threads_schedule_background_job, which in turn calls schedule_background_exec, which is implemented in TypeScript as:

You are using Per-patch output. So all the color attributes in the primitive become the same (from the last vertex in the patch):

Task.Delay is just pretty low resolution. As documentation states:

This method depends on the system clock. This means that the time delay will approximately equal the resolution of the system clock if the millisecondsDelay argument is less than the resolution of the system clock, which is approximately 15 milliseconds on Windows systems.

Your argument (1) is less than 15 milliseconds, so it gets adjusted to that. You can just do:

you can use $emit and $on for passing data between sibling components. please look at this example

when you pass data into another component you have to set this line:

It might help to see how the SetResult and SetCanceled methods are implemented:

Presumably your embedded device performs a service. This service needs an interface.

You need to specify that interface. Each available command, value, action, etc. should be documented along with acceptable ranges for values and what happens in error conditions. Then you simply implement the specification on both sides.

Bit-depth or data types of either side is irrelevant. If data doesn't fit the interface requirements, then it must be converted before using the interface.