The .Net frog

Dans une application asp.net, de base, les fichiers aspx ne sont pas compilés. Cette étape est réalisée par IIS lors du déploiement. En conséquence, toute erreur de syntaxe dans l'un de ces fichiers passera inaperçue lors de la compilation de la solution par le serveur d'intégration continue. Comme les vues sont rarement testées, on peut donc facilement se retrouver à déployer des fichiers contenants des erreurs de syntaxe... Aïe!

Pour éviter ce problème, il est possible d'appeler l'outil aspnet_compiler.exe directement depuis le fichier de build nant. Les quelques lignes suivantes auront donc pour effet de provoquer la compilation de l'ensemble des fichiers aspx de la solution et donc de rapporter toute erreur, magique!

 
<property name="build.dir" value="${build.base}/${project::get-name()}-${project.config}/"/>
<property name="aspxbuild.dir" value="${build.dir}\aspx" />
<property name="aspxvirtual.dir" value="${build.dir}\iis" />
 
<mkdir dir="${aspxbuild.dir}" />
    <mkdir dir="${aspxvirtual.dir}" />
    <copy todir="${aspxbuild.dir}">
      <fileset basedir="${aspx.dir}">
        <include name="**" />
      </fileset>
    </copy>
 
    <mkiisdir dirpath="${aspxvirtual.dir}" vdirname="aspprecompile" />
    <exec program="C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\aspnet_compiler.exe" useruntimeengine="true">
      <arg value="-p" />
      <arg value="${aspxbuild.dir}" />
      <arg value="-v" />
      <arg value="aspprecompile" />
      <arg value="${aspxvirtual.dir}" />
    </exec>
    <deliisdir vdirname="aspprecompile" />
    <delete dir="${aspxvirtual.dir}" />
 

Remarque: il faut avoir installé iis et NantContrib sur le serveur de build !

J'utilise un préfixe (A savoir: "_") pour indiquer les membres privés de mes classes. Autrement dit, une de mes classes ressemblera à cela:

public class Car
{
    private string _model;
    private string _owner;
    [...]
}

Différentes notations existent ici et là, notamment "m_". Mais de nombreuses personnes ont aussi choisi de ne simplement pas démarquer les membres privés des variables locales et autres paramètres. Je suis tout à fait conscient que c'est un sujet polémique, et que les avis sont très partagés. J'aimerai toutefois expliquer pourquoi je trouve personnellement qu'il est important d'avoir cette distinction.

En guise de référence, voici ce à quoi pourrait ressembler une classe sans préfixe:

public class Transportation
{
    private TransportStatus status;
 
    public  TransportStatus Status
   {
        get { return status; }
    }
 
    public void ChangeTransportStatus(TransportStatus status)
    {
        this.status= status;
        DoSomeStuff();
    }
}

Il y a plusieurs problèmes avec cette classe:

• Utiliser un préfixe permet de se passer du mot clef "this", ce qui réduit le "bruit" dans les sources. En effet, écrire "this.model" revient en quelque sorte à utiliser un préfixe ("this."). Autant utiliser quelque chose de plus court du coup!
• Qui plus est, l'utilisation de "this" est optionnelle en C#. On se retrouve rapidement avec un mélange des genres ou certains accès sont fait avec "this". et d'autres le sont sans aucun préfixe. Si on ne connait pas bien le code, on est obligé de constamment vérifier si telle variable est privée avec l'intellisense ou en naviguant dans la classe.
• L'absence de préfixe provoque rapidement des confusions. Par exemple, dans la fonction ChangeTransportStatus, 2 variables ont le même nom: mon paramètre et mon membre privé. Le code étant ici très simple, il est difficile de se tromper. Dans une fonction de 50 lignes, il peut y avoir potentiellement beaucoup plus d'erreurs: il est courant d'utiliser le paramètre à la place du membre...
• J'ai également une propriété "Status" qui ressemble énormément à mon membre privé "status" dans mon exemple. L'utilisation du mot clef "this" ne règle en rien la confusion potentielle. Sans préfixe il faut donc être très attentif à l'utilisation des majuscules. Sur certaines lettres la distinction est évidente, sur d'autres, elle l'est beaucoup moins! L'expérience montre que sans préfixe, le code d'une classe utilisera plus ou moins aléatoirement la propriété ou le membre privé en fonction de la rigueur et/ou de l'humeur des développeurs. Pour peu que la propriété encapsule un peu de logique, on se retrouve rapidement avec des effets de bord indésirable.
• Enfin, et je vous accorde que c'est un argument très discutable mais les nouveaux outils de Microsoft génère le code avec des préfixes (voir Linq to Sql par exemple). Si eux le font, c'est peut être qu'il y a du bon ;-).

Alors, prêt à utiliser un préfixe? :-)

J'ai eu l'occasion de m'apercevoir qu'il y avait un certain besoin autour de trucs et astuces sur .NET. Je vais donc dorénavant essayer de poster ce qui me passera par la tête :). A noter que ces billets ont vocation à être court et couvrir des points très précis!

Comment vérifier qu'une chaine de caractère est vide de façon optimale?

Il existe plusieurs façon de faire la comparaison:
1) myString == ""
2) myString == String.Empty
3) myString.Length == 0
4) String.IsNullOrEmpty(myString)

La façon la plus performante est la solution 3, myString.Lengh == 0, à condition d'être sur que la chaine de caractère n'est pas nulle. Si la chaine de caractère peut potentiellement être nulle, String.IsNullOrEmpty(myString) est idéal. A noter d'ailleurs que String.IsNullOrEmpty(myString) utilise lui même string.Length == 0. En voici l'implémentation en guise de référence:

public static bool IsNullOrEmpty(string value)
{
    if (value != null)
    {
        return (value.Length == 0);
    }
    return true;
}