Skip to main content

A Task chaining refactoring with an example

This was a very long break since I posted my last web note however it`s time to share some fresh experience with the developer community. Today I want to show one of a handy solution which allowed me to simplify a Task chaining in .NET 4.5.1.

Let`s start from defining a problem which in this case is a Task.ContinueWith<TResult>  method and the way how it`s designed for a tasks chaining. So if you want to use a chaining by using this function, all the time you need to access a parent task result property which in many cases causes a lot of redundancy in the code. To demonstrate this I use a simple async WebApi2 GET cities  auto-complete function which will query a database and later map result set of entities to collection of data transfer objects (DTO).

// !!BADLY DESIGNED CODE!!
[HttpGet]
public async Task<HttpResponseMessage> Get(string query)
    {
         return await this.cityRepository
         .AutocompleteCityAsync(query)
         .ContinueWith<HttpResponseMessage>(parentTask =>
            {
                var cities = parentTask.Result.MapCollection<TCity>();


                //Returns HttpResponseMessage.

                return this.CreateListResponse<TCity>(cities); 
            });
    }





As you can see in the example above by awaiting a citiRepository.AutocompleteCityAsync function I started an asynchronous operation (Task). When this function returns a result a next piece of code going to be invoked as I used a ContinueWith<T> function where T is a type of results that my continuation code returns. The problem is that in chained code I need to deal with a previous task itself and the only way to retrieve result of it is to access a Result property directly.




public static Task<TNewResult> Continue<TResult, TNewResult>(


 this Task<TResult> task,


 Func<TResult, Task<TNewResult>> continuation)
    {
        if (task == null)
        {
            throw new ArgumentNullException("task");
        }
 
        if (continuation == null)
        {
            throw new ArgumentNullException("continuation");
        }
 
        return task
            .ContinueWith(innerTask => continuation(innerTask.Result))
            .Unwrap();
    }









The continuation code can be easily re-factored by creating a simple extension method for a Task<T> type. As presented in code above, just by centralizing a call of the ContinueWith function with a custom continuation function followed by a Unwrap method a chaining become much cleaner. So then a Continue<TResult, TNewResult> function knows a type of result from a parent task and also know what type a continuation code going to return. Therefor let`s use it an see how a chaining looks like after I use my extension method. Please note that I`m not accessing a  parent Task.Result directly and instead of this I working just with a type returned by this task.




 [HttpGet]
 public async Task<HttpResponseMessage> Get(string query)
       {
           return await this.cityRepository


               .AutocompleteCity(query)
               .Continue<IQueryable<City>, HttpResponseMessage>(entities =>
               {
                   var cities = entities.MapCollection<TCity>();
                   return this.CreateListResponse<TCity>(cities);
               });


       }







So as conclusion, just by using a simple extension method, I was able to successfully re-factor a common task chaining logic which results in having more cleaner and easier to understand code.













Labels:














Location:
Dublin, Ireland













































Popular posts from this blog



















Persisting Enum in database with Entity Framework




























Problem statement We all want to write clean code and follow best coding practices. This all engineers 'North Star' goal which in many cases can not be easily achievable because of many potential difficulties with converting our ideas/good practices into working solutions.  One of an example I recently came across was about using ASP.NET Core and Entity Framework 5 to store Enum values in a relational database (like Azure SQL). Why is this a problem you might ask... and my answer here is that you want to work with Enum types in your code but persist an integer in your databases. You can think about in that way. Why we use data types at all when everything could be just a string which is getting converted into a desirable type when needed. This 'all-string' approach is of course a huge anti-pattern and a bad practice for many reasons with few being: degraded performance, increased storage space, increased code duplication.  Pre-requirements 1. Status enum type definition...

























more -->






























Creating common partial class with Entity Framework




























When we use the Entity Framework (EF) in multilayer information systems sometimes we want to extend classes generated by EF by adding some common properties or functions. Such operation can`t be conduct on *.edmx data model so we need to make some improvement in our solution. Let`s begin...     Lets assumed that in our soulution we have only three layer (three project):    Client console application which has reference to the second layer  - ' ConsoleApplication ' project name  Class library project with class interfaces only - ' Interfaces ' project name  Class library class implementation and data model referenced to 'Interfaces' project - ' Classes ' project name.     Picture 1. Solution structure.    Now when we have all solution structure we can focus on data model. In the ' Classes ' project we create a new folder named ' Model ' and inside add new item of ADO.NET Entity Data Model  named ' Learning.edmx ' - it may be empty ...

























more -->






























Using Hortonworks Hive in .NET




























 A few months ago I decided to learn a big data. This sounds very complex and of course it is. All these strange names  which actually tells nothing to person who is new in these area combined with different way of looking at data storage makes entire topic even more complex. However after reading N blogs and watching many, many tutorials today I finally had a chance to try to write some code. As in last week I managed to setup a Hortonworks distribution of Hadoop today I decided to connect to it from my .NET  based application and this is what I will describe in this post.     First things first I didn`t setup entire Hortonworks ecosystem from scratch - I`d love to but for now it`s far beyond my knowledge thus I decided to use a sandbox environment  provided by Hortonworks. There are multiple different VMs available to download but in my case I`ve choose a Hyper-V. More about setting this environment up you can read here .     Picture 1. Up and running sandbox environment.     Now whe...

























more -->