What's in a Task?

Introduction

Tasks in .NET have become ubiquitous: by now we all know that in order to make our apps and services more scalable (not necessarily performant, they are different concepts), we need to use them. A task is an operation that is designed to run in the background and which may or may not return a value. Tasks allow complex operations (I/O or CPU-bound) to be executed without blocking the main thread and are implemented by the Task and Task<T> classes. These are actually monads in mathematical and functional terminology, which means they have certain properties which I won't cover here.

There are two ways by which we can call a method that is meant to be processed by another thread (one that returns Task or Task<T>, which inherits from Task but wraps a result):

  • We use await to ask for the callee to be called by another thread and wait for its completion
  • We omit await and have the callee processing in the background without waiting (sometimes called fire-and-forget)

Waiting for the Completion

When we call await on a Task-returning method, the calling thread will wait for the called method to finish. It will not block, but it will appear as such: the thread on the caller will be free to do other work if needed. If all went well, we can then access its result. We generally want this, but, there is an alternative.

Not Waiting for Completion

If we assign a Task or Task<T> variable to the return of the method we want to call asynchronously but omit the await, it will run in the background and will eventually finish (the fire-and-forget pattern). The thing here is: we should manually check for its status, which means, we aren't really forgetting about it.

We need to inspect our Task or Task<T> variable to see if:

If it has completed, we can then get its result (in the case of Task<T> it will be stored in Task<T>.Result). Any exceptions (one AggregateException will wrap many exceptions) thrown while executing will be in Task.Exception.

When we omit the await keyword we get a compiler warning: CS4014: Because this call is not awaited, execution of the current method continues before the call is completed. Consider applying the await operator to the result of the call. It is OK to ignore or suppress it, as long as we know what we are doing! The main problems with this are:

  • Forgetting to watch IsCompleted and IsCanceled before accessing Result, which may result in a blocking call or an exception being thrown
  • Calling GetAwaiter().GetResult(), which will block (this time, for real) the calling thread, if the task has not yet finished
  • Failing to have a look at Exception, resulting in an unobserved exception

Read more here.

Location: Coimbra, Portugal

Comments

Post a Comment

Popular posts from this blog

Modern Mapping with EF Core

Image
Introduction In EF Core (as in most O/RMs) we can map and store multiple things: Objects that hold a single value, like int , string , bool , float , Guid , DateTime , TimeSpan , Uri , etc. These are (somewhat wrongly) called primitive types  and are always included inside some container, like the following Objects that hold multiple single values and which have an identity, for example, Customer , Product , Order . These are called entity types  and they must have an identity that makes them unique amongst all the other objects of the same type Objects that are structured to hold multiple values, but have no identity, such as Address , Coordinate . These are called value types  and are merely a collection of (possibly related) properties We can also have collections of the previous things There's more to it, of course, for example, it is even possible to represent  inheritance of entities , of which I talked about before , In this post I am going to cover so...
Read more

OpenTelemetry with ASP.NET Core

Image
Introduction I wrote a post not too long ago about the building blocks of telemetry , or distributed tracing , with ASP.NET Core. Now I'm going to talk about how we can see it working using an open source bundle, otel-lgtm . Mind you, this may not be 100% suitable for production, but for development purposes, it should be fine, all concepts apply, of course. I won't cover everything about OpenTelemetry here, but should hopefully give you some insights as to what's there and how you can make good use of it. First, lets see what some of the concepts are. If you're interested in learning more about metrics, I suggest having a look at my post on this topic . OpenTelemetry OpenTelemetry  (OTel) provides a single, open-source standard, and a set of technologies to capture and export metrics, traces, and logs from your cloud-native applications and infrastructure. OTel is both a standard and a reference implementation that builds on other standards, such as W3C Distributed Tr...
Read more

.NET 10 Validation

Note: this is an update to my original post . Introduction I wrote about  entity validation  in the past, the reason I'm coming back to it is that there are some changes in .NET 10, related to validation. Let's cover the original validation API and then explain what has changed. .NET Validation Validation is implemented in the System.ComponentModel.DataAnnotations namespace. I'll describe it first and then move to the small changes in .NET 10. .NET has featured a way to validate classes and their properties for a long time, the API is called  Data Annotations Validation , and it integrates nicely with ASP.NET Core MVC and other frameworks (not Entity Framework Core, as  I've talked recently , nor ASP.NET Core Minimal APIs ). It is essentially, but not just, based on a set of attributes, one interface, and a class that performs validations on a target class and its properties, from the validation attributes it contain. The base class for attribute validation is ca...
Read more