Aurélien BOUDOUX

• Si la tendance du moment consiste à utiliser des méta-langages pour transpiler du javascript, pourquoi s'embêter à apprendre l'un de ces langages (ou le javascript lui même) plutôt que d'utiliser notre langage préféré ?
• N'existerait-il pas un transpileur de C# vers javascript histoire de gagner du temps ?

Pour voir la vidéo, c'est par ici

• Les programmeurs travaillent souvent seul sur un démon système
• Le .NET framework fourni des API natives très peu adaptées à la mise en place de design SOLID
• Les démons systèmes sont (de premier abord) des programmes simples qui ne font que des choses répétitives.

Principes de base

Service Control Manager

• Le premier est sa taille : l’exécutable ne fait que 287Ko et ne nécessite aucune installation préalable. C’est donc un outil idéal pour accompagner un package de déploiement.
• Le second est le nombre de possibilités que celui-ci a à offrir : Il permet de visualiser le flux d’informations comme dans un shell, d’appliquer des couleurs, des filtres, d’enregistrer les données selon une politique d’archivage, …
• Le troisième est la simplicité d’utilisation pour le développeur : DbgView utilise le principe de l’OutputDebugString qui permet d’écrire dans un output spécifique à Windows les informations de debugging. Grace à ce mécanisme, un développeur n’a qu’à appeler la commande Trace.WriteLine pour afficher ses informations, sans se soucier des problèmes de concurrences d’accès.

• Pour l’installation et la désinstallation, j’ai décidé de passer par l’outil sc.exe plutôt que par le couple classe d’installation / installutil.exe, car cela est d’une part beaucoup plus simple pour le développeur, et d’autre part beaucoup plus flexible pour l’administrateur. De plus, sc.exe étant disponible sur toutes les machines, un développeur peut aisément créer un outil d’installation qui se base sur celui-ci.
• Pour la configuration du service, celle-ci se fera sans surprise par l’intermédiaire d’un fichier XML. Mais attention, le .NET Framework préconise de passer par un fichier de type app.config en utilisant les API qui vont avec, ceci ne sera pas du tout notre cas !

Fonctionnement de SystemHell

Un démon est une DLL dont le nom se termine par « Daemon.dll », et qui doit être placée dans le même dossier que SystemHell.exe

Lorsque SystemHell démarre, il regarde dans son dossier s’il existe un fichier de configuration « Daemons.xml »

Si ce n’est pas le cas, SystemHell va rechercher dans son dossier toutes les DLL censées posséder un démon, et générer un « Daemons.xml » qui possédera la configuration pour une instance de chaque démon.

Comment développer un démon ?

Entrons tout de suite dans le vif du sujet. Pour ce faire, nous allons créer un démon simple puis le faire évoluer au fur et à mesure de nos besoins. Cela permettra de voir l’ensemble des possibilités offertes par SystemHell.

Allons-y :

Pour commencer, nous allons créer une nouvelle solution dans laquelle nous pourrons développer plusieurs démons. Nous l’appellerons « MyHellProject »

Création d'un solution vide MyHellProject

Nous allons créer dans cette solution un nouvelle DLL qui sera notre premier démon. Nous allons appeler cette DLL « HelloWorldDaemon »

Création d'une librairie HelloWorldDaemon.dll

Maintenant que nous avons une DLL, et que nous nous sommes bien assuré que le nom d’assembly se termine par le mot « Daemon », nous allons télécharger le package nuget « SystemHell » qui nous permettra de développer et de déployer notre démon.

Ouverture du gestionnaire de packages Nuget

Recherche du package SystemHell

Après avoir coché le projet « HellowWorldDaemon » et cliqué sur le bouton « Install », une référence à la librairie « SharedDaemonLib » s’ajoute à votre projet.

Ajout de la librairie SharedDaemonLib dans les références de la solution

A partir de là, nous allons pouvoir passer à la partie développement.

Pour commencer, nous allons créer une classe qui fera office de classe de configuration. Cette classe devra contenir tous les paramètres qui pourront être défini par l’administrateur pour faire tourner notre service.

Dans notre cas, nous allons mettre une phrase qui devra être écrite en boucle dans DbgView ainsi qu’un nombre de secondes qui définira la fréquence à laquelle afficher cette phrase.

public class HelloWorldConfiguration : DaemonModuleConfiguration
{
    private string _whatToSay = "Hello World !";
    private int _loopTimeInSecond = 5;

    public string WhatToSay
    {
     get { return _whatToSay; }
     set { _whatToSay = value; }
    }

    public int LoopTimeInSecond
    {
     get { return _loopTimeInSecond; }
     set { _loopTimeInSecond = value; }
    }
}

Comme vous pouvez le remarquer, notre classe doit hériter de la classe de base DaemonModuleConfiguration.

Une autre chose importante à savoir, c’est que toutes les propriétés de cette classe doivent être initialisées et accessibles en get / set. (Surtout pour les types string)

Si vous n’initialisez pas ces propriétés, elles risques de ne pas apparaître dans le fichier de configuration généré automatiquement par SystemHell. Il faudra donc que l’administrateur les connaissent par cœur pour les ajouter à la main.

Maintenant que nous disposons d’une classe de configuration, nous allons pouvoir créer le point d’entrée vers notre démon. Pour cela, nous allons ajouter une classe qui hérite de DaemonBase, et nous définirons en paramètre générique le type de notre classe de configuration défini plus haut.

public class HelloWorld : DaemonBase
{
 public override void Start(CancellationToken cancellationToken)
 {
  throw new NotImplementedException();
 }
}

public class HelloWorld : DaemonBase
{
 public override void Start(CancellationToken cancellationToken)
 {
  DaemonStarted = true;
  do
  {
   WriteTrace("Daemon say : {0}", Configuration.WhatToSay);
  } while (!cancellationToken.WaitHandle.WaitOne(Configuration.LoopTimeInSecond*1000));
 }  
}

Installation et exécution de notre premier démon

Après avoir compilé « HelloWorldDaemon.dll », nous pouvons aller chercher le programme SystemHell.exe qui nous permettra de le hoster. Pour cela, faites un clique droit sur le projet, et choisissez le menu « Ouvrir le dossier dans l’explorateur »

Ouverture du dossier dans l'explorateur

Dossier ou se situe le projet HelloWorld

Remontez d’un dossier pour attendre « MyHellProject » puis allez dans le dossier « Package »

Navigation jusqu'au dossier Packages

Ce dossier contient tous les packages Nuget téléchargés pour notre solution. Allez dans le dossier « systemHell.x.y.z » puis dans le sous dossier « tools ». Vous trouverez un exécutable appelé « systemHell.exe »

Navigation jusqu'au dossier "Tools" qui contient SystemHell.exe

Copiez cet exécutable dans le dossier où vous désirez installer votre service système, et profitez-en pour y placer votre dll « HelloWorldDaemon.dll » compilée précédemment, ainsi que ses dépendances.

Copie de l'exécutable dans un dossier

Ouvrez maintenant un interpréteur de commande en mode « Administrateur », puis tapez la commande suivante pour installer le service sur votre ordinateur :

Installation du service "HelloWorld" avec "sc.exe"

Attention : il doit y avoir un espace entre binPath= et le chemin vers SystemHell.exe

Normalement, une fois cette commande exécutée, vous trouverez un service nommé « HelloWorld » dans votre SCM.

Présence du service "HelloWorld" dans la SCM

Très bien.

Démarrez le service « HelloWorld » grâce à la SCM. Normalement un message d’erreur indique que le service n’a pas pu démarrer.

Message d'erreur suite au démarrage du service "HelloWorld"

Pour comprendre un peu plus ce qu’il se passe, vous pouvez aller dans l’observateur événements

Erreur SystemHell dans l'observateur d'événements

L’erreur indique que le service s’est arrêté car il n’y avait pas de fichier de configuration. Un fichier a été généré dans « c:\temp\test\Daemons.xml », et il suffit d’aller le configurer puis de relancer le service.

Ouvrons ce fichier de configuration pour voir ce qu’il contient.

Fichier de configuration généré par SystemHell pour HelloWorld

Voici comment est structuré ce fichier :

Le nœud « Modules » contient un ou plusieurs nœuds « Daemon » qui représentent pour chacun une instance de démon à charger.

Un nœud « Daemon » possède les attributs suivants :

Name : représente le nom du démon, celui-ci doit être unique dans le fichier « Daemons.xml »

Actif : Défini si SystemHell doit exécuter ce démon. Attention, lorsque le fichier de configuration est auto généré, tous les démons ont l’attribut « Actif » à « false » par défaut. Pensez à le passer à « true » sans quoi vous constaterez que votre démon ne démarre pas.

