Il s’agit d’une philosophie de développement qui propose une manière de travailler. Je vous la présente car elle primordiale à mes yeux.

Qu’est-ce-que l’ouvert-fermé?

En fait, par ouvert-fermé, il faut comprendre ouvert aux évolutions et fermé aux modifications.

Cela veut dire qu’une classe a la capacité d’être étendue (ajout de nouvelles fonctionnalités), sans pour autant que le code existant qui implémente un comportement soit modifié.

Appliquer le principe OCP permet d’assurer une architecture évolutive sans allonger la durée des tests et de la maintenance.

Le principe a été énoncé la première fois en 1988 par le Docteur Bertrand Meyer.

Pourquoi utiliser OCP?

OCP impose les règles suivantes:

• une classe doit être extensibles,
• pour ajouter une fonctionnalité ou modifier un comportement, il ne faut pas toucher au code existant.

Ceci entraine plusieurs conséquences:

• L’extensibilité: il faut donc réfléchir en amont aux extensions possibles. Il faut prévoir dans l’architecture des points d’extensions (par héritage, par événements ou autres) ;
• Le code testé n’est pas modifié: ce qui veut dire que les nouveaux bugs apparaitront dans votre nouveau code ;

Un exemple concret

Dans la pratique, j’utilise le framework ASP.NET MVC pour le développement des applications Web. Ce framework est une sur-couche de ASP.NET de Microsoft.

ASP.NET MVC permet d’ajouter des attributs sur les méthodes d’action des controlleurs. Ces attributs permettent de modifier le comportement d’une action avant ou/et après son exécution.

Prenons un exemple simple:

• Nous venons d’écrire une action qui effectue le chargement d’une liste d’utilisateurs en fonction du numéro de la page ;
• Nous testons notre code (en écrivant par exemple des tests unitaires) ;
• Plus tard, nous souhaitons ajouter un nouveau comportement à cette action: imposer l’authentification de l’utilisateur avec un rôle précis. Dans ASP.NET MVC, il suffira d’ajouter l’attribut Authorize sur la méthode pour que le framework demande automatiquement à l’utilisateur de s’authentifier lors de l’appel de cette action.

C’est donc ici un exemple d’OCP: le code existant de l’action n’est pas modifié et pour l’étendre, il suffit d’ajouter un attribut avant la méthode.

Voici un exemple en C# pour être plus clair:

public ActionResult Index(int page)
{
  List users = _userRepository.GetUsers(page);
  return View(users);
}

En appliquant l’attribut de sécurité, cela donne le code suivant:

// On demande d'être authentifié et d'avoir le rôle d'administrateur
[Authorize(Roles="Admin")]
public ActionResult Index(int page)
{
  List users = _userRepository.GetUsers(page);
  return View(users);
}

Pour en savoir plus sur les attributs et l’extensibilité, je vous invite à consulter l’excellent billet de Rob Conery: http://blog.wekeroad.com/blog/aspnet-mvc-securing-your-controller-actions/.

Pour aller plus loin

J’espère avoir attiré votre attention sur ce principe. Pourquoi pas essayer de le mettre en place dans vos prochains développements?

Voici quelques liens qui vous permettront d’en savoir plus sur OCP:

• Un article de Microsoft: http://msdn.microsoft.com/fr-fr/magazine/cc546578.aspx
• Un billet de Emmanuel Deloget: http://blog.emmanueldeloget.com/index.php/2006/09/21/15-le-principe-ouvert-ferme
• La présentation de Wikipedia: http://en.wikipedia.org/wiki/Open/closed_principle
• Extensibilité dans ASP.NET MVC: http://codeclimber.net.nz/archive/2009/04/08/13-asp.net-mvc-extensibility-points-you-have-to-know.aspx

Popflyest le dernier né des éditeurs de mashus pour Silverlight. Silverlight, comme vous le savez peut être, est un plugin pour les navigateurs internet qui est la réponse à Adobe Flash. Microsoft veut répliquer face à Flash et Silverlight risque bien de faire peur à Adobe car il apporte des éléments très convaincants (dont le support du codec vidéo VC-1 qui semble encore meilleur que le H264 pour de la vidéo HD en plein écran).

