Approfondissements

A propos du code MSIL

Lorsque l'on compile un fichier avec le compilateur C# (ou tout autre qui respecte la CLS) un fichier .dll ou .exe est généré, mais ces fichiers n'ont rien à voir avec les anciennes dll et exe windows. Le fichier (ou l'ensemble de fichiers s'il s'agit d'un projet) est appelé un assembly (assemblage).

Etudions un exemple :

public class Bonjour{
        public static void Main(){
                       System.Console.WriteLine("Bonjour");
        }
}

Compilons ce fichier bonjour.cs écrit en C#.

Un fichier bonjour.exe est créé, nous allons utiliser un logiciel de désassemblage fourni par VisualStudio.Net, ILdasm; si nous ouvrons le fichier exécutable, nous pouvons visualiser les différents éléments :

L'assembly contient

- un manifest, description de l'assembly lui-même :

- le code MSIL du programme, ouvrons la méthode Main :

On voit que le code généré fait appel aux fonctions du framework.

Le gros avantage de cette organisation réside dans la simplicité de déploiement (simple copie dans un répertoire), l'auto-description de l'assembly affranchit de toute installation référençant des DLL souvent obsolètes ainsi que l'inscription dans la base de registre.

retour

Champs et propriétés.

C# différencie deux concepts proches :

- Les champs correspondant à ce que nous nommions attributs, ils sont privés

- Les propriétés assimilables aux accesseurs/modificateurs (méthodes Get/Set); ainsi la déclaration d'une classe peut prendre l'allure :

class Personne{

                public Personne(string nom,int age){
                              this.nom = nom;
                              this.age = age;
                 }
//*************Définitions des propriétés publiques*********
                public string Nom{
                                   get{
                                        return this.nom;
                                       }
                                   set{
                                         this.nom= value;
                                        }
                }
                public int Age{
                               get{
                                      return this.age;
                                    }
                                set{
                                     this.age= value;
                                     }
                 }
//**********Déclaration des champs privés******************
private string nom;
private int age;
}

L'utilisation des propriétés est analogue à celle d'un champ privé :

Personne p = new Personne ("toto",10);
p.Age++;
Console.WriteLine(p.Age);

Notez l'affectation "directe" p.Age++; et l'absence de parenthèse dans l'utilisation des propriétés. Ainsi la propriété à la "couleur et l'odeur" d'un attribut, mais ce sont des méthodes; il est bien sûr possible de ne faire figurer que la méthode get dans la définition de la propriété.

Remarque : on reconnait ici les "Property" des modules de classe de VB6.

Regardons maintenant le code IL généré :

fig 1 : désassemblage de l'assembly

On voit la création de 4 accesseurs/modificateurs "classiques" ainsi que la présence de deux "Property" (Age et Nom) :

fig 2 méthode set_Age créée par C#

Si l'on regarde maintenant le code du Main :

fig 3 code MSIL du Main avec Property

L'instruction p.Age++; génère l'appel de deux méthodes, get_Age() et set_Age(). Il semble bien que cette version avec présence de "property" ne permet aucune optimisation, pour s'en convaincre regardons le code généré dans le cas de méthodes accesseurs/modificateurs (GetAge/SetAge) :

fig 4 code MSIL du Main avec des accesseurs/modificateurs

retour

retour