C# – Mot-clé default

En C#, il est possible de représenter la valeur par défaut d'un type (0 pour un entier, 0.0 pour un double, null pour une référence, etc.) par le mot clé default, ce qui simplifie un peu l'écriture du code générique.

En effet, s'il est clair que 0 peut être une valeur par défaut acceptable pour un int, que 0.0f peut convenir aux float, ou que false peut être approprié pour un bool, qu'en est-il d'un type T quelconque? Par exemple :

static T PeutÊtreFaireQuelqueChose(Func<T> f)
{
   T résultat; // notez : pas initialisée
   try
   {
      // ... gérer des ressources pour lesquelles un finally serait utile
      résultat = f(); // Ok, f retourne un T
      // ...
   }
   finally
   {
      // ... nettoyage
   }
   return résultat; // ICI : ne compile pas, résultat n'est pas initialisée
}

En C#, si nous souhaitons apposer la valeur par défaut appropriée à un T dans la variable résultat pour une fonction comme celle-ci, une valeur symbolique spéciale nommée default permet de le faire. On peut donc réécrire la fonction comme suit pour qu'elle compile :

static T PeutÊtreFaireQuelqueChose(Func<T> f)
{
   T résultat = default; // valeur par défaut du type T
   try
   {
      // ... gérer des ressources pour lesquelles un finally serait utile
      résultat = f(); // Ok, f retourne un T
      // ...
   }
   finally
   {
      // ... nettoyage
   }
   return résultat; // ICI : ne compile pas, résultat n'est pas initialisée
}

Le concept ne s'arrête d'ailleurs pas à l'initialisation des variables. Par exemple, ceci est légal :

static T PossibleTransfo<T>(T arg, Func<T,T> transfo, Func<T,bool> pred)
{
   if(pred(arg))
      return transfo(arg);
   return default; // légal
}
static T Test<T>(T arg, Func<T,bool> pred)
{
   if(PossibleTransfo(arg, x => x, pred) == default) // légal
      throw new Exception("Eh ben");
   return arg;
}

Lectures complémentaires

Quelques liens pour enrichir le propos.

(à venir)


Valid XHTML 1.0 Transitional

CSS Valide !