Bon revenons à Popfly. Il s’agit donc d’un mashup creator. Un mashup est une application créée à partir d’un mélange de services (en général des services web). Popflypermet donc de gérer les connexions entre ces services et de créer des applications pour Silverlight.

L’avantage de Popfly, par rapport à un atelier logiciel, est qu’il est entièrement visuel: on prend un bloc fonctionnel, on le pose, on en prend un second et on crée une connexion entre les deux. L’utilisation est simple et accessible à n’importe quelle personne quasiment: plus besoin d’être développeur pour créer une application. Voici donc la nouvelle attaque de Microsoft!

Bien sûr, Popfly ne va pas mettre tous les développeurs au chômage, bien loin de là! En effet, le logiciel propose quelques blocs par défaut. Ces blocs fournissent des fonctions de base: recherche d’images, modules de sortie, gestion de flux RSS… Les développeurs seront chargés de créer des blocs personnalisés pouvant réaliser des fonctionnalités complètement différentes. Popflypropose les briques de bases pour créer une application Silverlight rapidement.

Je vous invite à essayer Popfly et à me laisse vos commentaires sur le produit. Pour essayer, il suffit d’avoir un compte Live ID et de vous rendre à l’adresse du projet: www.popfly.com.

Vous pouvez également consulter d’autres articles sur le même sujet:

• http://www.clubic.com/actualite-73948…microsoft.html
• http://www.laboratoire-microsoft.org/…-facile.html
• http://www.pcinpact.com/actu/news/36487…invitatio.htm
• http://fr.techcrunch.com/2007/10/…pour-tous/

C’était en 1998 je crois, je sortais avec le bac S en poche et j’entrais en prépa.

J’avais pour projet de créer un système d’exploitation simple et léger pour permettre de le placer dans des systèmes embarqués ou des plateformes peu puissantes. Après études des documentations du processeur Intel 386 (c’était ma cible car on trouvait énormement de documentation à ce sujet à l’époque déjà), j’ai étudié différents systèmes proposés par le monde open source. Il y avait déjà plusieurs exemples de système gratuit à l’époque: linux, minix, freedos, reactos.

Mon objectif était simple: créer un petit système minimaliste qui permettrait à chacun d’étudier les mécanismes des systèmes d’exploitations, tout en permettant de partir de ce système comme base de développement plus complexe.

Par manque de temps, je n’ai pas pu avancer réellement sur ce projet. Le système LittleOS (c’est son nom) est donc devenu un projet qui s’est terminé assez rapidement (j’ai travaillé environ 2 ans dessus, quelques heures par mois).

Si vous souhaitez en savoir un peu plus, je vous invite à consulter le site du système LittleOS. Attention, il s’agit d’un (très) vieux site et j’avoue que je ne suis pas très fier des couleurs que j’ai pu choisir à l’époque (elles sont assez vives!).

Le site de LittleOS propose quelques documents mais surtout l’accès aux sources du système d’exploitation. Je tiens à vous prévenir car il s’agit d’une version préliminaire et donc pas très fonctionnelle.

La dernière version en ligne (0.3.2) propose les fonctionnalités suivantes:

• Gestion d’une console simpliste (affichage de messages),
• Gestion des interruptions et des exceptions du CPU,
• Gestion des allocations mémoire (type malloc/free),
• Accès à la pagination (pour gérer le mapping mémoire physique/mémoire logique).

Vous pouvez aussi accéder directement à la page des téléchargements: Téléchargement des sources de LittleOS.

Si vous avez des questions au sujet de ce projet, n’hésitez pas à me contacter.

Firefox est avant tout un navigateur gratuit et conforme aux normes. Il est facile à étendre grâce aux centaines de modules disponibles (voir par exemple sur Geckozone).

Certaines extensions apportent de nouvelles fonctionnalités de navigation ou de consultation (par exemple lire un flux RSS, ajouter un vérificateur orthographique pour valider les formulaires avant soumission).

Pour un développeur Web, Firefox apporte des extensions qui simplifient le développement et permettent de voir le résultat de manière immédiate. Du coup, ce navigateur peut désormais être utilisé comme environnement de développement pour des pages web (à condition de connaitre le langage HTML bien sûr).

DevelopperToolbar et Firebug sont deux extensions indispensables. Ce billet les présente.

Web Developper Toolbar