Assembly : Défini le nom fort de l’assembly qui possède le code du démon. Cette assembly doit être située dans le même dossier que « SystemHell.exe ». Attention : Comme vous pouvez le constater, le nom fort de l’assembly possède le numéro de version. Si vous avez besoin d’attribuer des numéros version à votre démon, modifiez le numéro de version du fichier, et non celui de l’assembly, sinon 

SystemHell risque de ne pas pouvoir charger l’assembly de votre démon.

Modification du numéro de version de fichier plutôt que celui de l'assembly

Le sous nœud « Configuration » possède les propriétés que nous avons créées dans notre classe « HelloWorldConfiguration. ». Attention, si vous ajoutez de nouvelles propriétés dans votre classe, pensez bien à les répercuter à la main dans le fichier de configuration.

Maintenant que nous avons vu comment était constitué ce fichier, nous allons le manipuler pour bien comprendre comment celui-ci fonctionne.

Pour commencer, nous allons définir l’attribut « Actif » de notre démon à « true », pour notifier à SystemHell que ce démon doit être chargé.

Activation du démon HelloWorld dans le fichier de configuration

Maintenant procurez-vous l’exécutable DbgView disponible sur le site de Microsoft à l’adresse suivante : 

https://technet.microsoft.com/en-us/sysinternals/debugview.aspx

NB : si le lien de téléchargement est mort, faites une recherche de « dbgView » sur Google, vous le trouverez très facilement.

Une fois l’exécutable obtenu, lancez-le en mode « Administrateur » puis allez dans le menu « capture » et assurez-vous que l’option «Capture Global Win32 » est active.

Activation de l'option "Capture Global Win32" dans DebugView

Retournez dans la SCM, puis lancez le démarrage du service « HelloWorld »

SystemHell démarre notre démon dont l’activité est visible dans la console « DbgView »

Visualisation de l'activité du démon dans DebugView

Arrêtons notre démon pour faire un petit changement dans le fichier de configuration

Changements dans le fichier de configuration

Redémarrons le service « HelloWorld » pour voir ce qu’il se passe

Activité du démon "HelloWorld" après redémarrage

Comme vous pouvez le constater, il est extrêmement simple de configurer notre démon avec le fichier XML !

Maintenant, nous allons créer deux instances de notre démon pour que l'in répète en boucle "bonjour" toutes les 10 secondes  et l"autre "au revoir" toutes les 5 secondes.

Pour cela, il suffit de dupliquer le nœud « Daemon », et d’appliquer des configurations différentes. Attention à bien faire en sorte que l’attribut « name » soit unique dans le fichier de configuration.

Configuration pour activer deux instances du démon "HelloWorld"

Visualisation de l'activité des deux instances du démon "HelloWorld"

Et voilà, vous venez de créer votre premier démon. Celui-ci est paramétrable, configurable et administrable très facilement.

Allons un peu plus loin...

Les commandes personnalisées

Un service Windows à la possibilité de recevoir des commandes personnalisées via la commande « sc control », c’est-à-dire que nous pouvons demander à notre démon d’effectuer certaines actions à la demande de l’administrateur.

Pour implémenter cette fonctionnalité, rien de plus simple, il suffit de surcharger la méthode « OnCustomCommand » dans notre démon.

Par exemple, si nous reprenons le code de notre démon « HelloWorld », voici comment nous pourrions le modifier.

public class HelloWorld : DaemonBase
 {
  public override void Start(CancellationToken cancellationToken)
  {
   DaemonStarted = true;
   do
   {
    WriteTrace("Daemon say : {0}", Configuration.WhatToSay);
   } while (!cancellationToken.WaitHandle.WaitOne(Configuration.LoopTimeInSecond*1000));
  }

  public override void OnCustomCommand(int command)
  {
   WriteTrace("la commande numéro {0} a été reçue.", command.ToString());
  }
 }

Envoi de la commande 150 au service HelloWorld

Réception de la commande 150 par SystemHell

Activer ou désactiver des instances de démon sans redémarrer SystemHell

Visualisation de l'activité des deux instances de démon

Modification du fichier de configuration pour désactiver HelloWorld_2

Envoi de la commande 200 au service "HelloWorld"

Visualisation de l'impacte dans dbgview

Les fichiers de configurations complexes

public class HelloWorldConfiguration : DaemonModuleConfiguration
    {
     public HelloWorldConfiguration()
     {
      SubData = new Subclass1();
     }
     private string _whatToSay = "Hello World !";
     private int _loopTimeInSecond = 5;

     public string WhatToSay
     {
      get { return _whatToSay; }
      set { _whatToSay = value; }
     }

     public int LoopTimeInSecond
     {
      get { return _loopTimeInSecond; }
      set { _loopTimeInSecond = value; }
     }

  public Subclass1 SubData { get; set; }     
    }

 [Serializable]
 public class Subclass1
 {
  public Subclass1()
  {
   MyData = new Subclass2();   
  }
  private string _property1 = "this is property 1";
  private int _property2 = 1;

  public string Property1
  {
   get { return _property1; }
   set { _property1 = value; }
  }

  public int Property2
  {
   get { return _property2; }
   set { _property2 = value; }
  }

  public Subclass2 MyData { get; set; }
 }

 [Serializable]
 public class Subclass2
 {
  private string _myPoperty = "this is my property";

  public string MyPoperty
  {
   get { return _myPoperty; }
   set { _myPoperty = value; }
  }
 }

Fichier de configuration complexe

BadImageFormatException, ou comment passer SystemHell en x86

Définition de la plateforme cible du démon en x86

Recherche de l'outil CorFlags.exe sur le disque dur

Consultation des flags CLR de SystemHell avec CorFlags.exe

Forcage du flag 32 bits sur SystemHell

Consultation des flags CLR de SystemHell avec CorFlags.exe

Exemples de produits

Astread

Page d'accueil de astread.com

Visualisation de l'activité SystemHell de www.astread.com

Fichier de configuration SystemHell de astread

Connecteur HL7

HL7 est une norme de communication dans le monde de la santé qui permet de transmettre des informations entre plusieurs systèmes logiciels au sein de cabinets, de cliniques ou d’hôpitaux.

Pour ce faire, l’éditeur qui désire pouvoir être compatible HL7 doit créer un connecteur capable de générer des messages au format texte en fonction d’événements qui se produisent dans le système d’information (admission d’un patient, création du compte rendu, facturation, …)

Une clinique ou un hôpital peuvent recevoir plusieurs centaines de patients par jour, et chaque patient génère une dizaine d’événements qui doivent être envoyés en HL7 à des tiers, il est donc primordial que le connecteur qui tourne en fond de tâche soit extrêmement robuste pour ne pas perturber le worflow de prise en charge.

Or, HL7 est une norme très complexe qui a bénéficié de nombreuses évolutions. Le connecteur doit donc pouvoir gérer plusieurs versions de la norme et s’assurer à chaque évolution qu’aucune régression n’a été introduite dans le code.

Grace à SystemHell, nous avons pu écrire en quelques semaines un connecteur HL7 capable de gérer plusieurs profils dans 2 versions de la norme. La grande souplesse du framework a permis de mettre en place des tests unitaires ainsi que des scénarios en « Behavior Driven Development » pour valider automatiquement le bon fonctionnement du connecteur à chaque modification de code.

Le déploiement et la configuration du connecteur ont ainsi été grandement simplifiés, ce qui a permis aux installateurs de s’approprier l’outil très rapidement, et de pouvoir mettre en place plusieurs types de stratégies en fonction du contexte d’installation (création de services séparés, création d’un seul service, ciblage de plusieurs types d’appareil, suivit et diagnostique des anomalies, …)

Exemple de scénarios BDD du connecteur HL7

Exemple de fichier de configuration du démon HL7

Ce démon est actif dans plusieurs cabinets de radiologie et a permis d’acheminer plusieurs millions de messages sans jamais défaillir.

Système de dictée numérique

Des utilisateurs qui font de la dictée numérique désiraient que leurs fichiers son puissent être placés automatiquement dans une GED (Gestion Electronique de Document), un répertoire, un partage réseau ou un serveur FTP.

De plus, le fichier son pouvait provenir soit d’un dossier faisant office de puit de fichiers, soit depuis un appareil spécifique qui agissait comme une clé USB.

La multitude de configurations et le mode fond de tâche devant tourner 24/24 étaient tout indiqués pour créer un démon SystemHell dont voici le fichier de configuration :

Fichier de configuration du démon de dictée numérique

Comme vous pouvez le constater, SystemHell permet de créer des fichiers de configuration très complexes, selon la stratégie choisie par le développeur.

