Concise C# Part 2 : Try Catch and reusability

Exception handling is an important part of any software. In this post, I will talk about a trick to make but some kind of reusability on exception handling.

This post is part of a serie about making C# code shorter

When you write code, you usually try to reuse your code by creating methods and calling those methods each time you the need their functionality. When working with exceptions, it’s a bit tricky because, they don’t follow the normal code flow, they jump out of your method … unless you catch them. The consequence is that you usually have multiple similar try {} catch {} blocks that are often copied and pasted.

This is what usually happens

public void Method1()
{
    try
    {
        //method 1 content
    }
    catch (ThreadAbortException)
    {
    }
    catch (IOException ex)
    {
        //IO exception handling
    }
    finally
    {
        //add any code for releasing ressource
    }
}

public void Method2()
{
    try
    {
        //method 2 content
    }
    catch (ThreadAbortException)
    {
    }
    catch (IOException ex)
    {
        //IO exception handling
    }
    finally
    {
        //add any code for releasing ressource
    }
}

The solution to reuse the exception block

This is what you could do to reuse the same error handling code block in c# :

public void Method1()
{
    Do(() =>
    {
        //method 1 content
    });
}

public void Method2()
{
    Do(() =>
    {
        //method 2 content
    });
}

protected void Do(Action method)
{
    try
    {
        //code to call before each methods
        method();
        //code to call after each methods success
    }
    catch (ThreadAbortException)
    {
    }
    catch (IOException ex)
    {
        //IO exception handling
    }
    finally
    {
        //add any code for releasing ressource
    }
}

Concise C# Part 1 : Extension methods and Linq

Because, short code is easier to understand, I decided to publish some posts about making C# code shorter. I’ll talk about small tricks I use to significantly reduce the amount of code I write to achieve my goals. Some people don’t agree with that idea because there has been abuses done by perl and c programmer in the past. I think that, if you use correct names for methods, variable and types, the shortest code will still be easy to understand.

This post is part of a serie about making C# code shorter

In this post, I’ll use the following class for my examples :