Comme son nom l’indique, l’extension Web Developper Toolbar permet d’ajouter des fonctionnalités orientées développement web. Cette barre ajoute des fonctions pour inspecter le contenu des pages (code HTML ou CSS par exemple), mais aussi de valider ces pages en utilisant les services en ligne. Il est également possible de parcourir visuellement l’arbre syntaxique de la page en survolant les éléments de la page en cours. Cette extension permet d’afficher un page web sans les images, sans la feuille de style, bref, elle permet de la tester dans différentes configuration.

Quelques fonctionnalités intéressantes

• Activer/Désactiver l’affichage des images,
• Vérifier les attributs « alt » sur les images,
• Activer/Désactiver/Modifier les feuilles de styles,
• Vérifier si les codes HTML et CSS sont valides (en utilisant les validateurs du W3C),
• Afficher le chemin d’un élément surligné (en passant la souris),
• Désactiver le cache, l’utilisation de java ou de javascript.
• Afficher les informations de la page: id des éléments, liens, les différents média chargés (permet de visualiser chaque image et de la sauvegarder).

Exemples d’utilisation

Voici quelques captures qui vous montrent à quoi ressemble cette extension et son utilisation.

Regardons ce que devient Google si on active l’aperçu sur écran de petite taille (par exemple PDA):

On remarque que ce site semble bien conçu pour ce type d’affichage.

Web Developper Toolbar permet aussi de tester l’accessibilité d’un site en désactivant les images:

D’après ce qu’on peut voir, le site de TF1 n’est pas vraiment adapté si on désactive les images. Il n’est donc pas accessibles aux personnes mal-voyantes par exemple.

Je vous ai présenté quelques fonctions de cette extension. J’espère que vous aurez la curiosité de l’installer et de me donner vos impressions.

Pour aller plus loin

Rendez-vous à la page de l’extension Web Developer Toolbar.

Vous pouvez également retrouver des informations complémentaires sur la page du développeur: http://chrispederick.com/work/webdeveloper/.

Firebug

Cette extension permet de debugger et de valider le développement AJAX, DHTML et Javascript. L’extension permet d’afficher le DOM d’une page, de sélectionner une portion et d’inspecter les requêtes effectuées par le navigateur.

Fonctionnalités

• Modification en temps réel du code HTML ou CSS (vous pouvez aussi voir instantannement le résultat),
• Débuggage javascript: espions et points d’arrêts,
• Analyse des accès réseau: une page donne la liste des requêtes avec les réponses.
• Inspection d’un élément donné (permet de sélectionner une portion de code et de travailler ensuite celui-ci),
• Inspection du DOM du document.

Exemples d’utilisation

Pour essayer cette extension, j’ai simplement démarré Firebug sur mon blog et j’ai essayé de modifier le titre du premier billet.

L’interface affiche une zone de saisie lorsque l’on clique sur un élément modifiable:

Après la modification, le rendu se met à jour et donne ceci:

Ensuite, je me suis intéressé de plus prêt à la fonction d’analyse des requêtes (pour vérifier le chargement des éléments de ma page d’accueil). L’extension me donne le résultat suivant:

Finalement, je me rends compte que le temps total de chargement est de 4,5 secondes (1and1 n’est pas très performant!). Le résultat donne la liste de chaque élément. Lorsqu’on passe la souris sur un élément, l’extension affiche les détails (pour une image celle-ci est affichée, pratique non?).

Pour aller plus loin

Cette extension est un composant indispensable pour le développeur HTML/Javascript. La possibilité de mettre des points d’arrêts vous fera gagner beaucoup de temps de débuggage.

Je vous invite à consulter la page principale de l’extension GetFirebug.

Quelques autres blogs qui parlent des deux extensions:

• p4bl0,
• Oh my blog (Developpez.com),
• Blogzinet.

Définition d’un itérateur

Un itérateur est un design pattern utilisé couramment dans les langages objets de haut niveau comme Java ou C#. Il permet de parcourir une liste d’éléments de manière ordonnée dans avoir à se soucier de la manière dont sont stockés les éléments. C’est un design pattern de comportement qui permet de parcourir de manière unique une collection d’objet. Pour plus d’informations sur les designs pattern en général, je vous invite à consulter l’excellent article trouvé sur Wikipédia: Design Pattern, Iterateur