Dans notre cas, le système possède deux concepts : des « watchers » permettent de configurer comment surveiller une entrée de fichier son (mode répertoire ou USB) et des « Behaviors » permettent de spécifier comment le démon doit se comporter lorsque un fichier a été détecté par le « watcher » (envoi dans une GED, un répertoire ou du FTP).

Ainsi, le démon peut être installé soit sur un serveur, soit directement sur un poste utilisateur en fonction du besoin final.

BubbleBugs

Page d'accueil du site www.bubblebugs.net

BubbleBugs est un site permettant de faire remonter les erreurs qui se produisent dans des applications « .NET » directement dans un serveur TFS ou VSO sous forme de WorkItem (http://www.bubblebugs.net)

Pour ce faire, l’utilisateur doit s’inscrire sur le site et donner les informations de connexion vers son dépôt de fichiers source, puis intégrer une librairie à son application.

Lorsque un utilisateur a validé les informations de connexion à son dépôt, un nouveau nœud XML est créé dans le fichier de configuration SystemHell, et une commande 200 est envoyée pour démarrer un démon spécifique qui a la charge de surveiller un dossier, et créer un workitem correspondant chaque fois qu’un nouveau fichier apparaît dans celui-ci.

En parallèle, un autre démon qui tourne dans le même service à la responsabilité de recevoir les erreurs issues des applications en ligne, et de déposer dans l’un des dossiers correspondant le fichier qui contient tous les détails de l’erreur.

Ce site exploite toutes les possibilités offertes par SystemHell : il combine deux démons différents qui travaillent de concert, et permet de créer une nouvelle instance à la volé pour chaque inscription sur le site, sans redémarrer le service.

Fichier de configuration SystemHell du site bubblebugs

Visualiation de l'activité du démon BubbleBugs

Conclusion

Les services Windows sont des applications spécifiques dont la robustesse et la maintenabilité ne sont pas négociables, il est donc nécessaire de mettre toutes les chances de son côté lorsque vous devez en développer un.

En utilisant SystemHell, vous serez en capacité de créer rapidement des services Windows facilement testables et configurables tout en assurant la scalabilité de votre architecture.

SystemHell est un Framework Open Source accessible sur Github à l’adresse https://github.com/aboudoux/systemHell

Si vous avez besoin de conseils pour votre architecture de services Windows, laissez donc un commentaire ! Je serai ravi d’en discuter avec vous.

Chaque jour dans le monde, des milliers de personnes se jettent dans un nouveau projet de développement logiciel : Que ce soit une startup qui veut lancer un concept avec son site web, une entreprise qui veut développer un logiciel de gestion ou un étudiant qui désire créer une application mobile, tous voient en la technologie un moyen simple et rapide de réaliser leurs ambitions.

Prologue

• Il veut être le chef de projet sur ce dossier 
•  Il veut participer activement au développement du produit avec moi

La naissance d'un projet stratégique

• En premier lieu, l’équipe de développeurs actuelle va-t-être formée au langage C#
• En parallèle, le chef de projet et moi-même redévelopperons le Framework RAD en .NET
• Le Framework devrait être terminé lorsque les équipes aurons fini d’être formées. A ce moment-là les développeurs pourront redévelopper le logiciel métier à l’aide du Framework, ce qui permettra de l’éprouver. 
• Pour que l’étape précédente puisse se dérouler dans de bonnes conditions, le directeur R&D devra fournir un cahier des charges exhaustif de tout ce qu’il voudra voir dans le nouveau logiciel.

Étape 1 : Euphorie

Étape 2 :  Inquiétude

•  Non, nous ne pourrons rien montrer, il faut donc s’organiser pour faire une énième démonstration de l’ancien produit à nos clients et prospects. 
•  La nouvelle version sera présentée lors du salon de l’année prochaine, les clients qui l’attendent auront alors tout le loisir de la tester et de la commander.

1.  On récupère un logiciel complémentaire prêt à vendre. 
2.  On récupère des développeurs .NET qui connaissent le métier, ce qui n’est pas si mal dans un contexte où il est très difficile d’en trouver. 
3.  On élimine du marché un concurrent potentiel qui aurait pu faire mal s’il était prêt avant nous.

Étape 3 : panique !

•  Le Framework qu’ils utilisent à de nombreux bugs et personne ne les formes correctement à son utilisation. 
• Tous les matins, ceux qui arrivent en premier téléchargent la dernière version du code source et celle-ci est corrompue. Ils passent donc leur matinée à essayer de comprendre d’où vient le dysfonctionnement qui dans 80% des cas dû à un changement dans le Framework poussé par le chef de projet à 22H. 
• La solution possède tellement de DLL avec des références circulaires que le logiciel met plus de 8 minutes à compiler sur chaque poste. 
• Le système de push crée plusieurs problèmes de race condition et de deadlock qui rendent extrêmement difficile le débogage de l’application. 
• Le couplage fort de la DLL où se trouve le code métier est assujetti à plusieurs régressions, forçant tous les développeurs à dépenser chaque jour une énergie folle pour revenir à un état stable est enfin commencer à travailler. 
• Le directeur R&D donne des indications techniques avec un vocabulaire qu’il ne maitrise pas, donc complétement incompréhensibles pour tous. Du coup, les développeurs se font régulièrement crier dessus à cause de leur incompétence supposée.
• La méthode Agile n’est pas correctement appliquée, les US sont à moitié faite, les daily standup durent des heures, le directeur R&D influence les « poker planning » et il n’y a jamais eu de démonstration interne du produit.

Étape 4 : Recherche des coupables

Étape 5 : Punition des innocents

Une réunion de crise invitant tous les collaborateurs de la société est organisée pour annoncer l’échec du projet.

Mon incompétence en terme d’IHM étant assez importante, j’ai suivi récemment une formation sur les outils de modélisation WPF, et je dois dire que cela m’a assez bien réconcilié avec le monde de l’interface graphique.

Introduction

• Visual Studio 2012
• Microsoft .NET 4.0
• Langage C#
• Blend for Visual studio (normalement installé en même temps que VS 2012)

Au travail

Vue d’ensemble de Blend

Commencement

public static readonly DependencyProperty TimeProperty = DependencyProperty.Register("Time", typeof (TimeSpan), typeof (MonHorloge), new PropertyMetadata(default(TimeSpan), PropertyChangedCallback));

private static void PropertyChangedCallback(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs dependencyPropertyChangedEventArgs)
{
    throw new NotImplementedException();
}

private static void PropertyChangedCallback(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs dependencyPropertyChangedEventArgs)
{
    var component = dependencyObject as MonHorloge;
    var timeSpan = (TimeSpan)dependencyPropertyChangedEventArgs.NewValue;
    if (component != null && timeSpan != null) {
          component.AngleHeures.Angle = (timeSpan.TotalMinutes/60/12)*360;
          component.AngleMinutes.Angle = (timeSpan.TotalMinutes%60)/60*360;
          component.AngleSecondes.Angle = (360/60)*timeSpan.Seconds;
    }
}

Teste de la première version de notre contrôle

public partial class MainWindow : Window
    {
        readonly DispatcherTimer _timer = new DispatcherTimer();
        public MainWindow()
        {
            InitializeComponent();
            SetHorlogeFr();
            _timer.Interval = new TimeSpan(0,0,1);
            _timer.IsEnabled = true;
            _timer.Tick += timer_Tick;
        }

        void timer_Tick(object sender, EventArgs e)
        {
            SetHorlogeFr();
        }

        private void SetHorlogeFr()
        {
            HorlogeFr.Time = DateTime.Now.TimeOfDay;
        }
    }

Panneau de configuration du cadran

Blend a détecté que le projet a été modifié depuis la dernière fois. Normal, car nous avons changé la grille en canvas.

Cliquez sur le bouton « Yes to all » pour accepter tous les changements.

Je rappelle que notre but est de pouvoir changer le cadran de l’horloge à la volée. La première chose à faire consiste donc à trouver d’autres cadrans, et à les dimensionner selon la taille du cadran originale.

Partons sur google Image à la recherches de quelques cadrans supplémentaires :

Je vais prendre par exemple le cadran avec un cheval ailé.

Je vois que ses dimensions sont en 1616x1616 alors que le cadran original était en 500x500.

Le problème c’est que je ne sais pas à quoi correspondent ces dimensions.

Je vais vous montrer comment nous allons régler le problème très simplement avec Blend et MSPaint.

En premier lieu, j’enregistre cette image sur mon disque dur, puis je la glisse dans le répertoire « Cadrans » de ma solution

Je renomme l’image en cadran2.jpg, puis je fais un clique-droit à « Edit externally » sur cadran1.jpg

Celui-ci s’ouvre dans Paint

Cliquez sur « Image » puis « Redimentionner », une fenêtre s’affiche.

Choisissez le bouton radio « Pixels »

Nous voyons que notre image de référence fait 225x225 pixels. Voici donc la taille dans laquelle la nouvelle image doit être redéfinie.

Pour cela, on referme Paint, puis on retourne sous Blend pour faire un clic droit à « Edit externally » sur cadran2.jpg

On refait « Image » puis « Redimentionner » à bouton radio « Pixels », et on entre la valeur 225 dans « Horizontal ». La valeur « Vertical » se met automatiquement à 225 elle aussi.

Cliquez sur OK

Il ne reste plus qu’a enregistrer l’image redimentionnée, et à refermer Paint.

Touvez deux ou trois autres cadrans sur google, et mettez les à la bonne taille en utilisant cette méthode.

Ajout de la liste

Une fois ceci fait, nous allons passer à l’incrustation d’une liste et d’un bouton dans notre contrôle, autant vous dire qu’on va devoir manipuler un peu le designer et le code xaml généré pour arriver à nos fins.

Donc, voici comment se présente votre composant dans Blend

Nous allons créer une grille avec deux colonnes.

La première contiendra le canvas qui contient notre horloge, et la deuxième notre liste de choix.

Dans l’onglet « Object and Timeline », faites un clic droit sur « canevas » puis choisissez « Group into à Grid »

Sélectionnez ensuite « UserControl » pour activer les outils de manipulation dans le designer.

Dans le designer, sélectionnez le carré sur le côté droit, puis étirez jusqu’à avoir un espace suffisant pour ajouter une grille.

Dans l’onglet « Object and Timeline », sélectionnez « Grid » pour activer les outils de manipulations dans le designer, puis ajouter une nouvelle colonne à votre grille en cliquant sur le bord supérieur droit de l’horloge.

Allez ensuite dans la barre d’outils, et choisissez un composant de type « ListBox »

Faite glisser la « ListBox » dans la deuxième colonne de votre grille

Nous allons maintenant aller changer quelques petites propriétés directement en xaml.

Cliquez sur le petit bouton « code » situé dans la barre du coin supérieur droit du designer.

Un éditeur xaml va apparaitre, le code doit ressembler à peu près à ceci :

Nous allons changer ce code pour que :

-          Le canvas soit sur la première colonne, et ne déborde pas sur la deuxième

-          Le ListeBox soit sur la deuxième colonne, et ne déborde pas sur la première

-          La deuxième colonne de la grille soit en taille automatique pour s’adapter à la taille du listBox

Tout cela pourrait se faire avec les propriétés de design, mais c’est beaucoup plus rapide de passer directement par le xaml.

D’ailleurs, une fois que vous serez familiarisé avec Blend, vous remarquerez que beaucoup de choses peuvent directement être faite en xaml, ce qui fait gagner pas mal de temps.

En premier lieu, voici les modifications à apporter au niveau des définitions de colonnes :

Ensuite, nous indiquons au canevas qu’il est dans la colonne 0 de la grille

Descendez tout en bas, et supprimez tous les attributs du nœud « ListBox » à l’exception de « Grid.Column= »1 » »

Voilà pour cette partie.

En retournant dans le designer, votre composant doit ressembler à ceci.

Template et Animation

Alors, maintenant nous allons commencer à entrer dans le dur, là ou WPF apporte pas mal d’avantages par rapport à du Winform standard.

Si je vous dis que dans notre ListBox, je veux afficher chaque candran sous forme d’un libellé, que me répondez-vous ?

Facile !

Ok, maintenant si je vous dis que le libellé doit avoir une police un peu stylé ?

Jouable !

Très bien, et si je vous dis que je veux un aperçu de l’image à gauche de chaque libellé qui soit assez gros pour voir quelque chose ?

Ça se complique !

Et si en plus je veux qu’au survol de la souris, l’image s’agrandisse pour avoir un meilleur aperçu ?

Oula ! On n’est pas chez Apple ici !

Grace à WPF, vous pouvez prendre n’importe quel contrôle de base et le redessiner comme bon vous semble grâce aux templates ! C’est ça qui est magique !

Mais comment faire ?

Faites un clic droit sur l’objet « ListBox » dans l’onglet « Object and Timeline », et choisissez le menu « Edit Additional Templates  à Edit generated Items (ItemTemplate ) » à «Create Empty»

Une boite de dialogue s’ouvre.

Choisissez dans la ComboBox de « This document » le choix « ListBox » car seul ce contrôle se verra appliquer le template (pas besoin de partager le template à tous les composants du contrôle)

En cliquant sur « OK », le designer ne montre plus le contrôle de l’horloge, mais affiche a quoi va ressembler graphiquement le Template

Donc là, pour ceux qui n’auraient pas compris, Blend nous donne la possibilité de dessiner à quoi va ressembler chaque item de notre ListBox !

Il suffit donc de  concaténer une image avec un TextBox, et le tour est joué !

Dans « Object and Timeline », faites un clic droit sur « Grid » et choisissez « Change Layout Type à Stackpanel». Cela permettra d’avoir quelque chose de plus rigide pour construire notre item 

Augmentez le zoom de votre designer pour pouvoir insérer des composants au stackpanel

Allez chercher dans la barre d’outils une image et glissez la dans le stackpanel.

Glissez-y ensuite un TextBlock.

Votre template va ressembler à quelque chose comme ça :

Nous voulons que le texte soit à droite de l’image, nous sélectionnerons donc le stackpanel dans « Objects and Timeline » puis nous irons dans la fenêtre des propriétés dans la partie « Layout » changer la propriété « Orientation » de « Vertical » à « Horizontal »

Voici l’impact sur le designer

Comme vous pouvez le constater, le texte n’est pas centré. Nous allons donc nous en occuper.

Cliquez sur le TextBlock puis ouvrez l’onglet « Properties ». Dans la partie « Layout » choisissez « Left » pour « HorizontalAlignement » et « Center » pour « VerticalAlignement »

Le TextBlock dans le designer devient tout de suite beaucoup mieux :

Pour avoir une meilleure vision de à quoi cela va ressembler, cliquez sur le composant « Image » puis dans les « Properties », choisissez un cadran dans la combobox proposée par la propriété « Source » de la partie « Common »

Ceci permet de bien prendre conscience du rendu final.

Attention, cette affectation est temporaire, vous devrez la remplacer par un data binding lorsque les manipulations seront terminées.

Bien. Jusque-là les choses se sont assez bien passées.

Mais maintenant, comment faire pour que l’image s’agrandisse lors d’un survol de la souris ?

Une fois de plus, le moteur WPF va nous sauver la vie en nous permettant de mettre en place ce genre d’effet sans taper une ligne de code.

Tout d’abord, commençons par mettre l’image du cadran à une taille raisonnable, disons 50x50.

Cliquez sur l’image et changez les propriétés With et Height

Très bien.

Maintenant, nous voulons que lorsque l’utilisateur passe sa souris au-dessus de l’image, celle-ci s’agrandit, et lorsqu’il sort le curseur de l’image, celle-ci reprend son état initial. Facile :)

