Oscar Lopez

Posted onJun 4, 2024 • Originally published atoscarlp6.dev

     

🕒 Task vs Promise: Chaining

#csharp#javascript#async

The first language in which I learned to work asynchronously wasJavaScript. Initially, it was very challenging because it was a completely different way of thinking from what I had learned in university. Once I internalized the principles ofasynchronous programming, it became much easier. So, when I started working inC#, I immediately noticed the similarities betweenTask andPromise since they are practically equivalent.

But when trying to chain promises the same way as inJavaScript, I encountered a peculiarity. The function received in the.then method ofJavaScript is a function that expects the value wrapped in the promise. That is, if we have aPromise<number>, the function in.then is a function that receives anumber. However, inC#, the "equivalent" to.then is.ContinueWith, but this method expects a function that receives aTask of the same type as theoriginalTask. That is, if we have aTask<string>, the.ContinueWith method receives a function that receives aTask<string>. This caused a lot of confusion, and by discussing it withChatGPT, I was able to gain more clarity on the matter.

If you want to review my process, this is theconversation

.then in JavaScript

InJavaScript, the.then method is used to handle the result of apromise. The handler in.then directly receives theresolved value of the promise. Additionally,JavaScript provides the.catch method to handle errors.

Example in #"http://www.w3.org/2000/svg" width="20px" height="20px" viewbox="0 0 24 24">

In this example, if the promise is resolved, the handler in the first.then receives the response and processes it. If an error occurs, the handler in.catch is executed.

.ContinueWith inC#

In C#, the.ContinueWith method of aTask is used to continue with code execution after a task is completed. Unlike.then, the handler in.ContinueWith receives an instance ofTask<T>, allowing access to more details about the task, including itsstatus, exceptions, and result.

Basic Example in C#:

Task<int>task=Task.Run(()=>{// Simulating an asynchronous operationreturn42;});task.ContinueWith(t=>{if(t.IsFaulted){// Handle exceptionsConsole.WriteLine($"Error:{t.Exception.InnerException.Message}");}elseif(t.IsCompletedSuccessfully){// Handle successful resultConsole.WriteLine($"Result:{t.Result}");}});

In this example,ContinueWith handles both the successful result and possible exceptions. This is possible becauseContinueWith provides access to the entire task.

The Reasoning

No.catch inC#

InC#, there is no direct equivalent to.catch for promises inJavaScript that chains directly to aTask. Instead, errors are handled within the sameContinueWith handler or by usingtry-catch blocks in combination withawait.

Options for.ContinueWith inC#

The.ContinueWith method also allows specifying options that controlwhen the continuation handler should be executed, such asOnlyOnRanToCompletion andOnlyOnFaulted.

Example with ContinueWith Options:

Task<int>task=Task.Run(()=>{// Simulating an operation that may throw an exceptionthrownewInvalidOperationException("Simulated error");return42;});task.ContinueWith(t=>{Console.WriteLine($"Result:{t.Result}");},TaskContinuationOptions.OnlyOnRanToCompletion);task.ContinueWith(t=>{Console.WriteLine($"Error:{t.Exception.InnerException.Message}");},TaskContinuationOptions.OnlyOnFaulted);

In this example, two continuation handlers are defined: one that executes only if the task completes successfully (OnlyOnRanToCompletion) and another that executes only if thetask fails (OnlyOnFaulted).

Conclusions

Although both.ContinueWith inC# and.then inJavaScript serve to continue code execution after anasynchronous operation, there are important differences:

1. Continuation Handler: InJavaScript, the.then handler receives theresolved value of thepromise. InC#, the.ContinueWith handler receives an instance ofTask<T>, providing access to more task details.
2. Error Handling:JavaScript uses.catch to handleerrors. InC#, they are handled within theContinueWith handler or by using try-catch blocks when usingawait.
3. Continuation Options:C# allows specifying options in.ContinueWith to control when the continuation handler should be executed, offering more granular control.

These differences reflect the different philosophies and capabilities of the languages, providing developers with powerful tools to handle asynchronous operations in each environment.

I hope this article helps you better understand the differences between.ContinueWith in C# and.then in JavaScript, as well as the options for handling errors and accessing task details in C#.