Fonctionnement des itérateurs dans .NET 1.0/1.1

Utilisation d’un itérateur

Vous avez peut être déjà utilisé des itérateurs dans .NET sans le savoir. Microsoft a développé un ensemble de classes dont beaucoup sont utilisables comme des itérateurs. En réalité, il est possible d’itérer sur un objet dès le moment qu’il implémente l’interface IEnumerable.

Beaucoup de collections, listes, tables de hashages implémentent cette interface. Grâce à cela, il est possible d’utiliser l’opérateur foreach de C# pour itérer sur une collection d’objet.

Voici un exemple très simple:

ArrayList liste = new ArrayList();
liste.Add("hello");
liste.Add("bonjour");
liste.Add("au revoir");
liste.Add("bye");

foreach (string element in liste)
{
    Console.WriteLine(element);
}

Cet exemple affiche ceci sur la sortie console:

hello
bonjour
au revoir
bye

Rien d’extraordinaire c’est vrai mais nous avons tout de même réussi à parcourir une liste de manière très simple. Ce fonctionnement est utilisable pour n’importe quel type d’objet tant que le conteneur implémente IEnumerable.

Implémentation

L’interface IEnumerable contient la méthode suivante:

IEnumerator GetEnumerator()

Cette méthode doit retourner une instance de type IEnumerator. Cette interface contient les méthodes suivantes:

object Current { get; }
bool MoveNext()
void Reset()

La propriété Current retourne l’élément courant de la collection. La méthode MoveNext permet de passer à l’élément suivant. Elle retourne false quand la collection est arrivée à la fin. La méthode Reset permet de réinitialiser la collection pour retourner sur le premier élément.

Exemple simple

Voyons de plus près comment créer un itérateur simple. Dans mon exemple, j’utilise comme nom de classe OldIterator, en référence aux itérateurs de .NET 1.0/1.1. Les itérateurs de .NET 2.0 fonctionnent un peu différemment. (Le code source est proposé à la fin de cette partie)

Première étape: créer une classe qui implémente IEnumerable

class OldIterator: IEnumerable
{
    private string[] m_Values = { "a", "b", "c", "d" };
#region IEnumerable Members
    public IEnumerator GetEnumerator()
    {
        return new OldIteratorEnumerator(this);
    }
  #endregion
}

Cet exemple présente deux parties: un liste d’éléments fixe qui contient nos valeurs et la méthode GetEnumerator qui permet d’utiliser cette classe avec foreach.

Deuxième étape: créer une classe qui implémente IEnumerator

Une pratique courante est d’inclure la classe énumerateur dans la classe IEnumerable. Ceci permet de partager facilement les données de deux classes (la sous-classe aura accès aux membres de la classe parente). Il suffit donc d’ajouter le code suivant dans la classe OldIterator:

internal class OldIteratorEnumerator: IEnumerator
{
    private OldIterator m_Parent;
    private int m_Index;
    public OldIteratorEnumerator(OldIterator parent)
    {
        m_Parent    = parent;
        m_Index     = -1;
    }
    #region IEnumerator Members
    /// <summary>
    /// Retourne l'objet courant.
    /// </summary>
    public object Current
    {
         get
         {
             Console.WriteLine("### Appel de Current");
             if (m_Index < 0)
                throw new ApplicationException("L'index n'a pas encore été initialisé. Il faut appeler la méthode MoveNext en premier.");
             return m_Parent.m_Values[m_Index];
         }
    }
    /// <summary>
    /// Passer à l'élément suivant.
    /// </summary>
    /// <returns>true s'il y a encore des éléments après, false si c'est la fin.</returns>
    public bool MoveNext()
    {
         bool resultat;
         m_Index++;
         if (m_Index >= m_Parent.m_Values.Length)
             resultat = false;
         else
             resultat = true;
         Console.WriteLine("### Appel de MoveNext(resultat={0})", resultat);
         return resultat;
    }
    /// <summary>
    /// Réinitialise le pointeur d'élément pour retourner au premier.
    /// </summary>
    public void Reset()
    {
         Console.WriteLine("### Appel de Reset");
         m_Index = -1;
    }
    #endregion
 }

Trosième étape: écriture d’une classe de test

Nous avons fait la plus grosse partie du travail, la classe de test montre comme utiliser notre itérateur.