Pour faire cela avec WPF, nous allons mapper des « StoryBoard » aux événements « OnMouseEnter » et « OnMouseLeave » de notre image.

Mais c’est quoi un storyboard ?

Pour faire simple, c’est une ressource éditable qui se présente sous la forme d’une ligne de temps, un peu comme dans les logiciels de montage vidéo.
Cette ligne de temps permet de spécifier à WPF des propriétés qui doivent changer dans le temps. Et là où c’est bien fait, c’est que WPF s’occupe de la transition graphique à votre place.

Ici par exemple, nous allons créer un storyboard pour que la taille de l’image passe de 50x50 à 150x150 en 200ms. Il nous suffira simplement de créer une image clé dans laquelle notre composant possède les nouvelles dimensions, et WPF s’occupe de tout pour nous !!

Allez zou, je vous montre comment faire.

Dans les onglets situés en bas de Blend, cliquez sur l’onglet Triggers. Et sélectionnez dans l’onglet « Objects and Timeline » le composant « image »

Cliquez sur le bouton « + Event » pour créer un nouvel évènement à mapper à un storyboard.

Dans les listes déroulantes situées à côté de « When », changez « target-element » par « image » et changez « Loaded » par « MouseEnter »

Cliquez sur le bouton « + » situé à droit des listes déroulantes.

Normalement ce message apparait :

Cliquez sur « OK » pour créer un storyboard qui sera lié avec cet évènement

Nous venons ici de créer un storyboard du nom de « OnMouseEnter1 », celui-ci possède un petit rond rouge sur sa gauche ce qui signifie qu’il est en cours d’enregistrement. D’ailleurs, vous remarquez aussi que le designer est entouré d’un cadre rouge avec une petite annotation en haut.

