Les 5 méthodes d’extension que vous devez connaitre

Je vous propose de découvrir les méthodes d’extensions que j’utilise le plus souvent et qui pourront très certainement vous servir pour gagner en efficacité au quotidien.

IsNull

// Permet de vérifier si un objet est null
public static bool IsNull(this object source)
{
    return source == null;
}

Cette extention peut s’utiliser comme ceci :

void Main()
{
if (obj.IsNull())
    {
        // traiter le cas null
    }
}

FormatWith

// Permet de formater une chaine de caractères
public static string FormatWith(this string format,
                         params object[] args)
{
    return string.Format(format, args);
}

Cette extension peut être utilisée comme ceci :

var resultat = "Ceci est le résultat: A={0}, B={1}".FormatWith(a, b);

ToInt / ToDouble

// Convertir une string en int avec valeur par défaut
public static int ToInteger(this string value,
                      int defaultvalue)
{
    return (int)ToDouble(value, defaultvalue);
}

// Convertir en int (valeur par défaut = 0)
public static int ToInteger(this string value)
{
    return ToInteger(value, 0);
}

// Convertir en double
public static double ToDouble(this string value)
{
    return ToDouble(value, 0);
}

// Convertir en double avec valeur par défaut
public static double ToDouble(this string value,
                         double defaultvalue)
{
    double result;
    if (double.TryParse(value, out result))
    {
    return result;
    }
    else
        return defaultvalue;
}

Vous pourrez utiliser ces extensions comme ceci :

int valeur = "1233".ToInteger();

// appel avec une valeur par défaut
double autre = "3.14".ToDouble(1.0);

In

// Vérifier si un élement est contenu dans une liste
public static bool In<T>(this T source, params T[] list)
{
    if (null==source) throw new ArgumentNullException("source");
    return list.Contains(source);
}

Cette méthode bien pratique pourra être utilisé pour remplacer ce code :

if(reallyLongIntegerVariableName == 1 ||
reallyLongIntegerVariableName == 6 ||
reallyLongIntegerVariableName == 9 ||
reallyLongIntegerVariableName == 11)
{
    // faire quelque chose...
}

if(reallyLongStringVariableName == "string1" ||
reallyLongStringVariableName == "string2" ||
reallyLongStringVariableName == "string3")
{
    // faire quelque chose...
}

if(reallyLongMethodParameterName == SomeEnum.Value1 ||
reallyLongMethodParameterName == SomeEnum.Value2 ||
reallyLongMethodParameterName == SomeEnum.Value3 ||
reallyLongMethodParameterName == SomeEnum.Value4)
{
    // faire quelque chose...
}

Par celui-ci (plus simple et plus lisible) :

if(reallyLongIntegerVariableName.In(1,6,9,11))
{
    // faire quelque chose...
}

if(reallyLongStringVariableName.In("string1","string2","string3"))
{
    // faire quelque chose...
}

if(reallyLongMethodParameterName.In(SomeEnum.Value1, SomeEnum.Value2, SomeEnum.Value3, SomeEnum.Value4)
{
    // faire quelque chose...
}

Pour aller plus loin

Il existe un projet sur CodePlex qui regroupe une grande quantité de méthode d’extensions prêtes à être utilisées, je vous invite donc à le télécharger et à l’utiliser pour faciliter votre quotidien: Extension overflow.