class TestIterateur
{
         static void Main(string[ args)
         {
           OldIterator iterator = new OldIterator();
           Console.WriteLine("Les valeurs de l'iterateur:");
           foreach (string value in iterator)
           {
                Console.WriteLine("--> " + value);
            }
            Console.ReadLine();
        }
 }

Cet exemple affiche ceci dans la console:

Les valeurs de l'iterateur:
### Appel de MoveNext(resultat=True)
### Appel de Current --> a
### Appel de MoveNext(resultat=True)
### Appel de Current --> b
### Appel de MoveNext(resultat=True)
### Appel de Current --> c
### Appel de MoveNext(resultat=True)
### Appel de Current --> d
### Appel de MoveNext(resultat=False)

Le code source est disponible dans l’archive suivante: IteratorsTest.zip (4ko)

Fonctionnement interne

En analysant le résultat de l’exemple précédant, nous pouvons imaginer le fonctionnement de l’opérateur foreach.

foreach (string element in iterator)
{
     Console.WriteLine(element);
}

Le compilateur génère l’équivalent du code suivant:

while (iterator.MoveNext())
{
     string element = iterator.Current as string;
     Console.WriteLine(element);
}

Et voilà pourquoi il est plus facile d’utiliser l’opérateur foreach. La syntaxe est plus simple à coder et plus facile à comprendre. Ce chapitre vous a présenté le fonctionnement des itérateurs dans .NET 1.0/1.1. C’est un concept simple mais qu’il faut connaître car ils sont utilises partout dans le framework .NET. De plus, les itérateurs vous apportent de la souplesse dans le codage. Plus besoin de connaître la taille d’une liste, d’initialiser un curseur au premier élément, etc. Le chapitre suivant présentera les itérateurs dans .NET 2.0.

Fonctionnement des itérateurs dans .NET 2.0

Utilisation d’un itérateur

.NET 2.0 introduit un nouveau moyen pour implémenter facilement des itérateurs. Néanmoins, l’utilisation d’un itérateur est identique:

foreach TypeElement element in liste_elements
{
     // Traiter 'element'.
}

La nouveauté par rapport à .NET 1.0/1.1 est l’introduction du mot clé yield. De plus, avec la possiblité d’utilier des generics depuis .NET 2.0, il est désormais possible de créer des itérateurs typés ce qui rend le code plus robuste (les erreurs sont détectables plus tôt par le compilateur).

Implémentation

Grâce au mot-clef yield, vous pourrez créer des itérateurs typés très facilement puisque le compilateur va générer un grande partie du code. yield permet de retourner une collection d’élément automatiquement. Le compilateur s’occupe de générer le code nécessaire.

Exemple simple

Voyons un petit exemple. Nous allons créer un itérateur qui retourne des entiers. Par contre, par rapport à l’exemple de .NET 1.0/1.1, désormais nous n’avons plus besoin de mettre en place l’index, la méthode MoveNext, Reset et la propriété Current. Tout ceci est fait par le compilateur.

public class PowerIterator: IEnumerable<int>
{
     private int m_Number, m_Exponent;
     public PowerIterator(int number, int exponent)
     {
         m_Number   = number;
         m_Exponent = exponent;
     }
     // <summary>
     // Méthode statique qu'on peut appeler simple par PowerIterator.Power.
     // Elle retourne un itérateur d'entiers qui représente la suite q^n avec
     // q = number et n = exponent.
     // </summary>
     // <param name="number"></param>
     // <param name="exponent"></param>
     // <returns></returns>
     public static IEnumerable<int> Power(int number, int exponent)
     {
         int counter = 0;
         int result = 1;
         while (counter < exponent)
         {
             result = result * number;
             yield return result;
             counter++;
         }
     }

     #region IEnumerable<int> Members
     public IEnumerator<int> GetEnumerator()
     {
         return Power(m_Number, m_Exponent).GetEnumerator();
     }
     #endregion