A ce stade, nous allons définir le comportement graphique qui va-t-être joué lorsque la souris va passer au-dessus de notre image.

Cliquez sur le composant « image » dans « Objects and timeline » puis déplacez le curseur de votre ligne de temps à 0:00.200

Allez dans les propriétés de votre image, et changez le « Width » et le « height » pour qu’ils soient tous les deux à 150

Vous remarquez dans la ligne de temps qu’une image clé est apparue.

Et aussi que l’image dans le designer est plus grosse.

Pour voir l’effet que cela va donner, cliquez sur le bouton « Play » de la ligne de temps de votre storyboard.

Normalement, vous voyez dans le designer l’image passez de 50x50 à 150x150.

Cool non ?

Faisons maintenant l’inverse, c’est-à-dire que lorsque je vais retirer ma souris de l’image, celle-ci va se rétracter.

Ajoutez un nouvel évènement en cliquant sur le bouton « +Event »

Dans les listes déroulantes situées à côté de « When », changez « target-element » par « image » et changez « Loaded » par « MouseLeave »

Si vous ne voyez pas « Image » dans les choix de la liste de « target-element », prenez garde à bien avoir cliqué sur « image » dans « Objects and Timeline »

Je vais vous montrer comment gagner un peu de temps en évitant de récréer complétement un storyboard.

Il suffit de dire à blend de dupliquer notre premier storyboard, puis de l’inverser :)

Dans « Objects and Timeline », cliquez sur le petit menu déroulant à la droite du « + » situé au niveau du nom du storyboard puis cliquez sur « Duplicate »

Renommez le nouveau storyboard de « OnMouseEnter_Copy1 » en « OnMouseLeave 1»

Déroulez une nouvelle fois le petit menu et choisissez « Reverse »

Il ne vous reste plus qu’à assigner ce nouveau storyboard à votre évènement « MouseLeave » :)

Cliquez sur le « + » situé à droite de votre événement.

Puis choisissez-le storyboard « OnMouseLeave1 »

Et voilà ! Vous venez en quelques clics de créer une petite animation sympa sans effort !

Bon, pourquoi ne pas continuer sur notre lancée et maintenant faire l’ouverture de la liste de paramétrage de cadran ?

Sortez du designer de template en cliquant sur « MaListe »

Bouton de paramétrage

Nous allons ajouter un bouton dans le coin supérieur droit de l’horloge qui nous permettra d’ouvrir la liste à droite afin de choisir un cadran approprié.

Dans votre barre d’outils, recherchez un contrôle de type « Button »

Glissez le bouton dans le coin supérieur droit de l’horloge

Vous conviendrez que ce bouton n’est pas très sexy.

Ce que nous voulons, c’est un petit bouton assez discret contenant une image représentative.

Pour trouver notre image, allons sur www.iconfinder.com à la recherche d’une icône gratuite pour notre bouton.

Celle du milieu semble bien. Je clique dessus afin de la télécharger au format 16x16

Une fois celle-ci enregistrée sur mon disque, je la renomme « param_button.png » puis je la glisse directement dans mon projet Blend.

Passons au paramétrage du bouton.

Cliquez dessus dans le designer et allez dans la fenêtre des propriétés.

Effacez en premier lieu le contenu de la propriété « Content », puis définissez le « Width » et le « Height » à 16

Pour définir l’image du bouton, allez dans la partie « Brush » puis cliquez sur « Background ».

Choisissez le bouton onglet « Tile brush » puis mettez en « imageSource » notre « param_button.png » téléchargée précédemment.

Définissez aussi le « Stretch » à « None »

Il ne vous reste plus qu’à placer le bouton en haut à droite du composant horloge

Maintenant, nous allons définir ce qui doit se passer lors d’un clique sur ce bouton.

Pour rappel, nous voulons que la liste située à droite de l’horloge s’étende vers la droite pour pouvoir sélectionner un cadran. Nous allons donc mapper un storyboard qui fait cette action à l’évènement « Click » de notre bouton.

C’est parti !

Cliquez sur le bouton « + Event » de l’onglet « Triggers »

Après avoir bien vérifié que l’élément « Button » est sélectionné dans « Object and Timeline », choisissez dans les listes déroulantes à côté de When « Button » et « Click », puis cliquez sur le bouton «+ »

Un message proposant de créer un nouveau storyboard apparait. Cliquez sur OK.

Un storyboard « OnClick1 » a été créé.

Sélectionnez le composant « MaListe » dans « Object and Timeline », puis déplacez le curseur de l’image clé sur 0 :00.300

Dans la fenêtre « Properties » de « MaListe », essayez de changer la valeur de la propriété « Width »

Si la valeur est paramétrée en « Auto » comme dans la capture d’écran, un message d’erreur apparait vous expliquant qu’il n’est pas possible d’animer une propriété qui possède une valeur auto-calculée.

Dans ce cas, il faut fermer le storyboard et appliquer une valeur fixe à la propriété « Width » de votre liste.

Une fois la propriété défini, re-sélectionnez le storyboard « OnClick1 » dans « Object and Timeline »

Sélectionnez le composant « MaListe » dans « Object and Timeline », puis déplacez le curseur de l’image clé sur 0 :00.300

Dans la fenêtre « Properties » de « MaListe », changez la valeur de la propriété « Width ».

Normalement, vous n’avez plus le message d’erreur vu précédemment.

Une image clé vient d’apparaitre dans le storyboard.

Vous pouvez maintenant cliquer sur le bouton « play » pour visualiser l’animation.

Voilà, nous venons de faire en sorte que la liste se déploie sur la droite lorsque l’on clique sur le bouton.

Nous allons maintenant mettre en œuvre le mécanisme de rétractation de la liste qui se produira lorsque la souris sortira de celle-ci.

Nous allons ajouter un évènement dans les triggers en cliquant sur le bouton « +Event »

Après avoir pris soins de sélectionner « MaListe » dans « Objects and Timeline », on déroule les listes de choix à coté de « When » pour définir l’événement « MouseLeave » de « Maliste »

Ensuite nous dupliquons le storyboard « OnClick1 »

Puis nous le renommons « OnListMouseLeave »

Nous inversons le storyboard pour donner l’effet de rétractation.

Puis nous assignons ce storyboard à l’évenement « MouseLeave » défini précédemment.

Voila ! Tous nos comportements graphiques sont définis !

Il ne nous reste plus qu’à passer à la partie programmation pour ajouter des items à la liste de choix, puis à définir quelques options de « binding », et le tour est joué !

Databinding

Fermez le programme « Blend » et retournez dans VisualStudio.

Double cliquez sur « MonHorloge.xaml » pour visualiser le code Xaml de votre horloge

Si vous regardez ce code, vous trouverez tous les éléments que nous avons définis dans blend. Les storyboard, les évènements de clique, les boutons, les templates, tout y est.

Nous allons jeter un œil à ce code pour variabiliser les parties liées aux images de cadans, qui pour l’instants sont toutes définies en dur.

Par exemple le cadran principal est défini pour être le fichier cadran1.jpg

Nous avions aussi défini ce même fichier dans le « item template » de notre liste afin d’avoir une meilleure visualisation.

Nous voyons aussi dans ce même bloque de code que le texte est défini en dur.

Donc, quel est le plan d’action ?

Dans un premier temps, nous allons variabiliser le texte et l’image de nos items de liste, puis ensuite nous allons lier l’image du cadran principal avec l’image de la sélection courante dans notre liste.

Pour variabiliser les items, nous allons utiliser le mécanisme de « Data Binding » utilisé par WPF.

Ce système très puissant permet de dire à un composant graphique qu’il doit aller puiser une valeur dans une propriété dont le nom lui est indiqué.

Mais attention, le data binding est une arme à double tranchant car celui-ci est sous forme de couplage faible.

C’est-à-dire que nous allons indiquer à WPF : « Pour la propriété graphique X, tu appliqueras la valeur Y contenue dans la propriété de classe de nom Z »

Et WPF nous fait confiance. Il n’ira pas vérifier à la compilation que le membre est bien lié à une classe dont l’une des propriétés possède bien le nom Z. C’est à nous de nous débrouiller pour lui fournir les bonnes informations.

Voyez comment nous allons définir le binding pour la source de l’image ainsi que pour le texte de notre TextBlock :

Nous venons d’indiquer à WPF : « Tu trouveras le chemin de l’image dans la propriété ‘Image’ et le texte à afficher de la propriété ‘Texte’ de l’item que nous te passerons »

Grâce à ce procédé, nous pouvons ajouter des items sous forme de classes anonymes à notre liste. Tant que celles-ci possèdent nos deux propriétés, WPF n’y vois aucun inconvénient !