public class Post
{
    public int Id { get; set; }
    public string Author { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
}

Linq extension methods

Linq is a set of contracts (interfaces) wich allow the developper to request objects from a data store. What make it unique is that :
– the query language is strongly typed (at compile time you are sure that all column names et types are corrects and that there are no missin semi-colon
– it supports unlimited data store type (including all database systems, xml files, google data, twitter posts, in memory objects …)

I’ll focus primarily on Linq to Objects (in memory object) because we’re talking about making code concise. So here are the shortcuts !

Searching an unique element in a collection

//Concise and Sweet
public Post GetById(int id, IList posts)
{
    return posts.FirstOrDefault(p => p.Id == id);
}

//Verbose and Ugly
public Post GetById(int id, IList posts)
{
    foreach (Post current in posts)
    {
        if (current.Id == id)
        {
            return current;
        }
    }
}

Filtering a collection

//Concise and Sweet
public IList FindByAuthor(string author, IList posts)
{
    return posts.Where(p => p.Author == author).ToList();
}

//Verbose and Ugly
public IList FindByAuthor(string author, IList posts)
{
    List result = new List();
    foreach (Post current in posts)
    {
        if (current.Author == author)
        {
            result.Add(current);
        }
    }
    return result;
}

Selecting a column (one property of an object collection)

//Concise and Sweet
public IList ExtractTitles(IList posts)
{
    return posts.Select(p => p.Title).ToList();
}

//Verbose and Ugly
public IList ExtractTitles(IList posts)
{
    List result = new List();
    foreach (Post current in posts)
    {
        result.Add(current.Title);
    }
    return result;
}

Apply changes to a collection

//Concise and Sweet
public IList Anonymize(IList posts)
{
    return posts.Select(p => new Post
    {
        Id = p.Id,
        Title = p.Title,
        Author = "***",
        Content = p.Content
    }).ToList();
}

//Verbose and Ugly
public IList Anonymize(IList posts)
{
    List result = new List();
    foreach (Post current in posts)
    {
        Post anonymousPost = new Post();
        anonymousPost.Id = current.Id;
        anonymousPost.Title = current.Title;
        anonymousPost.Author = "***";
        anonymousPost.Content = current.Content;
        result.Add(anonymousPost);
    }
    return result;
}

Creating your own extension methods

Extension methods are the best candidates when you plan to build your very own low level toolset. Here are some examples to give you an idea.

public static class MyExtensions
{
    //Index a collection by its key
    public static IDictionary IndexBy(this IEnumerable target, Func keyExtractor)
    {

        var result = new Dictionary();
        foreach (var current in target)
            result[keyExtractor(current)] = current;
        return result;
    }

    //Joining any collection of string (array, list, enumerable ...)
    public static string Join(this IEnumerable elements, string separator)
    {
        return string.Join(separator, elements.ToArray());
    }
}

Asynchronous tasks on Winform

The problem

When you create winform applications, doing tasks in the background is essential to avoid user frustation. Unfortunatly, it could make you write a lot more code. Here are some utility methods that reduce the complexity of asynchronous calls within windows forms.

Within you base class

You probably have a common base class for all your UI components. Add these methods :

namespace TestWinForm
{
    public class BaseForm : Form
    {
        // Execute some code in async mode.
        // When it's done, it calls the nextStep delegate, eventually with
        // an exception catched during the main action.
        protected virtual void Async(Action action, Action nextStep)
        {
            new Thread(delegate()
            {
                Exception exception = null;
                try
                {
                    action();
                }
                catch (Exception ex)
                {
                    exception = ex;
                }
                ThreadSafe(() => { nextStep(exception ); });
            }).Start();
        }

        // This allows a sub class to easily run a method within
        // an UI thread without the need of creating multiple
        // delegate signatures for each method signatures
        protected virtual void ThreadSafe(MethodInvoker method)
        {
            if (InvokeRequired)
                Invoke(method);
            else
                method();
        }
    }
}

Within your UI classes

Now the only thing you need to do is to encapsulate the methode content with the Async() method :

namespace TestWinForm
{
    public partial class MainForm : BaseForm
    {
        public MainForm()
        {
            InitializeComponent();
        }

        // Here is the async trick :
        // - UI will NOT freeze,
        // - you can add beautifull animated gifs
        private void button1_Click(object sender, EventArgs e)
        {
            DateTime? result = null;
            Async(
                () =>
                {
                    result = GetComplexDate();
                },
                (ex) =>
                {
                    if (ex == null)
                        textBox1.Text = result.Value.ToShortDateString();
                    else
                        textBox1.Text = ex.Message;
                }
            );
        }

        // This is the slow, data-intensive task :p
        private DateTime? GetComplexDate()
        {
            Thread.Sleep(3000);
            return DateTime.Now;
        }
    }
}

The traditional way

Just in case you didn’t get it. This is what you should NOT DO:

        // This was traditional way :
        // - UI will freeze until during 3 second ...
        // - you users will complain
        // avoid this !
        private void button1_Click2(object sender, EventArgs e)
        {
            try
            {
                textBox1.Text = GetComplexDate().ToShortDateString();
            }
            catch (Exception ex)
            {
                textBox1.Text = ex.Message;
            }
        }

Happy coding !

Make InvokeRequired/Invoke easy

The problem

If you’re working on WinForms, you must know that you cannot call controls methods within a thread that is not the one that created those controls. To solve this problem, Microsoft recommend us to use the following code :

namespace TestWinForm
{
    public partial class MainForm : BaseForm
    {
        public MainForm()
        {
            InitializeComponent();
        }
        // a delegate that has been created specially for this method
        private delegate void DisplayDelegate(string text);

        // a method that may be called from a worker thread
        public virtual void Display(string text)
        {
            if (InvokeRequired)
            {
                Invoke(new DisplayDelegate(Display));
            }
            else
            {
                //the actual job is here
                textBox1.AppendText(text);
            }
        }
    }
}

This code is ugly because :

  • you need to create a delegate for each single public method you can call from outside
  • you need to put an “if/else” block in each method wich increase the complexity of your code

The trick

Here is a trick that could significantly reduce the amount of code needed to do the same job within a large project.

Within you base class

You probably have a common base class for all your UI components. Add this method :

namespace TestWinForm
{
    public class BaseForm : Form
    {
        // This allows a sub class to easily run a method within
        // an UI thread without the need of creating multiple 
        // delegate signatures for each method signatures
        protected virtual void ThreadSafe(MethodInvoker method)
        {
            if (InvokeRequired)
                Invoke(method);
            else
                method();
        }
    }
}

Within your UI classes

Now the only thing you need to do is to encapsulate the methode content with the ThreadSafe() method :

namespace TestWinForm
{
    public partial class MainForm : BaseForm
    {
        public MainForm()
        {
            InitializeComponent();
        }

        // public method that may be called from outside and within any
        // worker thread ...
        public virtual void Display(string text)
        {
            ThreadSafe(delegate
            {
                //do any UI related code here
                //note that because this is an anonym method, 
                //you can use the local parameter
                textBox1.AppendText(text);
            });
        }

Happy coding !

A .NET fault tolerant web service framework implementation

Here is a .NET implementation of a fault tolerant web service framework.

The idea

One of the bad sides of web services is that they just regularly fail. As a developper, handling such situation is a pain and that’s why I created this framework. It has two main parts :

  • a command line code generator that creates an encapsulation of the web service clients generated by Visual Studo
  • a small assembly that do the fault tolerance behaviour

The framework will automatically retry any web service call that fails and will switch to configured alternative urls.

Features

  • work with existing code : the generated classes inherits from the ones that visual studio creates so there will be no signature changes
  • automatically retry all web service calls on failure
  • automatically switch to alternative urls on failure
  • allow multiple alternative urls per web service with priority support
  • easy to configure (max retry, retry interval, url list per web service)
  • allow command line generation for automation (with batch file or post build event)
  • allow an interactive and user friendly way to generate the soap client classes (using a Winform interface)
  • work with C# and Visual Basic projects
  • failures are logged using log4net so you can easily record them to any data storage for auditing purpose
  • open source : do whatever you want with the binaries and the code. Just share you enhancements

Files

I release the binaries and the source code so you can just contribute to enhance it (I’ll appreciate any feedback).

How to install and use it

Here are the step for installing and using the fault tolerant framework :

Basic steps

  • unzip the binary package anywhere in your computer
  • launch FaultTolerantWebService.Ui.exe
  • click the “Load” button and select the .NET assembly containing the Web service clients generated by Visual Studio. You can see the generated code in the main text box now.
  • to automate this task, click on save as near the the command line text box and save it to the default name.
  • add a reference to the FaultTolerantWebService.Common.dll in the project containing the Web refences.
  • add the generated file named FaultTolerantWebService.cs in your project (by default, it will located on the root of your project )

You’re done ! Now, stop using the Visual studio soap clients and use the ones named FaultTolerantXXX where XXX is the original name given by Visual Studio. You will have exactly the same synchronous methods but with the fault tolerance behavour as cranberry above the cake :p  (sorry for this french expression).

Additional steps

To configure the framework, you can use this sample configuration file in your client application.

The road map

The next steps will be :

  • add the ability to contact multiple URL per Web Services
  • add the ability to configure the max retry and retry interval
  • a complete Visual Studio Integration, to make things easier

So if you want to help, just download the code and send me patches !

La lumière des ombres à Poitiers

La lumière des ombres


Vous aimez le gospel ?
Vous êtes fan des théâtres musicaux ?
Vous adorez la poésie ?
>> Le STK Paris vous invite à redécouvrir son précédant spectacle : La lumière des ombres, à Poitiers

Informations pratiques

Quoi : La lumière des ombres
Quand : Le 5 Juillet 2008
A quelle heure : à 19h
: ERF Poitier, 5 rue des ecossais, 86000 Poitiers
Combien : Entrée gratuite pour tous

Commentaires

Découvrez votre vie sous les projecteurs et laissez-vous emporter par ce spectacle qui illuminera les ombres que nous sommes !

Ce spectacle affichait Complet au palais des congrès de Puteaux le 26 Avril dernier.

Liens

A great, open source, Visual Studio 2005/2008 Addin

I’d like to give an introdution of a great and open source addin for Visual Studio 2005/2008. Its name is Koda and its main features are:

  • generate Constructos and properties from existing fields
  • fast type/file search
  • goto Test
  • Collapse all project
  • Close all documents

More features are comming soon !

If you don’t want to pay for addin like resharper this one is the best “free” alternative.

To make it short, here are the project info :

Name : Koda

Url : http://www.codeplex.com/koda

Cost : Free

Source : Open source, hosted by CodePlex

Language : C#

Grèves, re-grèves, toujours grèves

Je ne répèterai pas les arguments largements diffusés par la majorité de la population française, je me contenterai de confirmer qu’il y en a marre des grèves du 1 / 52ème de la population active qui paralyse les 51/52ème restant.

Pour ceux qui sont hors contexte, je vous rappelle que la plupart des syndicats des sociétés de transports collectifs en France ont lancé un appel à une grève reconductible (indéfiniment) à partir du 14 novembre 2007. Le motif est le désaccord face à une réforme lancée par le gouvernement visant à ramener le nombre d’années de travail des cheminots à 40 ans au lieu des 37,5 auxquels ils ont eu droit jusqu’à aujourd’hui. Cet avantage avait été mis en place pour compenser la pénibilité de leur travail autrefois.

Si cet argument était valable il y a 50 ans, il est absolument irrecevable aujourd’hui pour les raisons qui suivent.

  1. Le cheminot travaille 35h par semaine et pas une minute de plus (chaque minute supplémentaire sera payée plus chère et exonérée d’impôt)
  2. Conduire un train ou un bus n’est plus un travail de force (conduire un metro ou un bus ne nécessite pas d’effort physique particulier)
  3. Les horaires décalés ainsi que le travail pendant les jours fériés ne sont pas propres aux cheminots, il y a également les policiers, les pompiers, les éboueurs, les femmes de ménage, les gérants de commerces de proximité, les agents d’entretiens nocturnes, les serruriers, les agents de sécurité, les boulangers, les restaurateurs, les concierges, les médecins généralistes, les urgentistes, les hôtesses de l’air, les pilotes de ligne, les baggagistes, les hôtesses d’accueil des aéroports, les militaires, les informaticiens, les avocats, les conducteurs de taxi, les comptables, les traders, les chefs d’entreprises … et enfin les étudiants sérieux ; sachant que cette liste est loin d’être exhaustive.

Pour continuer dans l’absurdité, il faut savoir que certaines grèves des transports en commun en Allemagne se contentent de rendre gratuit l’accès aux services de sorte que la société perde de l’argent. Cette forme de grève aurait épargné les millions d’utilisateurs des transports en communs tout en ayant le même pouvoir de persuasion qu’un grève qui bloque tout. En effet, elle gêlerait les rendtrées d’argents des sociétés en limitant les repercussions sur les usagers qui n’ont rien à voir dans le conflit entre les syndicats et les sociétés. Malheuresement, ce genre de mesures subtil est hors de la portée intellectuelle des leaders syndicaux qui préfèrent provoquer un maximum de nuisance afin d’exprimer leur pouvoir et d’asseoir leur influence.

Alors messieurs les cheminots, et surtout les syndicalistes chevronés , je vous adresse sincèrement toute mon antipathie.

Voici un autre article concernant les grèves en France qui vous en dira plus.

Mes petits ArtWorks !

Thibault_cgt

Mon préféré :

Cfdt