     #region IEnumerable Members
     System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
     {
         return Power(m_Number, m_Exponent).GetEnumerator();
     }
     #endregion
}

Cette classe mérite quelques explications:

• Tout d’abord, on commence par indiquer qu’on implémente un itérateur de type int avec l’interface IEnumerable<int>,
• Il y a deux méthodes dans cette interface: une méthode typée et une autre méthode non typée (pour rester compatible avec la version 1.0/1.1),
• Chacun de ces méthodes retourne un énumérateur de type IEnumerator grâce à la méthode Power,
• La méthode Power retourne une suite de nombres qui représente les puissances d’un entier passé en argument.

Pour utiliser cet itérateur, voici une petite classe de démonstration. Elle propose deux moyens d’accès:

• soit en instanciant l’itérateur et en utilisant le mot-clef foreach sur cette instance (méthode utilisée avec .NET 1.0/1.1),
• soit en appelant directement la méthode Power qui retourne l’itérateur sous la forme IEnumerable<int>.

class Program
{
     static void Main(string[ args)
     {
         PowerIterator iterator = new PowerIterator(2, 5);
         // L'utilisation d'un itérateur typé permet de détecter une erreur
         // si on utilise le mauvais type en tant qu'élément.
         Console.WriteLine("Puissances de 2:");
         foreach (int n in iterator)
         {
             Console.WriteLine(n);
         }

         Console.WriteLine();
         // Un moyen encore plus simple pour accéder à l'itérateur:
         Console.WriteLine("Puissances de 3:");
         foreach (int n in PowerIterator.Power(3, 5))
         {
             Console.WriteLine(n);
         }
         Console.ReadLine();
     }
}

Comme vous pouvez le constater, l’utilisation d’un itérateur est toujours aussi simple. Par contre, l’implémentation a été encore simplifiée puisqu’il suffit de générer une liste d’élément et de les retourner avec yield.

Cependant, avant d’utiliser ce mécanisme partout dans votre code, il convient de savoir ce que fait vraiment le compilateur. En effet, en ignorant son fonctionnement, on pourrait se retrouver avec une application lente ou qui ne fonctionne pas comme il faut. L’ensemble des codes sources est disponible dans l’archive: IteratorsDotnet2.zip

Fonctionnement interne

Première approche

Pour arriver à comprendre le fonctionnement de l’opérateur yield, j’ai utilisé l’outil Reflector .NET (de Lutz Roeder) qui permet de désassembler le code et de générer une représentation équivalente en C#. Voici une représentation du code généré par le compilateur pour notre itérateur (les noms générés ont été traduits à la main pour plus de compréhension):

internal class PowerIterator : IEnumerable<int>, IEnumerable
{
      // Methods
      public PowerIterator(int number, int exponent);
      public IEnumerator<int> GetEnumerator();
      public static IEnumerable<int> Power(int number, int exponent);
      IEnumerator IEnumerable.GetEnumerator();

      // Fields
      private int m_Exponent;
      private int m_Number;

      // Nested Types
      private sealed class InternalPowerIterator : IEnumerable<int>, IEnumerable,          IEnumerator<int>, IEnumerator, IDisposable
      {
            // Methods
            public InternalPowerIterator(int state);
            private bool MoveNext();
            IEnumerator<int> IEnumerable<int>.GetEnumerator();
            IEnumerator IEnumerable.GetEnumerator();
            void IEnumerator.Reset();
            void IDisposable.Dispose();

            // Properties
            int IEnumerator<int>.Current { get; }
            object IEnumerator.Current { get; }