public MonHorloge()
{
    InitializeComponent();
    MaListe.Items.Add(new { Image = "Cadrans/cadran1.jpg", Texte = "Standard"});
    MaListe.Items.Add(new { Image = "Cadrans/cadran2.jpg", Texte = "Romain" });
    MaListe.Items.Add(new { Image = "Cadrans/cadran3.jpg", Texte = "Jaguar" });
    MaListe.Items.Add(new { Image = "Cadrans/cadran4.jpg", Texte = "Emeraude" });
    MaListe.Items.Add(new { Image = "Cadrans/cadran5.jpg", Texte = "Classique" });
}

L’avantage avec le databinding, c’est que celui-ci permet aussi d’aller chercher des informations dans les propriétés d’un sous composant de notre arborescence. C’est exactement ce dont nous avons besoins pour définir notre cadran principal !

Allez dans le code WPF de l’image, et définissez le binding de la façon suivante :

La syntaxe indique la chose suivante : « tu iras chercher l’image à afficher dans la propriété ‘SelectedItem.Image’ de l’élément ‘MaListe’ »

Une fois ceci fait, on a presque terminé.

Effectivement, il faut définir dans le code au moins un « SelectedItem » par défaut, sinon notre horloge n’aura pas de cadran au démarrage.

Pour cela, il suffit de rajouter la ligne de code suivante à la fin du constructeur de « MonHorloge.cs »

MaListe.SelectedItem = MaListe.Items[0]

Et voilà, c’est enfin terminé !

Maintenant que vous disposez d’un contrôle d’horloge, Vous pouvez l’utiliser dans toutes vos applications qui en ont besoins comme bon vous semble !

Conclusion

Nous venons de voir comment WPF facilite grandement la conception d'IHM pour votre application, mais ce n'est pas tout !

Car grâce au langage Xaml et aux mécanismes de "Data binding", WPF permet enfin un vrai découplage entre votre code et votre IHM, ce qui présente encore plein d'autres avantages :

• Vous pouvez intégrer un graphiste/designer à votre projet sans que celui-ci possède nécessairement de grosses compétences en développement.
• Le découplage total permet de pousser la testabilité de votre logiciel sur la partie interface, notamment grâce au pattern MVVM.
• Les interfaces que vous réalisez en Xaml sont compatibles avec toutes les technologies de développement Microsoft.

Bref, si un allergique à la programmation graphique comme moi est convaincu par cette technologie, autant vous dire que vous pouvez y aller tranquille :)

select * from Identifiant where (dbo.RegexMatch(Valeur, '^([1-37-8])([0-9]{2})(0[0-9]|[2-35-9][0-9]|[14][0-2])((0[1-9]|[1-8][0-9]|9[0-69]|2[abAB])(00[1-9]|0[1-9][0-9]|[1-8][0-9]{2}|9[0-8][0-9]|990)|(9[78][0-9])(0[1-9]|[1-8][0-9]|90))([0-9]{3})([0-8][0-9]|9[0-7])',1) = 0
OR 
 CAST(SUBSTRING(Valeur, 14, 2) AS int) <> CASE 
 WHEN valeur like '%A%' THEN (97 - ((CAST(SUBSTRING(REPLACE(Valeur,'A','0'), 1, 13) as bigint) - 1000000) % 97)) 
 WHEN valeur like '%B%' THEN (97 - ((CAST(SUBSTRING(REPLACE(Valeur,'B','0'), 1, 13) as bigint) - 2000000) % 97)) 
 ELSE (97 - (CAST(SUBSTRING(Valeur, 1, 13) as bigint) % 97)) 
 END ) 

select * from Identifiant where 
(dbo.RegexMatch(Valeur, '^([1-37-8])([0-9]{2})(0[0-9]|[2-35-9][0-9]|[14][0-2])((0[1-9]|[1-8][0-9]|9[0-69]|2[abAB])(00[1-9]|0[1-9][0-9]|[1-8][0-9]{2}|9[0-8][0-9]|990)|(9[78][0-9])(0[1-9]|[1-8][0-9]|90))([0-9]{3})([0-8][0-9]|9[0-7])',1) = 1
AND 
 CAST(SUBSTRING(Valeur, 14, 2) AS int) = CASE 
 WHEN valeur like '%A%' THEN (97 - ((CAST(SUBSTRING(REPLACE(Valeur,'A','0'), 1, 13) as bigint) - 1000000) % 97)) 
 WHEN valeur like '%B%' THEN (97 - ((CAST(SUBSTRING(REPLACE(Valeur,'B','0'), 1, 13) as bigint) - 2000000) % 97)) 
 ELSE (97 - (CAST(SUBSTRING(Valeur, 1, 13) as bigint) % 97)) 
 END ) 

Introduction

La dérive d’une architecture

•  Le framework possède un système de détection automatique des changements qui se base sur les instances de classes.
• Le framework permet de travailler avec des objets dit POCO censés donner la possibilité de faire des classes libres de toutes les contraintes liées au schéma de données.

Revenons aux fondamentaux

• Pouvoir travailler sur un domaine sans impact majeur sur les autres domaines.
• Pouvoir substituer l’implémentation d’un domaine par une autre implémentation.
• Pouvoir tester chaque domaine de manière indépendante, selon ses spécificités techniques

Explication

•  La partie business (en bleu) qui est le centre de l’architecture. Physiquement, c’est un projet (une DLL) qui possède toutes les API permettant de manipuler du métier pur. Ici on trouve des classes factures, personnes, monnaies, des factorys permettant d’obtenir des entités purement métier.
• La partie contrats (en jaune) est une zone dans laquelle ne se trouve AUCUN CODE. Physiquement, ce sont des projets dans lesquelles on ne trouve que des interfaces. Nous verrons plus tard que ces interfaces devront être écrites d’une manière particulière pour être en adéquation avec notre principe d’indépendance totale.
• La partie périphérique (en vert) possède les implémentations des contrats (en jaune). Chaque périphérique est un projet spécifique qui doit implémenter tous les contrats qui le concerne. Le développeur du projet a aussi la charge de mettre en place l’environnement de test qui permettra de valider la bonne implémentation de son code.

• Partager le travail : un groupe de développeur peut travailler sur la partie purement business tandis qu’un autre travaille sur un périphérique sans aucune interférence ni effet de bord possible. Plusieurs équipes peuvent alors travailler de façon verticale sur le même sujet mais à des niveaux différents.
• Changement d’un comportement sans danger : Vous devez migrer votre SGBD en mode NoSQL ? Votre fournisseur Webservice passe en LDAP ? Une prochaine mise à jour va nécessiter de revoir les appels à un périphérique ? Votre IHM doit repasser en Winform ? pas de problème ! Grâce au couplage inexistant entre vos domaines de responsabilités, le fait de changer l’implémentation d’un projet périphérique n’aura aucun impact sur votre partie business (ni sur les autres périphériques d’ailleurs). Vous pourrez garder le focus sur la ré-implémentation du domaine ciblé sans vous soucier des effets de bords possibles. De quoi se permettre tous les délires.
• Implémentations multiples : Votre logiciel doit travailler sur plusieurs types de bases de données ? switcher entre Oracle, SQL Server et un fichier Excel local ? Supporter plusieurs IHM en fonction qu’il soit exécuté sur une machine de bureau ou une tablette Surface ? Une fois encore, les contrats vont vous permettre de jouer avec plusieurs implémentations grâce à l’injection de dépendance.
• Recherche et correction de bug : Les exceptions non gérées ainsi que les bugs de fonctionnement sont plus rapidement identifiés et corrigés du fait que chaque domaine de responsabilité possède son propre arsenal de tests spécifiques.

Si ces deux domaines doivent manipuler des entités communes, la bonne pratique consiste à faire un contrat qui définit les propriétés de ces entités :

Choix du type de contrats

Structurer des interfaces pour qu’elles remplissent leur rôle de contrat.

public interface IPerson
{
    string FirstName { get; set; }
    string LastName { get; set; }

    IAddress Address{ get; set;}
}

public interface IAddress
{
   string Street { get; set; }
   string City { get; set; }
   string Country { get; set; }
}

public class PersonA : IPerson
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime BirthDay { get; set; }

    public IAddress Address { get; set; }
}
public class AddressA : IAddress
{
    public string Street { get; set; }
    public string City { get; set; }
    public string Country { get; set; }
}

public class PersonA : IPerson
{
    public AddressA Address = new AddressA();

    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime BirthDay { get; set; }

    IAddress IPerson.Address
    {
        get { return Address; }
        set { 
            if( !(value is AddressA) ) 
                throw new Exception("Cannot assign the property because is does not have the matching type AddressA");
            Address = (AddressA)value;
        }
    }
}

