Bnaya Eshet : SELA, SDP, TAP

The 3rd day of the SDP

bnaya — Wed, 08 May 2013 04:17:58 GMT

The 3rd day of the SDP was over and I want to thanks all the attendants.
my yesterday session was about C# 5 async and await.

today I will have a full day tutorial on Rx and TPL Dataflow.
you can download the demo code and also the presentation for second and third days from here (the link is also having the demo code for today's sessions).

anyway, I also want to recommend 2of yesterday session.

if you were attend at the conference you should have an access to the sessions video page.
first I want to recommend Ofir Makmal's session about .NET 4.5 CLR improvements.

Ofir was talking about subjects like:

Multi-core JIT
Managed Profile Guided Optimization
Auto-Ngen
Background Server GC

my favorite subject was Multi-core JIT.

the following is a snippet for Multi-core JITing.

Code Snippet
 static void Main(string[] args)
{
    ProfileOptimization.SetProfileRoot(@"C:\MyApplicationFolder");
    ProfileOptimization.StartProfile("startup.profile");
}
 

my second recommendation is Manu Cohen-Yashar's session about .NET cryptography.
Manu's talk is great for anyone who want to use the .NET cryptography library.

Async - Handling multiple Exceptions

bnaya — Mon, 10 Dec 2012 06:30:25 GMT

Async - Handling multiple Exceptions

the SDP conference was ended a few week ago and I finally find a time to write some comments.

It was a very successful conference, the feedback and evaluations, of most sessions scored higher than 4.5, some well-over it. For example, one workshop had a perfect 5 / 5 score, and two other workshops scored 4.92 / 5 and 4.9 / 5. The highest score for a breakout session was 9.39 / 10, which is the highest score we’ve seen to date. my score was 4.90 / 5.

but this post isn't about scores, it is about fixing a sample that I was showing at the SDP about exception handling within the async / await context.

when you do use the great async / await syntax you may run into a problem while trying to handle multiple exception which was thrown from async operations (it can happens in cases like parent child relationship or when using WhenAll API).

by design the catch closure will handle the first exception and ignore all the other, you can read about it in here.

the following code will catch a single NullReferenceException or ArgumentException exception (the AggregateException will be ignored):

Code Snippet
     try
    {
        await Task.Factory.StartNew(() =>
            {
                Task.Factory.StartNew(() => 
                    { throw new NullReferenceException(); },
                        TaskCreationOptions.AttachedToParent);
                Task.Factory.StartNew(() => 
                    { throw new ArgumentException(); },
                        TaskCreationOptions.AttachedToParent);
            });
    }
    catch (AggregateException ex)
    {
        // this catch will never be target
    }
    catch (Exception ex)
    {
        Console.WriteLine("## {0} ##", ex.GetType().Name);
    }
}
 

if you do want to catch the AggregateException you can use the following work around :

Code Snippet
 try
{
    Task t = Task.Factory.StartNew(() =>
        {
            Task.Factory.StartNew(() => 
                { throw new NullReferenceException(); },
                    TaskCreationOptions.AttachedToParent);
            Task.Factory.StartNew(() => 
                { throw new ArgumentException(); },
                    TaskCreationOptions.AttachedToParent);
        });
    await t.ContinueWith(tsk => { if (tsk.Exception != null) throw tsk.Exception; });
}
catch (AggregateException ex)
{
    foreach (var exc in ex.Flatten().InnerExceptions)
    {
        Console.WriteLine(exc.GetType().Name);
    }
}
 

the difference is at line 12, I'm using a continuation that re-throw the AggregateException.

because this is a fairly common practice you may better wrap it within an extension method like the following one:

Code Snippet
 public static Task ThrowMultiple(this Task t)
{
    return t.ContinueWith(tsk => { if (tsk.Exception != null) throw tsk.Exception; });
}
 
public static Task<T> ThrowMultiple<T>(this Task<T> t)
{
    return t.ContinueWith(tsk => 
    {
        if (tsk.Exception != null)
            throw tsk.Exception;
        return tsk.Result;
    });
}
 

you can use it as follow:

Code Snippet
 try
{
    await Task.Factory.StartNew(() =>
        {
            Task.Factory.StartNew(() =>
                { throw new NullReferenceException(); },
                    TaskCreationOptions.AttachedToParent);
            Task.Factory.StartNew(() =>
                { throw new ArgumentException(); },
                    TaskCreationOptions.AttachedToParent);
        }).ThrowMultiple();
}
catch (AggregateException ex)
{
    foreach (var exc in ex.Flatten().InnerExceptions)
    {
        Console.WriteLine(exc.GetType().Name);
    }
}
 

Summary

catching a single exception within an async method is a design decision,
but you may want to override this decision in some scenarios.

I hope that in a future release of .NET framework Microsoft consider to throw an AggregateException when the compiler will detect that the developer was adding an AggregateException catch block.

in the meantime you can use the extension methods.

you should not forget to catch a non AggregateException if you have any code before the await (this code will run synchronously).

My session at the SDP

bnaya — Tue, 13 Mar 2012 12:15:35 GMT

Sela conferences (SDP) is coming near (25-29/3/2012).

you can check the following link for all the SDP's tutorials and sessions http://www.sela.co.il/s/SDP2012/index.html.

I will present 2 full-day tutorials (Yaniv Rodenski will join me on the first one).

the first day Introduction to the Task Parallel Library is a full TPL 4 day which will give you a solid knowledge, HowTo and Consideration about building parallel application using the TPL library.
at the end of this day we will survey some improvement made in .NET 4.5 to the existing TPL Library.

the second day Parallel Programming: One Step Beyond assume that the audience are already familiar with TPL (or participate in the first day).
this day will focus on 3 subject:

The new async/await keywords (.NET 4.5 / C# 5)
TPL Dataflow (which is new level of abstraction above the TPL - also .NET 4.5 / C# 5)
Rx (Reactive Extension) which is a great Library for parallel composition over LINQ.