            // Fields
            private int m_state;
            private int m_current;
            public int m_exponent;
            public int m_number;
            public int m_counter;
            public int m_result;
            public int exponent;
            public int number;
      }
}

En analysant rapidement ce code, nous constatons que le compilateur C# a généré une classe (ici InternalPowerIterator). Cette classe implémente les différentes interfaces pour les itérateurs et la gestion mémoire du garbage collector (IDisposable). Les méthodes PowerIterator.GetEnumerator n’ont pas changé.

La méthode PowerIterator.Power est décrite par le code suivant:

public static IEnumerable<int> Power(int number, int exponent)
{
      PowerIterator.InternalPowerIterator result = new PowerIterator.InternalPowerIterator(-2);
      result.m_number = number;
      result.m_exponent = exponent;
      return result;
}

Cette méthode instancie la classe InternalPowerIterator, initialise ses membres puis retourne le résultat. Nous pouvons donc en déduire que le compilateur génère automatiquement une classe interne qui sera utilisée pour notre itérateur. La méthode Power permet d’instancier cette classe généré.

Etude de la classe générée

Cette classe contient un ensemble de méthodes que nous allons analyser en détails.

Constructeur

Le constructeur de InternalPowerIterator prend en paramètre un entier qui indique un état (state).

MoveNext

private bool MoveNext()
{
     switch (this.m_state)
     {
         case 0:
               this.m_state = -1;
               this.m_counter = 0;
               this.m_result = 1;
               while (this.m_counter < this.exponent)
               {
                     this.m_result *= this.number;
                     this.m_current = this.m_result;
                     this.m_state = 1;
                     return true;
                  Label_0060:
                     this.m_state = -1;
                     this.m_counter++;
               }
               break;
         case 1:
               goto Label_0060;
      }
      return false;
}

Cette méthode nous en apprend plus sur l’attribut m_state. Il s’agit très probablement de l’état d’un automate. En effet, en regardant le code switch, nous remarquons qu’il s’agit du code d’un automate à état très simple. Celui-ci ne gère que trois états: -2, 0 et 1. L’état -2 est réservé et indique probablement que l’automate n’est pas dans un état correcte. L’état 0 est celui qui initialise les membres de la classe est début la boucle while. L’état 1 permet de continuer la boucle while à l’aide du goto.

GetEnumerator

IEnumerator<int> IEnumerable<int>.GetEnumerator()
{
    PowerIterator.InternalPowerIterator result;
    // Comparaison de l'état actuel avec l'état -2 (non initialisé).
    if (Interlocked.CompareExchange(ref this.m_state, 0, -2) == -2)
    {        // Si m_state = -2, alors m_state = 0 et retourner la même instance.
        result = this;
    }
    else
    {
        // Sinon retourner une nouvelle instance initialisée.
        result = new PowerIterator.InternalPowerIterator(0);
    }
    result.number = this.m_number;
    result.exponent = this.m_exponent;
    return result;
}

IEnumerator IEnumerable.GetEnumerator() {
     // Retourne une énumérateur à partir de la méthode IEnumerable<int>.GetEnumerator().
     return this.System.Collections.Generic.IEnumerable<System.Int32>.GetEnumerator();
}

La première méthode est très importante pour cette classe. C’est elle qui permet d’initialiser la valeur de m_state (l’état de l’automate). Elle utilise la méthode Interlocked.CompareExchange qui permet une comparaison/échange thread-safe et retourne une instance de son propre type. Pour le résultat, l’état est initialisé à 0.

Reset

Le code génère une exception indiquant que la méthode n’est pas implémentée. Reset() n’est donc pas supporté dans .NET 2.0.

Dispose

Cette méthode ne contient rien pour le moment.

La propriété Current

int IEnumerator<int>.Current
{
      get
      {
            return this.m_current;
      }
}

object IEnumerator.Current
{
      get
      {
            return this.m_current;
      }
}

Rien à dire: les deux méthodes retournent l’élément courant.

Analyse des observations

Nous remarquons que le code généré par le compilateur constitue un automate à état qui comporte quatre états:

• l’état -2 indique que l’automate est invalide,
• l’état 0 indique qu’il faut initialiser l’automate,
• l’état 1 indique qu’il est initialisé et que l’on peut continuer le traitement,
• l’état -1 indique que l’automate est en cours d’initialisation.

La méthode MoveNext contient le traitement qui permet de générer les éléments. La méthode GetEnumerator retourne un énumérateur dont l’automate se retrouve dans l’état initial. Etant donné que la méthode Reset n’est plus supportée, GetEnumerator retourne à chaque fois une nouvelle instance initialisé dans l’état 0 (indique le début de l’itération).

Bilan général

Nous avons vu qu’il devient très facile d’écrire des itérateurs grâce au mot-clef yield. Vous savez désormais que le compilateur génère une classe interne à notre implémentation qui permet de gérer un automate à états qui s’occupe de lister les éléments pendant les itérations. Il est important de noter que l’automate peut devenir complexe en fonction de votre traitement. Il ne faut pas non plus oublier que chaque boucle foreach va demander au runtime une nouvelle instance de la classe d’itération. Il faudra donc veiller à la consommation mémoire. ]]> http://www.pascallacroix.net/blog/2006/10/25/introduction-aux-iterateurs/feed/ 0