public interface IPerson
{
    string FirstName { get; set; }
    string LastName { get; set; }
    DateTime BirthDay { get; set; }

    IEnumerable Address { get; set; }
}

public interface IPerson where TAddress : IAddress
{
    string FirstName { get; set; }
    string LastName { get; set; }
    DateTime BirthDay { get; set; }
    TAddress Address { get; set; }
}

public class PersonA : IPerson
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime BirthDay { get; set; }

    public AddressA Address { get; set; }
}

public interface IPhone
{
    string Number { get; set; }
    string Type { get; set; }
}
public interface IPerson
    where TAddress : IAddress
    where TPhone : IPhone
    where TCollectionPhone : ICollection
{
    string FirstName { get; set; }
    string LastName { get; set; }
    DateTime BirthDay { get; set; }
    TAddress Address { get; set; }
    TCollectionPhone Phones { get; set; }
}

public interface IGpsLocation
{
    double Latitude { get; set; }
    double Longitude { get; set; }
}
public interface IAddress
{
    string Street { get; set; }
    string City { get; set; }
    string Country { get; set; }
}
public interface IAddress : IAddress
    where TGpsLocation : IGpsLocation
{
    TGpsLocation GpsLocation { get; set; }
}

public class GpsLocationA : IGpsLocation
{
    public double Latitude { get; set; }
    public double Longitude { get; set; }
}
public class AddressA : IAddress
{
    public string Street { get; set; }
    public string City { get; set; }
    public string Country { get; set; }

    public GpsLocationA GpsLocation { get; set; }
}
public class PersonA : IPerson
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime BirthDay { get; set; }

    public AddressA Address { get; set; }
}

•  Les contrats sont des interfaces
•  Les membres qui ne sont pas des types natifs doivent être déclarés sous forme de type générique.
•  Les membres de types collection doivent aussi être déclarés sous forme de type générique avec une contrainte sur l’interface ICollection.
•  Les interfaces génériques qui contiennent elles-mêmes d’autres interfaces génériques peuvent être séparées en deux parties. Une interface de base qui contient tous les membres natifs et une interface générique qui hérite de l’interface de base. Ainsi les contrats peuvent garder leur simplicité en ne déclarant que l’interface de base.

Le système de transformation

Utilisation

public interface IPerson : IMergeableCopy
{
    string FirstName { get; set; }
    string LastName { get; set; }
    DateTime BirthDay { get; set; }       
}

public interface IPerson : IPerson
    where TAddress : IAddress
    where TPhone : IPhone
    where TCollectionPhone : ICollection
{      
    TAddress Address { get; set; }
    TCollectionPhone Phones { get; set; }
} 

public interface IPhone : IMergeableCopy
{
    string Number { get; set; }
    string Type { get; set; }
}
public interface IAddress : IMergeableCopy
{
    string Street { get; set; }
    string City { get; set; }
    string Country { get; set; }
}

public interface IAddress : IAddress
    where TGpsLocation : IGpsLocation
{
    TGpsLocation GpsLocation { get; set; }
}

public interface IGpsLocation : IMergeableCopy
{
    double Latitude { get; set; }
    double Longitude { get; set; }
}

• BusinessDomain aura la responsabilité de fournir des Api pour créer et manipuler des personnes
• StorageDomain aura quant à lui la responsabilité de sérialiser et desérialiser ces objets dans un fichier texte possédant un format spécifique.

public abstract class Business : IMergeableCopy
{
    protected Business()
    {
        MergeId = Guid.NewGuid();
    }
    public Guid MergeId { get; set; }
}

public class BusinessPhone : Business, IPhone
{
    public string Number { get; set; }
    public string Type { get; set; }
}

public class BusinessGps : Business, IGpsLocation
{
    public double Latitude { get; set; }
    public double Longitude { get; set; }
}

public class BusinessAddress : Business, IAddress
{
    public string Street { get; set; }
    public string City { get; set; }
    public string Country { get; set; }
    public BusinessGps GpsLocation { get; set; }
}
public class BusinessPerson : Business, IPerson>
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime BirthDay { get; set; }
    public BusinessAddress Address { get; set; }
    public List Phones { get; set; }
}

public class BusinessPerson : Business, IPerson>
{
    private string _lastName;
    public string FirstName { get; set; }
    public string LastName
    {
        get { return _lastName; }
        set
        {
            if( string.IsNullOrWhiteSpace(value) )
                throw new Exception("The lastname cannot be empty");
            _lastName = value.ToUpper();
        }
    }
    public DateTime BirthDay { get; set; }
    public BusinessAddress Address { get; set; }
    public List Phones { get; set; }

    public int Age { get { return DateTime.Now.Year - BirthDay.Year; } }
}

public class StoragePerson : Storage, IPerson>
{        
    public string FirstName { get; set; }
    public string LastName{ get; set; }       
    public DateTime BirthDay { get; set; }
    public StorageAddress Address { get; set; }
    public List Phones { get; set; }

    public override string ToString()
    {
        var builder = new StringBuilder(FirstName + "^" + LastName + "^" + BirthDay + "^" + (Address != null ? Address.ToString() : ""));
        foreach (var storagePhone in Phones)
            builder.Append("|" + storagePhone);            
        return builder.ToString();
    }
}

public class StorageAddress : Storage, IAddress
{
    public string Street { get; set; }
    public string City { get; set; }
    public string Country { get; set; }
    public StorageGps GpsLocation { get; set; }

    public override string ToString()
    {
        return Street + "^" + City + "^" + Country + "^" + (GpsLocation != null ? GpsLocation.ToString() : "");
    }
}

public class StoragePhone : Storage, IPhone
{
    public string Number { get; set; }
    public string Type { get; set; }
    public override string ToString()
    {
        return Number + "^" + Type;
    }
}

public class StorageGps : Storage, IGpsLocation
{
    public double Latitude { get; set; }
    public double Longitude { get; set; }

    public override string ToString()
    {
        return Latitude + "^" + Longitude;
    }
}

public abstract class Storage : IMergeableCopy
{
    protected Storage()
    {
        MergeId = Guid.NewGuid();
    }
    public Guid MergeId { get; set; }
}

public interface IStorageRepository
{
    void SavePerson(string filePath, IPerson person);
}

public class StorageRepository : IStorageRepository
{
    public void SavePerson(string filePath, IPerson person)
    {
        var personToSave = new StoragePerson();
        personToSave.MergeCopy(person);
        File.AppendText("\r\n" + personToSave);
    }
}

var personToSave = new StoragePerson();
personToSave.MergeCopy(person);

public interface IStorageRepository
{
    IPerson Load(Guid personId);
    void SavePerson(string filePath, IPerson person);
}

public interface IBusinessService
{
    BusinessPerson GetPerson(Guid id);
    void SavePerson(BusinessPerson person);
}

public class BusinessService : IBusinessService
{
    private readonly IStorageRepository _storageRepository;

    public BusinessService(IStorageRepository storageRepository)
    {
        if (storageRepository == null) throw new ArgumentNullException("storageRepository");
        _storageRepository = storageRepository;
    }

    public BusinessPerson GetPerson(Guid id)
    {
        var storageObject = _storageRepository.Load(id);
        BusinessPerson result = new BusinessPerson();
        result.MergeCopy(storageObject);
        return result;
    }

    public void SavePerson(BusinessPerson person)
    {
        _storageRepository.SavePerson("d:\\database.txt",person);
    }
}

• La bonne gestion du MergeId ne permet pas seulement de régler les cas de fusions d’instances, mais permet aussi de régler les problèmes de type enfant qui pointe vers son parent. Donc pas d’inquiétude en ce qui concerne les boucles infinies qui peuvent se produire dans d’autres systèmes de copie.
•  En tant que système central de votre architecture, La MergeCopy possède plusieurs systèmes d’optimisation pour que la copie ne ralentisse pas trop votre application. Toutefois des objets trop gros ou trop complexes qui sont très souvent transformés peuvent avoir un impacte sur les performances. Soyez donc vigilent sur ce point.

public class BusinessAddress : Business, IAddress
{
    private string _city;
    private string _country;
    private BusinessGps _gpsLocation;

    public string Street { get; set; }
    public string City
    {
        get { return _city; }
        set
        {
            if(string.IsNullOrWhiteSpace(Street))
                throw new Exception("Define street before the city");
            _city = value;
        }
    }

    public string Country
    {
        get { return _country; }
        set
        {
            if (string.IsNullOrWhiteSpace(City))
                throw new Exception("Define city before the country");
            _country = value;
        }
    }

    public BusinessGps GpsLocation
    {
        get { return _gpsLocation; }
        set
        {
            if( string.IsNullOrWhiteSpace(Street) || string.IsNullOrWhiteSpace(Country) || string.IsNullOrWhiteSpace(City) )
                throw new Exception("define all the properties before the gps location");
            _gpsLocation = value;
        }
    }
}

public class BusinessAddress : Business, IAddress
{
    private string _city;
    private string _country;
    private BusinessGps _gpsLocation;

    [MergeCopy(Order = 1)]
    public string Street { get; set; }
    [MergeCopy(Order = 2)]
    public string City
    {
        get { return _city; }
        set
        {
            if(string.IsNullOrWhiteSpace(Street))
                throw new Exception("Define street before the city");
            _city = value;
        }
    }
    [MergeCopy(Order = 3)]
    public string Country
    {
        get { return _country; }
        set
        {
            if (string.IsNullOrWhiteSpace(City))
                throw new Exception("Define city before the country");
            _country = value;
        }
    }
    [MergeCopy(Order = 4)]
    public BusinessGps GpsLocation
    {
        get { return _gpsLocation; }
        set
        {
            if( string.IsNullOrWhiteSpace(Street) || string.IsNullOrWhiteSpace(Country) || string.IsNullOrWhiteSpace(City) )
                throw new Exception("define all the properties before the gps location");
            _gpsLocation = value;
        }
    }
}

Conclusion

Qu’est-ce que MyTCPMON ?

Va-t-il y avoir des évolutions ?

Les articles

C'est notre monde maintenant... Le monde de l'électron et de l'interrupteur, la beauté du baud. Nous utilisons un service déjà existant, Sans payer ce qui pourrait être bon marché si ce n'était pas la propriété de gloutons profiteurs, et vous nous appelez criminels. Nous explorons... et vous nous appelez criminels. Nous recherchons la connaissance... et vous nous appelez criminels. Nous existons sans couleur de peau, sans nationalité, sans dogme religieux... et vous nous appelez criminels. Vous construisez des bombes atomiques, vous financez les guerres, Vous ne punissez pas les patrons de la mafia aux riches avocats, Vous assassinez et trichez, vous manipulez et nous mentez en essayant de nous faire croire que c'est pour notre propre bien être, et nous sommes encore des criminels.

Oui, je suis un criminel. Mon crime est celui de la curiosité. Mon crime est celui de juger les gens par ce qu'ils pensent et dise, pas selon leur apparence. Mon crime est de vous surpasser, quelque chose que vous ne me pardonnerez jamais.
Je suis un hacker, et ceci est mon manifeste.Vous pouvez arrêter cet individu, mais vous ne pouvez pas tous nous arrêter... Après tout, nous sommes tous les mêmes.

Introduction

Etat de l'art

public class DataObject
{
    private static readonly Random Random = new Random();

    private readonly Guid _id = Guid.NewGuid();
    private readonly DateTime _date = new DateTime(Random.Next(1980, 2020),Random.Next(1,12), Random.Next(1,27));
    private readonly int _number = Random.Next();

    public  Guid ID
    {
        get { return _id; }
    }
    public DateTime Date
    {
        get { return _date; }
    }
    public int Number
    {
        get { return _number; }
    }
}

public static class DataFactory
{
    public static List GetDataObjects(int number)
    {
        var result = new List();
        for(int i = 0; i < number; i++)
            result.Add(new DataObject());
        return result;
    }
}

Vous remarquerez que la factory renvoie directement une liste au lieu d'une énumération. Ceci est fait exprès pour que les calculs de temps ne soient pas faussés par le temps de génération de chaque objet.

public class PerfCounter : IDisposable
{
    private readonly Stopwatch _stopwatch = new Stopwatch();
    private readonly long _currentMemoryUsage = Process.GetCurrentProcess().WorkingSet64;
    private readonly string _filePath;

    public PerfCounter(string filePath)
    {
        if( string.IsNullOrEmpty(filePath) )
            throw new FileNotFoundException();

        string directoryPath = Path.GetDirectoryName(filePath);
        if( string.IsNullOrEmpty(directoryPath) )
            throw new FileNotFoundException();

        Directory.CreateDirectory(directoryPath);
        if (!File.Exists(filePath))
            File.AppendAllText(filePath, "Memory\tTime\r\n");

        _filePath = filePath;
        _stopwatch.Start();            
    }

    public void Dispose()
    {
        _stopwatch.Stop();
        GC.Collect();
        long memory = Process.GetCurrentProcess().WorkingSet64 - _currentMemoryUsage;     
        File.AppendAllText(_filePath, _stopwatch.Elapsed.ToString() + "\t" + memory + "\r\n");
    }
}

private static void TestSortedList()
{
    var sortedList = new SortedList();

    for (int i = 0; i < 10; i++) {
        List datas = DataFactory.GetDataObjects(100000);
        using (var counter = new PerfCounter("c:\\Indexation\\SortedList.txt")) {
            foreach (DataObject dataObject in datas) {
                sortedList.Add(dataObject.ID, dataObject);
            }
        }
    }
}

Dictionary>> index = new Dictionary>>();

Ma solution : la SortedSplitList

Comment fonctionne la SortedSplitList ?

Utilisation du code

public class TestObject
{
    public int Id { get; set; }
    public int Id2 { get; set; }
    public DateTime Date { get; set; }
    public string Data { get; set; }
}

public class CompareById : IComparer
{
    public int Compare(TestObject x, TestObject y)
    {
        if (x.Id == y.Id)
            return 0;
        if (x.Id < y.Id)
            return -1;
        return 1;
    }
}

SortedSplitList sortedSplitList = new SortedSplitList(new CompareById());

var searchObject = new TestObject {Id = 78};
var foundObject = sortedSplitList.Retrieve(searchObject);
Console.WriteLine(foundObject != null ? foundObject.Data : "Data not found.");

Travailler avec des enregistrements rangés selon des critères multiples

public class CompareByDateId : IComparer
{

    public int Compare(TestObject x, TestObject y)
    {
        int dateResult = x.Date.CompareTo(y.Date);
        if (dateResult == 0) {
            if (x.Id == y.Id)
                return 0;
            if (x.Id < y.Id)
                return -1;
            return 1;
        }
        return dateResult;
    }
}

foreach (var testObject in sortedSplitListSortedById.Where(a => a.Date == DateTime.Parse("2003/01/01")))
           Console.WriteLine(testObject.Data);

public class CompareByDate : IComparer
{
    public int Compare(TestObject x, TestObject y)
    {
        return x.Date.CompareTo(y.Date);
    }
}   

foreach (var testObject in sortedSplitList.PartiallyEnumerate(new TestObject() { Date = DateTime.Parse("01/01/2003") }, new CompareByDate()) )
           Console.WriteLine(testObject.Id);                           

Conclusion

Bien que les outils d'indexations fournis par le .NET framework soient largement suffisant pour la plupart des besoins logiciel, la SortedSplitList peut s'avérer très utile pour traiter un très grand volume d'objets dans votre application, celle-ci allie l'optimisation mémoire d'une SortedList, la vitesse d'insertion d'un SortedDictionary tout en donnant la possibilité de travailler sur plusieurs clés.

Ainsi, vous pourrez facilement indexer vos données selon plusieurs critères sans craindre de voir trop rapidement apparaître une OutOfMemoryException.

Telecharger le code source de la SortedSplitList

Nous décidons alors d'augmenter la fréquence d’exécution de notre femme de ménage :

• Passer l'aspirateur
• Si une tache est visible sur la moquette
• Prendre l'éponge sur le meuble de la cuisine
• Laver la tache avec l'éponge
• Reposer l'éponge sur le meuble de la cuisine
• Continuer à passer l'aspirateur.

• Ranger la vaisselle issue du lave vaisselle.
• Si une assiette n'est pas propre
• Prendre l'éponge sur le meuble de la cuisine
• Laver l'assiette avec l'éponge
• Reposer l'éponge sur le meuble de la cuisine
• Continuer à ranger la vaisselle

• Faire la poussière
• Faire d'autres trucs.
• Prendre l'aspirateur dans le placard.
• Passer l'aspirateur
• Si une tache est visible sur la moquette
• Prendre l'éponge sur le meuble de la cuisine
• Laver la tache avec l'éponge
• Reposer l'éponge sur le meuble de la cuisine
• Continuer à passer l'aspirateur.
• Remettre l'aspirateur dans le placard

• Ranger les placard de la cuisine
• Faire d'autre trucs
• Prendre l'éponge sur le meuble de la cuisine
• Nettoyer la table de la cuisine
• Si des miettes tombes par terre
• Prendre l'aspirateur dans le placard.
• Aspirer les miettes avec l'aspirateur
• Remettre l'aspirateur dans le placard
• Continuer à nettoyer la table.
• Reposer l'éponge sur le meuble de la cuisine