lundi 12 octobre 2009

Atelier 02 - Localiser l'application

Nous allons voir à présent comment rendre notre programme utilisable dans plusieurs pays, comme la langue par exemple.

Si nous envisageons de distribuer notre application à un public international, nous devrons garder à l'esprit certaines considérations lors des phases de design et de développement. Et, même si nous ne pensons pas immédiatement distribuer notre application à un public international, de simples préparatifs pourront nous faciliter considérablement la tâche dans l'éventualité où les versions ultérieures de notre application aient des objectifs différents.

La localisation est le processus de personnalisation de notre application pour une culture ou des paramètres régionaux donnés. La localisation consiste principalement à traduire l'interface utilisateur.

La globalisation est le processus de conception et de développement d'un produit logiciel adapté à plusieurs cultures.

C’est quoi une ressource ?
Lorsque nous localisons une application, l’ensemble des données localisées, comme des chaînes et des images qui sont adaptées à chaque culture, sont stockées avec Visual Studio dans des fichiers séparés d’extension .resx ; Ces différentes données qui vont être chargées au moment de l’exécution en fonction de la culture sont appelées les ressources de l’application.

Dans Visual Studio, les ressources localisées (des données comme des chaînes et des images qui sont adaptées à chaque culture) sont stockées dans des fichiers séparés et chargées en fonction de la configuration de la culture de l'interface utilisateur. Pour comprendre comment les ressources sont chargées, imaginons qu'elles sont organisées sous la forme d'une hiérarchie.
  • En haut de la hiérarchie se trouvent les ressources par défaut, c'est-à-dire celles correspondant à la langue de développement de l’application. Dans notre cas, il s’agit du français. Ce sont les seules ressources qui n'ont pas leur propre fichier. Au moment de la compilation, elles sont stockées dans l’assemblage principal de l’application (par exemple nom.exe)
  • Sous ces ressources par défaut se trouvent les ressources des cultures neutres. Une culture neutre est associée à une langue, mais pas à une région. Par exemple, Français (« fr ») ou l’anglais (« en ») sont des cultures neutres. Lors de la compilation, elles sont stockées dans un assemblage satellite lui-même stocké dans un sous répertoire ayant un nom référençant la culture neutre (par exemple fr)
  • En dessous de ces ressources de cultures neutres se trouvent les ressources des cultures spécifiques. Une culture spécifique est associée à une langue et à une région. Par exemple, Français (Canada) ("fr-CA") est une culture spécifique. Lors de la compilation, elles sont stockées dans un assemblage satellite lui-même stockée dans un sous répertoire ayant un nom référençant la culture spécifique (par exemple fr-CH)
Si une application essaie de charger une ressource localisée, telle qu'une chaîne, et ne la trouve pas, elle remontera dans la hiérarchie jusqu'à ce qu'elle trouve un fichier de ressources contenant la ressource demandée.

On revient sur notre application Main.cs en mode [design] et on affiche les propriétés. On met Localizable à True et on sélectionne également le langage en English (United States). Dans l'explorateur de solution, un nouveau fichier Main.en-US.resx a fait son apparition, en dépendance de Main.cs. Ce fichier contient les ressources de l'application pour la nouvelle langue ajoutée.

Pour définir la culture de l'interface utilisateur, nous allons afficher le code de Main.cs. On ajoute les lignes suivantes :
// Configure la culture à Anglais (Etats-Unis)
System.Threading.Thread.CurrentThread.CurrentCulture =
new System.Globalization.CultureInfo("en-US");
// Configure la culture de l'interface à Anglais (Etats-Unis)
System.Threading.Thread.CurrentThread.CurrentUICulture =
new System.Globalization.CultureInfo("en-US");
Pensons à configurer la culture d’exécution avant l’appel à InitializeComponent() ; en effet, cette méthode va configurer les différents contrôles du formulaire, dont leurs propriétés Text, et donc elle va charger les ressources dont elle a besoin ; si la culture du processus est configurée après l’appel de cette méthode, ce sera trop tard car les fichiers de ressources auront déjà été lus …

C’est quoi CultureInfo ?
La classe CultureInfo rend des informations spécifiques à une culture, par exemple la langue, la sous-langue, le pays et/ou la région ou le calendrier associés à la culture, ainsi que les conventions applicables à cette dernière. Elle spécifie un nom unique pour chaque culture, basé sur la norme RFC 3066 pour Windows Vista et les versions ultérieures, et sur la norme RFC 1766 pour les systèmes d'exploitation antérieurs à Windows Vista. Le nom est une combinaison d'un code de culture à deux lettres minuscules ISO 639 associé à une langue et d'un code de sous-culture à deux lettres majuscules ISO 3166 associé à un pays ou une région. Le format du nom de culture est -, où est le code de langue et est le code de sous-culture

Quelle est la différence entre CurrentThread.CurrentCulture et CurrentThread.CurrentUICulture ?
  • CurrentCulture obtient ou définit la culture du thread en cours, c'est-à-dire la façon dont l’application va traiter en interne le format des nombres, des dates ou de chaines de caractères par exemple
  • CurrentUICulture obtient ou définit la culture actuelle utilisée par le gestionnaire de ressources pour rechercher des ressources spécifiques à la culture au moment de l'exécution ;
    C’est pour cette raison qu’il faut changer les deux propriétés dans le code.
Si on regarde dans le répertoire Debug de notre application (sur le dique dur), on remarque qu'un nouveau répertoire a été créé avec à l'intérieur, une dll.

Pour les traducteurs qui localisent les applications, il existe un outil spécifique dans le SDK de .Net 2.0 : Winres.exe.
Winres.exe est une application graphique qui recrée une version en mode WYSIWYG d'un formulaire Windows simplement à partir du fichier de ressources, sans devoir accéder au code source. Winres.exe héberge le concepteur de formulaires Windows et sa fenêtre Propriétés. Ces fonctionnalités permettent une modification visuelle d'un fichier .resources ou .resx contenant un formulaire Windows Forms.


Les développeurs utilisent généralement aussi des ressources directement codées « en dur » dans le code, comme par exemple les chaines de caractères de messages. La création et l'utilisation de fichiers de ressources pour ces chaînes de caractères est une tâche plutôt délicate, si elle est réalisée à la fin de la programmation car elle nécessite une relecture complète du code. Il existe un outil, le Resource Refactoring Tool, qui peut aider à résoudre ce problème.

On peut mettre en commentaire les lignes que nous venons d'ajouter, et remettre le Localize à false.


samedi 10 octobre 2009

Atelier 02 - Positionner les contrôles de données

Nous allons à présent positionner nos éléments (contrôles de données), mais avant cela, nous allons structurer le formulaire à l'aide de tableaux.

Pour structurer l’interface, nous allons utiliser le contrôle TableLayoutPanel dont l’objectif est de manipuler la disposition des composants et de les organiser automatiquement sous forme de tableau.

On reprend notre Main.cs en mode [design]. Dans la toolbox, l'onglet containers, nous glissons le contrôle TableLayoutPanel sur le formulaire. On affiche les propriétés de ce dernier contrôle et on configure la propriété Dock de manière à ce qu'il remplisse tout le formulaire (Fill)

En fait, la mise en forme de base comporte deux fonctions : l'ancrage (Anchor) et le docking (Dock). Par exemple, le contrôle TableLayoutPanel a une propriété Anchor qui est un type énuméré dont les valeurs (qui peuvent être traitées par un ou logique) indiquent de quel(s) bord(s) du contrôle parent le contrôle TableLayoutPanel gardera une distance constante. Par exemple, en configurant la propriété Anchor à AnchorStyles.Bottom, le tableau restera toujours à la même distance du bord inférieur du formulaire, lorsque ce dernier sera redimensionné. Le docking n'est en fait qu'un cas spécial de l'ancrage. La propriété Dock décrit à quel bord du contrôle parent un contrôle doit se relier. Il y a le docking Haut (Top), Gauche (Left), Droit (Right), Bas (Bottom), ou Plein (Fill). Dans chaque cas, le contrôle est déplacé aussi près que possible du bord spécifié et dimensionné de manière à remplir ce bord, où il reste lorsque le parent est redimensionné. Le docking est une sorte d’ancrage avec une distance de zéro par rapport au bord. Les deux propriétés Anchor et Dock possèdent un éditeur de propriétés visuel.

On sélectionne à présent la propriété Columns qui permet de travailler avec la collection de colonnes et de lignes du tableau. On supprime la Column2 et on sélectionne la Column1 pour lui mettre en AutoSize. Dans la liste déroulante Show, on sélectionne Rows. Pour la Row1, on sélectionne Absolute, et on fixe à 35 pixels. La Row2 sera en Percent 100% afin de remplir tout l'espace restant. On clique OK afin de fermer la boîte de dialogue.

On glisse un 2e TableLayoutPanel à l'intérieur de la ligne que nous avons créé précédemment et on affiche ses propriétés. On met la propriété Dock à Fill. On clique sur la petite flèche en haut à droite, ce qui a pour effet de nous indique les tâches les plus courantes à faire sur ce contrôles.

On va sélectionner "Edit rows and columns" et on arrive sur la même fenêtre que tout à l'heure pour configurer les lignes et les colonnes. On sélectionne Rows dans la liste déroulante, et on supprime Row2. On sélectionne Row1, et on lui met un AutoSize.
On affiche à présent les colonnes. On ajoute une nouvelle colonne (bouton Add). Les colonnes 1 et 2 seront Absolute, à respectivement 350 et 150px. La 3e colonne sera AutoSize. On ferme le tout, on sauve, et on peut essayer de faire tourner le programme.

Les contrôles de tableau n'ont aucun impact sur l'aspect visuel.

Bon, nous avons maintenant une structure de tableau avec 4 cellules. A priori, nous allons donc maintenant ajouter 4 contrôles, un par cellule (Cqfd !). En regardant le document d’analyse fonctionnelle (comme quoi, cela sert un peu de faire des documents d’analyse), l’interface utilisateur est composée des contrôles suivants :
  • Une barre de navigation
  • Une grille d'affichage des données
  • Une boîte de texte d'affichage de résultat
  • Un libellé


Outre le libellé et la boite de texte qui sont des contrôles de base de tout bon outil de développement, Visual Studio propose deux contrôles de données répondants à nos besoins : le DataGridView et le BindingNavigator. Ce sont ces contrôles que nous allons utiliser :
  • Le contrôle DataGridView offre un moyen puissant et flexible pour afficher des données sous forme de tableau. Il est possible d’étendre le contrôle DataGridView afin de générer des comportements personnalisés. Par exemple, nous pouvons spécifier par programme nos propres algorithmes de tri, et nous pouvons créer nos propres types de cellules
  • Le contrôle BindingNavigator propose une façon standardisée pour parcourir et manipuler des données sur un formulaire. C’est en fait une barre d’outils qui a été complétée par les équipes de développement de Microsoft afin de gérer automatiquement la navigation dans les données
On reprend notre Main.cs en mode [design] et dans la toolbox, nous allons chercher l'onglet Data. Nous glissons le DataGridView sur notre fomulaire, dans la plus grande cellule de notre premier tableau. Nous ajoutons également un contrôle BindingNavigator dans la cellule de gauche en haut. Dans la toolbox, dans les common controls, on glisse un contrôle Label dans la 2e cellule en haut de notre tableau et un TextBox dans la 3e cellule.

Nous allons sélectionner ces 4 contrôles en maintenant la touche Shift et afficher les propriétés. Nous allons mettre la propriété Dock à Fill, ce qui aura pour effet de faire en sorte que nos 4 contrôles prennent toute la place qui leur est attribuée.

Nous allons ne sélectionner plus que le DataGridView1 pour lui afficher ses propriétés et renommer son name en mainDataGridView. Pareil pour mainBindingNavigator et nous allons renommer le Label1 en lblOperation. On va également positionner ce label avec la propriété TextAlign en MiddleRight. On renomme également la propriété Text en Total.

On passe à présent à TextBox1, on va dans les propriétés pour modifier la propriété Name en txtOperation. Cette zone de texte sera également en lecture seule, donc on va modifier la propriété ReadOnly en True.

On peut sauver, et faire tourner le programme. Normalement, il ne devrait y avoir aucune erreur.


vendredi 9 octobre 2009

Atelier 02 - Définir l'interface utilisateur de l'application

Définir l'interface utilisateur de l'application

Nous allons apprendre à :
  • Créer un projet de développement type formulaire Windows
  • Positionner les différents contrôles graphiques de l'interface utilisateur
  • Localiser l'application dans différentes langues
Contexte fonctionnel
Nous sommes développeurs, et nous avons à implémenter des écrans qui ont été décrits dans l’analyse fonctionnelle, ou mieux qui ont été conçus par un designer d’application à base de formulaire (on peut rêver un peu, non ?). Plus probablement, on nous a donné un bout de feuille issu d’une réunion et qui décrit ce qu’il faudrait faire :



Créer le projet et la fenêtre principale


Après avoir ouvert Visual Studio, nous choisissons de créer un nouveau projet de type Windows Forms Application, que l'on va appeler Coach.Editeur
Un nouveau projet avec une forme vide s'est ouvert...

Nous allons commencer par renommer Form1.cs en cliquant droite sur l'explorateur de document et rename pour l'appeler Main.cs

Visual Studio nous propose ici de chercher automatiquement dans le projet en cours tous les endroits où il y a une référence au nom de la fenêtre Form1 et de les remplacer par le nouveau nom donné Main. Il va s’occuper pour nous de renommer les variables et autres éléments, ce qui est très utile donc.

En fait, un formulaire Windows est avant tout une classe d’objet (d’ailleurs tout est classe d’objet dans .Net ?). En double cliquant sur le nom de la fenêtre Main.cs dans l’Explorateur de solutions, nous verrons le designer de formulaire qui affiche l’interprétation du code de définition de la classe.

Un formulaire Windows est composé d’au moins deux fichiers dans Visual Studio. Le fichier Main.cs contient tous les codes que nous allons programmer, et le fichier Main.Designer.cs contient tous les codes qui sont générés par Visual Studio. Le code généré est exactement celui que nous devrions développer à la main si nous voulions faire l’équivalent de ce que fera le générateur. Il n’y a ainsi aucun code caché et la totalité du code est accessible ! Il ne faut pas hésiter à aller y jeter un coup d’œil, mais ne nous lançons pas à le modifier si nous ne savons pas ce que nous faisons, sauf pour corriger des éventuelles erreurs de compilation liées à des destructions intempestives de contrôles par exemple.

Comment fait Visual C# Express pour s’y retrouver dans ces fichiers ? En fait, la définition d’une classe peut être découpée en plusieurs fichiers. Pour indiquer à Visual C# Express qu’il va devoir recoller les morceaux, on ajoute à la directive de classe le mot partial :
public partial class Main : Form
C’est quoi une classe partielle ? On parle de classe partielle quand la définition de la classe est découpée en plusieurs fichiers. C’est très utile si nous avons plusieurs développeurs qui travaillent sur des parties différentes d’une même classe.

Sur notre formulaire, nous allons faire un clique-droit pour afficher les propriétés (qui vont apparaîtres normalement en bas à droite, en dessous de l'explorateur de solution). On vérifie que nous sommes sur le bon projet (Main System.Windows.Forms.Form mais vu qu'on en a qu'une... Sinon dans la liste déroulante, il faudrait sélectionner la bonne)

Dans la fenêtre de Propriétés, les propriétés affichées en gras sont celles que nous avons modifiées. Les autres indiquent les valeurs par défaut. Pour chacune des propriétés dont la valeur indiquée est différente de la valeur par défaut, Visual Studio va générer une (ou plusieurs) ligne(s) dans le fichier Main.Designer.cs ;

Dans la fenêtre Propriétés, nous allons changer la propriété Text et écrire Editeur du Coach C#, ce qui va avoir pour effet de changer le titre de la fenêtre.
Dans Microsoft .net, la propriété Text référence toujours ce qui est affiché par le contrôle à l’écran, même pour les labels ou les boutons.

Dans la propriété size, nous allons mettre 727 pour width et 427 pour height.



Définition d'un menu


On va à présent ajouter une barre de menu sous le titre de la fenêtre (comme il en existe dans la plupart des programmes) ainsi qu'un menu contextuel quand on clique-droite sur l'icône qui se trouvera dans la zone de notifications.

Nous allons ajouter le menu avec la toolbox (boîte à outils) qui se trouve à gauche de l'écran. Pour afficher la toolbox, nous devons être en mode [design]

Nous pouvons ajouter et supprimer des éléments dans la toolbox en faisant un clique-droit et en sélectionnant "Choose Items..."

Dans l'onglet "menus and toolbars", on glisse l'élément MenuStrip sur notre formulaire. Deux choses apparaissent sur notre formulaire, une barre de menu vide en dessous du titre et un contrôle de menu (MenuStrip1) dans une nouvelle zone de dépôt de contrôle en bas de la zone de travail. On va aller dans les propriétés du contrôle de menu (clique-droit) et on change le nom en mainMenuStrip de la propriété Name.

Le langage C# est sensible à la casse des mots. Autrement dit MainMenuStrip ne représente pas la même chose que mainMenuStrip. Il nous faut donc penser à systématiquement faire attention à la façon dont nous nommons nos variables et composants afin d’éviter les erreurs de compilation. Le meilleur moyen est de suivre un plan de nommage et de notation précis.

Avec un clique-droit sur le menu que nous venons d'ajouter, nous allons sélectionner Insert Standards Items... La magie opère, et nous trouvons les principaux menus. Ils ne sont par contre pas fonctionnels pour le moment.

On va faire un double-clique dans File - Exit et une méthode exitToolStripMenuItem_Click apparaît dans Main.cs. Dans cette méthode, nous allons ajouter le code
this.Close();
Après avoir sauvé notre projet, nous pouvons l'exécuter, et tester la fonction du menu Exit... Le programme se ferme :)

C’est quoi this ? Le mot clé this référence l’instance courante d’un objet. Dans notre cas il s’agit donc de l’instance de la fenêtre Main qui sera créée lors de l’exécution du programme

Mais comment fait le système pour retrouver la bonne méthode à exécuter quand on clique sur Quitter ?
Ce n’est pas le nom de la méthode qui fait foi. En fait, la fonction de prise en charge de l’événement (ou la méthode de réponse à l’événement, qui se dit « Event Handler » en anglais) a été dans notre cas automatiquement paramétrée par Visual Studio dans le fichier Main.Designer.cs lorsque nous avons fait un double clic sur le menu Quitter. Nous allons aller voir la définition (faites attention de ne rien modifier ?) :
  • Ouvrons le fichier Main.Designer.cs en double cliquant dessus dans l’Explorateur de solutions
  • Dans ce fichier, cherchez la partie qui est automatiquement générée par Visual Studio
  • On clique sur le petit + pour faire voir le code
  • On cherche exitToolStripMenuItem
  • L'action du click est ici :
this.exitToolStripMenuItem.Click += new System.EventHandler(this.exitToolStripMenuItem_Click);
Aucun code n'est caché... On peut également voir l'ensemble des événements disponibles pour le menu quitter, en faisant un clique-droit sur Exit et ensuite Properties. En cliquant sur le petit éclair (Events), nous remarquons que seul l'événement Click possède une méthode de réponse.

Pour ajouter une fonction de réponse à un événement, il suffit d’aller visualiser la liste des événements disponibles sur le contrôle sélectionné et de double-cliquer sur le nom de l’événement. Cela va ajouter automatiquement la fonction dans notre fichier de code (par exemple Main.cs), et le paramétrage de l’événement dans le fichier utilisé par le designer de Visual Studio (par exemple Main.Designer.cs). Au lieu de double-cliquer, nous pourrions aussi indiquer un nom quelconque pour la fonction de prise en charge (« toto » par exemple), et au moment ou nous allons taper Entrée, Visual Studio va tout créer pour nous. Si nous détruisons la fonction de réponse de notre fichier de code, il faudra aussi penser à retirer le paramétrage de l’événement dans le fichier utilisé par le designer, Visual Studio ne pouvant le faire pour nous car il ne sait pas si la destruction (ou le changement de nom) est consécutif à une erreur ou à un choix décidé du programmeur. De toute manière, si nous ne le faisons pas, nous obtiendrons une erreur de compilation (et oui, le compilateur C# vérifie un maximum de chose).



Nous allons à présent ajouter un menu contextuel qui apparaîtra dans la barre de notifications quand nous ferons un clique-droit.
Pour ce faire, nous devons suivre quatre étapes :
  • Ajouter une icône s'affichant dans la barre de notification et la paramétrer
  • Ajouter un menu contextuel et le paramétrer
  • Lier l'icône de notification et le menu contextuel
  • Ajouter le code correspondant aux options du menu contextuel
On reprend notre formulaire en mode [design] et dans les outils, nous cherchons les common objects. On glisse et déplace le contrôle NotifyIcon sur le formulaire, et nousle voyons apparaître dans la zone de dépôt de contrôles.
Nous allons modifier le name de ce contrôle en mainNotifyIcon en allant dans les propriétés.
Nous allons également modifier la propriété Text et lui attribuer la valeur "Editeur du Coach C#". Ce texte apparaîtra lorsque nous laisserons la souris sur l'icône lorsque le programme sera exécuté.

Nous allons à présent faire un tour dans les propriétés de Coach.Editeur et ajouter un fichier existant dans les ressources. Nous sélectionnons l'icône (fournie avec le projet de test chez Microsoft)

Nous affichons à présent le code de Main.cs (notre formulaire) et nous cherchons la méthode Main(). Il s'agit du constructeur de classe.

C’est quoi un constructeur ?
Le constructeur est la méthode membre d’une classe que vous allez appeler à chaque fois que vous instanciez un nouvel objet :
Main main = new Main();
Main (type de la variable) main (nom de la variable) = new Main() (méthode membre pour l'instanciation)
L’objectif du constructeur est de créer convenablement une instance d’objet, en le configurant dans un état valide. En C#, le constructeur répond aux caractéristiques suivantes :
  • Le nom du constructeur est rigoureusement le même que le nom de la classe
  • Le constructeur n'a aucun type de retour spécifique (pas même void)
Comme toute méthode membre, il est possible de passer des paramètres au(x) constructeur(s) d’une classe. Il est ainsi possible de définir plusieurs façons convenables de créer une instance d’objet. C’est notamment visible dans l’IntelliSense qui nous propose de sélectionner un des différents constructeurs disponible.

Le constructeur qui ne possède aucun paramètre passé est appelé le constructeur par défaut.

Dans le constructeur Main, nous allons ajouter le ode pour initialiser l'icône du contrôle mainNotifyIcon avec celui chargé en ressource :
mainNotifyIcon.Icon = Properties.Resources.lan_connected;
(lan_connected étant l'icône que nous avons ajoutée)

Nous sauvons et revons dans le mode [design]. Dans la toolbox, nous retournons dans Menus & Toolbars et nous glissons ContextMenuStrip dans notre formulaire. Il va se retrouver dans le zone de dépôts de contrôles.

Un menu contextuel ne s’affichant pas hors de son contexte (c’est une Lapalissade), dès que le contrôle du menu contextuel n’est plus sélectionné dans la zone de dépôt de contrôles, il disparaît de l’écran. Pour l’afficher de nouveau, il nous suffit de sélectionner le contrôle dans la zone de dépôt de contrôles.

On va renommer notre contrôle ContextMenuStrip1 en mainNotificationIconContextMenuStrip (Properties -> Name)

Juste en dessous du menu standard, on va cliquer sur la boîte de texte ContextMenuStrip (Type here) et saisir "Maximiser la fenêtre". Nous allons également ajouter "Restaurer la fenêtre", "Minimiser la fenêtre" et "Quitter l'application". On clique à présent sur le "Type here" qui nous laisse apparaître une petite flèche d'une liste déroulante et on ajoute un Separator.

La liste déroulante nous aide à insérer un autre type de ligne de menu : le MenuItem correspond à une ligne de menu similaire à celles que nous venons de saisir, une ComboBox ajoute une liste déroulante, et le TextBox nous permet de saisir directement une valeur de menu lors de l’exécution de l’application. Il reste le Separator, que nous allons utiliser, et qui ajoute simplement une ligne grise horizontale dans la liste des menus.

Nous faisons glisser la ligne de séparation juste en dessus de "Quitter l'application". Nous allons à présent dans les propriétés de mainNotifyIcon. Nous allons changer la valeur de ContextMenuStrip en utilisant la liste déroulante proposée et nous allons sélectionner mainNotificationIconContextMenuStrip. Nous allons pouvoir à présent tester notre programme en le lançant en mode debug et ainsi voir apparaître l'icône dans la barre de notification, ainsi que son menu contextuel (qui ne fonctionne pas, car nous ne l'avons pas encore encodé)

Nous allons maintenant développer les méthodes de réponse aux événements Click de chacun des menus.

Nous cliquons dans la zone de dépôt de contrôles sur mainNotificationIconContextMenuStrip afin de le faire apparaître en dessous du menu standard et faire un double-clique sur "Quitter l'application" du menu contextuel.

Une méthode quitterLapplicationToolStripMenuItem_Click apparaît dans notre code de Main.cs. Nous allons y ajouter la ligne de code qui nous permet de ferme l'application :
this.Close();
Nous allons faire plus ou moins pareil avec l'option "Maximiser la fenêtre".

La propriété que nous allons utiliser est WindowsState de l’instance de la fenêtre Main en cours (renvoyée par this). Cette propriété, accessible en lecture et en écriture obtient ou définit l’état de la fenêtre du formulaire.

Le type de cette propriété est FormWindowsState, qui est en réalité une énumération de variables à valeurs constantes (enum en C#)

Les trois valeurs possibles proposées par cette énumération de valeurs sont : Maximized, Minimized et Normal (en fait, chacune de ces valeurs correspond à un entier unique dans la liste des valeurs, mais c’est bien plus lisible avec une énumération ;))

C’est quoi un Type?
Le Type indique globalement la taille qu’un objet va utiliser en mémoire, la façon dont on va accéder à cette mémoire, et tout ce que cet objet peut faire. C# est un langage fortement typé. Autrement dit, tous les objets que nous allons utiliser ou que nous allons créer en C# doivent avoir un type. Le système de types C# comporte principalement des types valeurs (ou types intrinsèques) et des types références. Les variables de type valeur stockent directement des données (comme un entier ou une date) car le système sait exactement la taille à allouer pour ces données (un int32 fait toujours 32 octets !), alors que les variables de type référence stockent les références aux données (en gros, l’adresse des données en mémoire), car le système ne sait pas nécessairement la taille à allouer (quelle est la taille d’une liste de clients ?). Les types références sont également considérés comme des objets.

C’est quoi une variable ?
Pour les puristes, une variable est une instance d’un type par valeur (type intrinsèque). Bon, de mon coté, je désigne (comme la plupart des développeurs) une variable comme une instance d’un type quelconque, par valeur ou par référence (voire par pointeur si vous devez intégrer des librairie existante en C++ ?). Une variable est composée d’un type et d’un identificateur (aussi dit nom de la variable) :
int counter;
Assigner une variable, c’est lui donner une valeur en mémoire, soit à sa création, soit ultérieurement lors de l’exécution du programme. Une variable est donc fondamentalement en lecture/écriture (d’où son caractère variable [cqfd]).

A la différence d’autres langages du marché, l’assignation des variables est obligatoire en C#. Autrement dit, nous devons nécessairement définir la valeur par défaut que va avoir votre variable, le compilateur ne pouvant le décider pour nous – cela évite bien des bugs difficiles à détecter lors de l’exécution.

C’est quoi une constante ?
Une constante est une variable dont la valeur ne peut pas être changée lors de l’exécution du programme (elle est en lecture uniquement).
Une constante littérale est juste une valeur, comme 6, 12 ou "Coucou" ; D’ailleurs, tapons un point juste après la constante littérale "Coucou" , et nous obtenons par l’IntelliSense tout ce qu’il est possible de faire sur une chaîne de caractères (magique, non ?).

Une constante symbolique est l’assignation d’un nom à une valeur. La déclaration d’une constante symbolique est réalisée par la ligne suivante :
const int valeurMaximumDuCompteur = 42;
C’est quoi une énumération ?
Une énumération est un ensemble de constantes symboliques nommées. Par exemple, en utilisant Reflector pour décompiler le code de l’énumération System.Windows.Forms.FormWindowState (c’est l’énumération que l’on va utiliser – il ne faut pas oublier que l’objectif est de mettre en place le code pour maximiser la fenêtre [c’est fou ce que l’on peut dire à propos d’une seule ligne ?]), on obtient le code suivant :
public enum FormWindowState
{
Normal,
Minimized,
Maximized
}
La valeur des constantes de la liste n’étant pas précisée, le compilateur affecte des valeurs entières en commençant à 0 ; le code ci-dessus est donc similaire à :
public enum FormWindowState
{
Normal = 0,
Minimized = 1,
Maximized = 2
}
Pour revenir à notre code, après avoir double-cliqué sur "Maximiser la fenêtre" nous allons ajouter le code suivant :
private void maximiserLaFenêtreToolStripMenuItem_Click(object sender, EventArgs e)
{
// Maximise la fenêtre en cours
this.WindowState = FormWindowState.Maximized;
}
Nous allons faire pareil avec Minimiser et Restaurer :
private void restaurerLaFenêtreToolStripMenuItem_Click(object sender, EventArgs e)
{
this.WindowState = FormWindowState.Normal;
}

private void minimiserLaFenêtreToolStripMenuItem_Click(object sender, EventArgs e)
{
this.WindowState = FormWindowState.Minimized;
}
Un truc sympathique à faire serait de griser les menus contextuels qui sont inutiles en fonction du contexte de la fenêtre. Par exemple, le menu Maximiser la fenêtre pourrait être grisé quand la fenêtre est en état maximisé.

La propriété que nous allons utiliser est Enabled sur chacun des menus contextuel, en indiquant une valeur booléenne true ou false, pour respectivement le rendre actif ou le griser ;

Où faut-il connecter le code ? Si on regarde le besoin fonctionnel, on a :
le menu Maximiser la fenêtre doit être grisé quand la fenêtre est en état maximisé ; Bon, on va faire un peu d’analyse …

L’utilisation de la conjonction quand dans l’expression fonctionnelle indique l’utilisation d’un événement déclencheur : quand la fenêtre est en état maximisé . Nous allons donc utiliser une fonction de réponse à un événement (« event handler ») ;

La conjonction quand dans l’expression fonctionnelle est généralement suivie de l’objet sur lequel l’événement va porter : quand la fenêtre est en état maximisé. La fonction de réponse à l’événement va donc porter sur la fenêtre en cours (i.e. sur l’objet Main) ;

L’auxiliaire de l’expression fonctionnelle est généralement (dans le cas des événements) suivi du nom francisé (au sens large) de l’événement : quand la fenêtre est en état maximisé. C’est utile lorsqu’on ne connaît pas, à priori, le nom de l’événement à utiliser.

Où faut-il connecter le code, donc ? Dans notre cas, nous allons donc chercher s’il existe, sur l’objet fenêtre (« Form ») un événement comme « StateMaximized », ou « Maximized », ou encore un autre en relation avec la dimension de la fenêtre (« Size » en anglais), car maximiser une fenêtre revient à en changer la taille ; Et c’est là que nous allons connecter le code !

Nous allons faire un clique-droite sur le formulaire (en mode [design]) et ouvrir les propriétés. On clique sur le petit éclair (les events). On s'assure que nous sommes bien sur l'objet Main dont le nom s'affiche en haut dans la liste déroulante.
Dans la liste des événements disponibles, nous allons chercher quelque chose qui se rapproche de State mais comme il n'y en a pas, nous allons nous rabattre sur SizeChanged.

Lorsqu’un événement est au prétérit (c'est-à-dire avec ed à la fin), alors il est déclenché après que l’action ait eu lieu. Par exemple, SizeChanged est déclenché après le changement de taille de la fenêtre, ou encore FormClosed est déclenché après la fermeture de la fenêtre. Si l’événement est au présent progressif (c'est-à-dire avec ing à la fin), l’événement est déclenché en tout début d’action, et il est généralement possible d’interagir avec cette action. Par exemple, FormClosing est déclenché en début de processus de fermeture de la fenêtre et il est possible d’annuler ce processus en laissant la fenêtre ouverte (ce qui est pratique si vous avez des données non sauvegardées …) ;

On fait un double-clique sur l'événement SizeChanged et une méthode est créée dans le code.

L’idée de cette méthode est de configurer la propriété Enabled de chacun des menus contextuels à vrai (true) ou faux (false), en fonction de l’état de la fenêtre.

La méthode va avoir la forme suivante :
private void Main_SizeChanged(object sender, EventArgs e)
{
// Grise les menus en fonction de l'état de la fenêtre
this.maximiserLaFenêtreToolStripMenuItem.Enabled =
!(this.WindowState == FormWindowState.Maximized);
this.minimiserLaFenêtreToolStripMenuItem.Enabled =
!(this.WindowState == FormWindowState.Minimized);
this.restaurerLaFenêtreToolStripMenuItem.Enabled =
!(this.WindowState == FormWindowState.Normal);
}
Le code this.WindowState == FormWindowState.Minimized utilise l’opérateur d’égalité == . Pour les types valeurs, l'opérateur d'égalité == retourne true si les valeurs des opérandes sont égales et false dans le cas contraire. Pour les types références autres que string, == retourne true si ses deux opérandes font référence au même objet. Pour le type string, == compare les valeurs des chaînes.

Le code this.WindowState == FormWindowState.Minimized retourne donc true dans le cas où l’état de la fenêtre est minimisé. Mais nous aimerions que le menu contextuel Minimiser la fenêtre soit grisé quand l’état de la fenêtre est minimisé. Nous allons donc utiliser un autre opérateur, celui de négation logique.

L'opérateur de négation logique ! est un opérateur qui applique une négation sur l’opérande. Il est défini pour un opérande de type booléen et retourne true si, et seulement si, l'opérande est false, et inversement.

Le code !(this.WindowState == FormWindowState.Minimized) retourne donc false dans le cas où l’état de la fenêtre est minimisé, et c’est justement ce que nous aimerions afin que le menu contextuel Minimiser la fenêtre soit grisé quand l’état de la fenêtre est minimisé. Il nous reste donc à assigner la propriété Enabled du contrôle correspondant avec cette valeur, en utilisant l’opérateur d’assignation = ;

L'opérateur d'assignation = stocke la valeur de l'opérande de droite dans l'emplacement de stockage, la propriété (ou l'indexeur, mais cette notion est pour plus tard dans le coach) stipulé par l'opérande de gauche, et retourne la valeur comme résultat.
Les opérandes doivent être de même type (ou l'opérande de droite doit être implicitement convertible au type de l'opérande de gauche).

Et voilà, la ligne de code :
this.minimiserLaFenêtreToolStripMenuItem.Enabled =
!(this.WindowState == FormWindowState.Minimized);
grise donc le menu contextuel Minimiser la fenêtre quand la fenêtre est en état minimisé !

A la différence d’autres langages du marché, en C# l’opérateur d’assignation = est différencié de l’opérateur d’égalité ==, ce qui réduit fortement les risques de mauvaise interprétation des expressions.

Il nous reste à présent à griser le "Restaurer la fenêtre" au démarrage de l'application. En ligne de code, nous allons donc ajouter dans la méthode Main :
// Griser le menu Restaurer la fenêtre
this.restaurerLaFenêtreToolStripMenuItem.Enabled = false;
On peut sauver, et tester. Normalement, tout fonctionne comme nous l'avons souhaité, et nous savons à présent jouer avec les fenêtres et le menus.

jeudi 8 octobre 2009

Atelier 02 - Introduction

Le but de ce 2e atelier va être d'utiliser les types et les structures C#

Il est important pour la suite car on va créer un projet qui va être repris dans les Ateliers suivants.

Le but va simplement être de reproduire informatiquement le schéma suivant :


Il s'agit d'une interface classique Winform, avec une barre de menu standard, une barre de navigation pour naviguer dans une grille de données, avec une icône dans la barre de notifications pour manipuler avec le menu contextuel (ferme, réduire, etc...) le programme.

Nous allons aborder les points suivants :
  • Notions de classes partielles
  • Langage Case Sensitive
  • Le mot clef this
  • Notion d'EventHandler (réponse à un événement)
  • Constructeurs de classes
  • Types de données
  • Assignation de variables
  • Enumérations et constantes
  • Opérateurs (==, !, etc...)
Nous ferons également attention à la notion de localisation, comme traduire un projet dans une autre langue...

Nous allons également nous intéresser à la gestion de la grille de données (application Winform), lecture et écriture d'un fichier CSV (pour commencer)

Lecture d'un fichier CSV -> Mise en mémoire pour faire du Databinding et l'afficher dans la grille de notre programme.

Dans cette grille nous allons également pouvoir ajouter, modifier ou supprimer des données, et resauver les modifications.

Nous allons également voir les notions suivantes :
  • StreamReader, StreamWriter (pour lire le fichier)
  • Les espaces de nommage (namespace)
  • Les fonctions
  • Les mots clefs (TypeOf, New)
  • Passer des paramètres (par valeur ou référence)
  • Le DataBinding
  • Les structures de navigation et de bouclage (foreach)
  • Les conditions (if)
  • Le bloc de code using (délimitation de la portée d'une variable)
  • L'opérateur @
  • Les boîtes de dialogues
  • Les conversions de types de données (cast)
  • ? :
Et nous allons également faire des contrôles dans la saisie des données (pour interdire la saisie de chiffres au lieu de lettres, etc...)

Ce 2e atelier va surtout décrire la grammaire et les différents types que nous allons forcément utiliser dans nos tâches de programmation. Nous allons également aborder les blocs de programmation, importants pour la portée des variables et la gestion de la mémoire.

Dans un premier temps, nous allons programmer "à l'ancienne" comme lorsque l'on programmait en "clients/serveurs" à deux niveaux.

A la fin, nous saurons :
  • Créer une application simple à base de formulaires
  • Différencier les types par référence ou par valeurs
  • Définir la portée des variables
  • Organiser notre code en blocs afin de limiter la portée de nos variables
  • Utiliser les principales instructions de bouclages et de tests
  • Utiliser les principaux opérateurs
  • Utiliser les objets fournis par le Framework

mardi 6 octobre 2009

Atelier 01 - Enrichir le comportement de l'application

On va à présent modifier notre petit programme pour additionner d'autres nombres.

En fait, une fonction d’ajout utilise rarement un nombre fini de paramètres, et de plus est de type entier. L’idée est ici de modifier la méthode afin de pouvoir ajouter un nombre n de valeurs non entières.

On ouvre notre source Calculateur.cs de façon à pouvoir modifier le code. Nous allons modifier la méthode Ajouter en remplaçant
public static int Ajouter(int Valeur01, int Valeur02)
par
public static double Ajouter(double[] Valeurs)
  • Le type de renvoi (double) se place avant le nom de la méthode
  • Le "s" de Valeurs est une convention de nommage pour dire qu'il y'en a plusieurs
  • Le type (double avant les crochets) précède le nom de la variable
  • Les crochets [] indiquent un tableau de réels
On va également ajouter une variable double result; afin de pouvoir récupérer le résultat de notre calcul et modifier la ligne return en spécifiant ce que l'on retourne (result)

On ajoute une boucle foreach afin de prendre en compte les éléments du tableau passé en paramètre.

L’instruction de boucle foreach navigue dans tous les éléments d’une liste ou d’un tableau, en renvoyant à chaque itération l’élément en cours. Il s’arrête automatiquement en fin de liste. Pour sortir de la boucle avant la fin, utilisez l’ordre break;

La boucle va ressembler à :
foreach (double valeur in Valeurs)
{
result = result + valeur;
}
En gros, on va addition à la variable result, les valeurs contenues dans le tableau.

Le code complet va être :
/// <summary>
/// Cette fonction ajoute n valeurs réelles
/// </summary>
/// <param name="Valeurs">Tableau de valeurs à ajouter</param>
/// <returns>le réel en résultat</returns>
public static double Ajouter(double[] Valeurs)
{
// Definition des variables locales
double result;

// Balayage du tableau pour ajouter les valeurs
foreach (double valeur in Valeurs)
{
result = result + valeur;
}

return result ; // retour de la valeur
}
En compilant sous cette forme, nous obtenons une erreur (use of unassigned local variable result)

A la différence d’autres langages (comme VB.Net par exemple), Visual C# nécessite l’assignation systématique des variables à une valeur, c'est-à-dire qu’il ne décide pas à la place du développeur quel est la valeur par défaut des variables. Cela évite des bogues souvent difficile à trouver !

On modifie donc la déclaration de la variable en :
double result = 0;
Dans la boucle, une manière plus élégante d’exprimer le cumul du résultat avec l’élément courant est d’utiliser un opérateur de calcul d’ajout et d’assignation += La ligne devient ainsi result += valeur; Il existe l’équivalent pour la soustraction et la multiplication -= et *= respectivement.

On va générer (built) la nouvelle librairie de clacul seulement sur Coach.Calculateur avec le bouton droite dans l'explorateur de solution (car pour l'instant nous appelons notre méthode avec 2 paramètres au lieu d'un seul donc on aura une erreur si on génère tout le projet)

Pour corriger cette erreur, le mot clé params nous permet de spécifier un paramètre de méthode qui accepte un argument avec un nombre d'arguments variable. Aucun paramètre supplémentaire n'est autorisé après le mot clé params dans une déclaration de méthode et un seul mot clé params est autorisé dans une telle déclaration.

Notre néthode devient donc :
public static double Ajouter(params double[] Valeurs)
Tout se passe bien à présent, mais quel intérêt de pouvoir faire une addition avec le nombre de chiffres que l'on veut, mais ne pas pouvoir les saisir et avoir tout le temps la même réponse.

On va donc à présent modifier le fichier Program.cs et plus particulièrement la méthode Calculateur.Ajouter

On voit que la méthode Main, qui est le point d’entrée de l’application, à un paramètre args qui est un tableau de chaines de caractères : static void Main(string[] args) L’idée est de modifier l’application de façon à ajouter les valeurs passées en argument sur la méthode Main

Pour implémenter cette nouvelle fonction, il va falloir transformer le type des arguments fournis en entrée (chaîne de caractères) en réels, qui sont acceptés par la méthode Calculateur.Ajouter. Cette conversion de types est appelée Casting.

Dans Main, on va ajouter deux variables :
string valeursAAfficher = string.Empty;
double[] valeursACalculer = new double[args.Length];
string.Empty va nous assigner une string vide à la variable, quand à la seconde variable, on définit un tableau de longeur égale au nombre de paramètres passés.

Dans cette exercice nous allons balayer le tableau d’arguments avec une boucle de type for (int i = 0; i < Length; i++)

La boucle va être :
for (int i = 0; i < args.Length; i++) { // Chaîne pour l'affichage valeursAAfficher += args[i] + " "; // Tableau pour le calcul valeursACalculer[i] = Convert.ToDouble(args[i]); }
Il nous faut également modifier la sortie :
System.Console.
WriteLine("L'addition de {0} est : {1}.",
valeursAAfficher,
Calculateur.Ajouter(valeursACalculer));
Le code complet est le suivant :
static void Main(string[] args)
{
// Définition et assignation des variables locales
string valeursAAfficher = string.Empty;
double[] valeursACalculer = new double[args.Length];

// Balayage de la liste des arguments
for (int i = 0; i < args.Length; i++) { // Chaine pour l'affichage valeursAAfficher += args[i] + " "; // Tableau pour le calcul valeursACalculer[i] = Convert.ToDouble(args[i]); } System.Console. WriteLine("L'addition de {0} est : {1}.", valeursAAfficher, Calculateur.Ajouter(valeursACalculer)); System.Console.ReadKey(); }
Afin de tester notre petit programme modifié, nous allons dans les propriétés du projet Coach et dans l'onglet debug, on ajoute dans start options (command line) les valeurs de type double que nous voulons additionner.
Suivant l'OS que nous avons, il nous faut saisir nos chiffres avec des "." ou des ",". Dans mon cas, c'est des "."


Améliorer la robustesse du code

Si on saisit un lettre au lieu de chiffres dans les argurments de la ligne de commande, nous allons obtenir une erreur lors de l'exécution au niveau de la ligne de Casting Convert.ToDouble(args[i])

Cette erreur vient du fait que l’argument contient une chaîne de caractères (A) qui n’est par convertible en réel. Le code n’est donc pas robuste.

C# offre une assistance intégrée pour gérer des situations anormales, appelées exceptions, qui peuvent avoir lieu pendant l'exécution de votre programme. Ces exceptions sont traitées par du code situé hors du déroulement normal du contrôle. Dans notre cas, nous allons utiliser un bloc try … catch … finally. Le bloc try contient le code protégé risquant de provoquer l'exception. Le bloc est exécuté jusqu'à la levée d'une exception ou jusqu'à sa réussite totale. Il est suivi d'une ou de plusieurs clauses catch, qui désignent les gestionnaires des différentes exceptions. Tandis que catch est utilisé pour gérer les exceptions qui se produisent dans un bloc d'instructions, finally sert à garantir l'exécution d'un bloc d'instructions de code quelle que soit la méthode de sortie du bloc try précédent. Une utilisation de la combinaison de catch et finally permet d'obtenir et d'utiliser des ressources dans un bloc try, de traiter des circonstances exceptionnelles dans un bloc catch et de libérer les ressources dans le bloc finally

Après la déclaration de nos deux variables, nous allons ajouter un bloc try (try et Tab Tab) et y insérer le code que nous avons écrit précédemment.
Le résultat va être le suivant :
static void Main(string[] args)
{
String valeursAAfficher = string.Empty;
double[] valeursACalculer = new double[args.Length];

try
{
//Balyage de la liste des arguments
for (int i = 0; i < args.Length; i++) { // Chaine pour l'affichage valeursAAfficher += args[i] + " "; // Tableau pour le calcul valeursACalculer[i] = Convert.ToDouble(args[i]); } System.Console. WriteLine("L'addition de {0} est : {1}.", valeursAAfficher, Calculateur.Ajouter(valeursACalculer)); } catch (Exception) { System.Console.WriteLine("Les arguments doivent être numériques"); } finally { System.Console.ReadKey(); } }
Le code fonctionne, et même si nous saisissons une lettre à la place d'un chiffre, seule une erreur contrôlée sera retournée.


Ajout d'objets sympathiques

Comme nous venons de le voir, Visual C# fournit uniquement une façon d’exprimer un besoin fonctionnel, en respectant la grammaire définie. Les types de base (string, double, int, etc.) sont fournis par le Framework 2.0, qui fournit aussi tous les autres objets dont nous pouvons avoir besoin lors de la programmation. Il y a aujourd’hui dans le Framework certainement plusieurs dizaines de milliers d’objets différents.
La conversion que nous avons réalisée précédemment a été faite au travers d’un objet Convert. Si nous souhaitons lire un port série, gérer des processus, compresser des fichiers, etc. nous devrons utiliser le bon objet du Framework.

En fait, tout est objet avec .Net.

Nous allons à présent retourner le résultat de notre calcul dans une boîte de dialogue windows...

Commençons par chercher le composant dont nous avons besoin, en affichant l'exporateur d'objets (View -> Object browser)
On fait une recherche de "messagebox"
L’explorateur d’objets affiche tous les objets contenant la chaîne cherchée. Dans notre cas, nous voyons que la boîte de message est localisée dans la librairie System.Windows.Forms ;

On va donc ajouter la référence à cette librairie dans notre projet Coach afin de pouvoir l'utiliser.
Au début du programme, on ajoute la librairie que nous voulons utiliser :
using System.Windows.Forms;
Dans le bloc catch, on va modifier la ligne pour faire apparaître une boîte de dialogue :
MessageBox.Show("Les arguments doivent être numériques");
A l'intérieur de la méthode Main, dans le bloc try on va remplacer l'affichage du résultat :
MessageBox.Show(string.Format("L'addition de {0} est : {1}.",
valeursAAfficher,
Calculateur.Ajouter(valeursACalculer)));
Les messages s'affichent à présent dans les boîtes de dialogue.


NotifyIcon

Dans le Framework, il y a beaucoup d’objets de présentation pour tout faire. L’objet à utiliser pour afficher un petit icône dans la barre des tâches en bas à droite de l’écran est le NotifyIcon.

On va aller le chercher dans l'explorateur d'objets... Et comme par magie, il se trouve déjà dans System.Windows.Form

Nous allons ajouter une ressource, en cliquant droite sur le projet Coach et en allant dans le menu ressource (comme le projet n'en contient pas encore, nous allons cliquer sur le lien en bleu)

Les ressources du projet contiennent des chaînes de caractères, des images, des icônes, des fichiers audio, ou encore tout autre type de fichiers, qui vont être inclus à l’intérieur de l’assemblage pour être distribués avec le code compilé.

On choisit d'ajouter un fichier (Add ressource -> Add existing file) et on sélectionne notre icône (pour autant que l'on en ait une (source des ces exercices sur le site Microsoft))
Dans le projet Coach, un nouveau sous répertoire est apparu. C’est le dossier Resources qui contient le contenu des ressources comme les images et icônes. En outre, le sous répertoire Properties contient maintenant un nouveau fichier Resources.resx, qui contient la définition de toutes les ressources du projet.

Au début de la méthode Main, nous allons ajouter le code pour faire apparaître l'icône en bas à droite de l'écran :
NotifyIcon notifyIcon = new NotifyIcon();
notifyIcon.Icon = Properties.Resources.services;
notifyIcon.Visible = true;
notifyIcon.Text = "Application de calcul";
Après un petit essai, tout fonctionne ou presque. Le bouton OK de la boîte de dialogue ne termine pas l'exécution du debugger... Mais ça doit être possible à corriger ;)

lundi 5 octobre 2009

Atelier 01 - Créer sa première solution avec Visual C#

Comme on l'a constaté, il est possible de développer avec un simple éditeur de texte comme notepad++, mais le codage peut être fortement simplifié avec un environnement de développement comme Visual Studio pour le C#

Nous allons donc continuer notre première application en créant une solution contenant deux projets pour gérer nos fichiers de code.

Pour bien comprendre la différence entre une solution et un projet, chaque projet développé avec l’IDE va donner un assemblage .Net avec l’extension .dll ou .exe. Dans le cadre d’un développement, il arrive souvent que la compilation doive donner plusieurs assemblages, comme dans le cas de l’exercice précédent où nous avons un fichier .exe et un fichier .dll. Une solution va contenir des codes de projets différents mais relatifs à une même problématique de codage. Une solution contient donc au minimum un projet.



Organiser la solution

On va commencer par créer un nouveau projet "application console", avec pour nom Coach et l'enregistrer dans notre dossier de travail. Si l'explorateur de solution n'est pas visible, il faut aller dans le menu view -> Solution explorer

On va à présent ajouter à la solution un nouveau projet. Pour ce faire, on clique avec le bouton droite sur Solution (Coach) et on ajoute un nouveau projet. On va sélectionner Class Library que l'on va appeler Coach.Calculateur

L'explorateur de solution affiche à présent deux projet, Coach et Coach.Calculateur

Visual C# est fourni avec (entre autres) les modèles de projet suivants :
- Application Windows : Ce modèle est utilisé pour développer des applications avec une interface utilisateur Windows à base de formulaire ;
- Bibliothèque de classes : Il s’agit ici de développer une bibliothèque de classes qui sera compilée sous forme d’un assemblage d’extension .dll ;
- Application Console : Ce modèle aide à la création d’une application en ligne de commande, très utilisé pour tester des services ou des librairies de classes ;
- Projet vide : Ce modèle sert de base à la création de tout type de programme, les différents éléments et paramètres devant être configurés manuellement ;

Si on regarde sur le disque les fichiers qui ont été créés, on retrouve notre dossier Coach, et à l'intérieur les dossiers Coach et Coach.Calculateur (nos deux projets)

Le fichier Coach.sln est le fichier de solution. On peut l’ouvrir avec le bloc-notes. Il contient la définition de tous les projets composants la solution.

Dans chacun des sous-répertoires de projet, on voit un fichier d’extension .csproj. Il s’agit de notre fichier de projet, qui est utilisé par le compilateur (et MSBuild.exe) pour générer l’assemblage. On peut l’ouvrir avec le Bloc-notes, il est au format XML.

On va récupérer notre fichier Calculateur.cs créé dans l'exercice précédent et le copier dans le répertoire Coach.Calculateur. Dans l'explorateur de solution, on supprime le Class1.cs qui se crée par défaut. On clique sur le bouton en haut qui nous indique Show all files et on va retrouver notre fichier Calculateur.cs que l'on va inclure au projet (bouton droit sur le fichier, Include to Project) car il est pour l'instant grisé.

On va à présent modifier le projet Coach pour utiliser la librairie de calcul (click droit sur le projet Coach et le menu Add reference. Dans l'onglet Project, on va retrouver notre autre projet.

L’ajout d’une référence indique à l’IDE les noms d’objets à prendre en compte pour la vérification des noms lors du codage, et indique au compilateur les librairies à référencer et à copier.

On retrouve dans notre projet Coach, dans le référence, le projet que l'on vient d'ajouter.

Les références déjà présentes ont été ajoutées par le modèle de projet Application Console référencé lors de la création du projet Coach.

On va afficher le code de Program.cs qui se trouve dans le projet Coach en cliquant avec le bouton droit de la souris.

On ajoute le code suivant dans Main() :
System.Console.
WriteLine("L'addition de 10 et 5 est : {0}.",
Calculateur.Ajouter(10, 5));
System.Console.ReadKey();
On sauve, et on peut générer la solution (F6 ou Build -> Build Solution). Normalement, il ne devrait pas y'avoir d'erreur (on le voit tout de suite dans la fenêtre output)

On va ensuite lancer le debugger pour exécuter l'application (Debug -> Start debugging). La console doit s'ouvrir avec notre calcul et son résultat.

Le code aurait aussi pu être généré en utilisant la touche F6. L’application aurait pu aussi être lancée en tapant la touche F5

Les projets compilés sont sous le répertoire bin\debug de chaque projet respectif.

Sous chaque répertoire de compilation bin\debug, le programme [nom de projet].vshost.exe (par exemple Coach.vshost.exe) est le programme qui est utilisé par l’IDE en mode de débogage.

Sous chaque projet, dans le sous répertoire Properties, nous avons un fichier AssemblyInfo.cs qui contient les informations relatives à l’assemblage comme les numéros de version ou le copyright.

Parmi ces propriétés, on retrouvera sur l’onglet Signature celle qui permet de signer avec un nom fort l’assemblage. Cela nous évite d’avoir à générer avec l’utilitaire sn.exe le fichier de paire de clés, et de l’associer en ligne de commande lors de la compilation.



Apprivoiser l'environnement de développement

On va essayer d'utiliser IntelliSense. On ouvre le code de Program.cs et après la ligne System.Console.ReadKey(); on fait un retour de chariot.

On commence à taper le mot sys
Une fenêtre proposant les différents objets est ouverte sous le curseur, en surlignant le mot le plus proche du début que nous venons de taper. C’est l’IntelliSense...
Etant donné que System sera en surbrillance, on peut taper à présent un point (.) et on continuer à taper cons qui nous permettra de saisir le mot Console (avec la touche tabulation le mot sera complété)

IntelliSense est un mécanisme automatique d’auto-sélection qui intervient comme une aide à la programmation et un accès à la documentation. Il propose sans ambiguïté les noms des types, des méthodes, des fonctions et des objets accessibles dans le contexte, et aussi des aides au codage sous forme de blocs de codes préprogrammés.

Les touches à connaître avec IntelliSense sont :
  • Le point (.), pour afficher les membres d'un type
  • Le Tab (Tabulation), pour sélectionner l'élément surligné dans IntelliSense
  • Le Ctrl Espace pour vérifier l'écriture d'un terme présent dans IntelliSense, et en finir la tape si le mot (ou le début de mot) tapé n'a pas d'ambiguïté
  • Le Tab Tab (double tabulation) pour insérer un extrait de code
Lors de la programmation, si IntelliSense ne reconnaît pas un terme alors que nous nous attendions à ce qu’il soit reconnu, c’est que :
  • Ou nous sommes positionné au mauvais endroit
  • Ou la portée de l'objet le rend inaccessible dans notre contexte
  • Ou nous avons oublié de référencer la librairie fournissant cet objet dans notre projet
Dans tous les cas, si IntelliSense ne nous propose pas le terme attendu, nous obtiendrons une erreur de compilation.



Utilisation des extraits de code

Un extrait de code est un bloc préprogrammé reprenant les structures de base de C# pour nous aider à aller plus vite dans nos développements.

Nous allons reprendre le code de notre fichier Program.cs du projet Coach. On ajoute une ligne vierge après l'accolade fermante de la méthode static void Main() et on tape le début de mot prop et on va faire un Tab Tab pour insérer un extrait de code.

Pour visualiser et gérer l’ensemble des extraits de code, on sélectionne le menu Outils > Gestionnaire des extraits de code. Cette fenêtre nous indique notamment l’endroit où ces extraits de code sont installés.



Debuggage


Très pratique, la fonction qui nous permet de debugger notre application. On ouvre le code du fichier que l'on veut débugger (Program.cs dans notre cas) et on va cliquer dans la marge à gauche pour obtenir un point d'arrêt (rouge). Tout le code de la ligne ou de l'instruction (si elle est sur plusieurs lignes) va être en surbrillance.

On fait tourner le debugger (touche F5) et le programme va s'arrêter sur cette ligne. En laissant posée la souris sur une variable, nous aurons sa valeur.

Atelier 01 - Comprendre la compilation .NET

Afin de comprendre la compilation d'un programme en C#, nous allons utiliser le programme IL Disassembler (que l'on doit normalement trouver dans le menu démarrer, tous les programmes, Microsoft.. Pour ma part il se trouve dans Microsoft Windows SDK -> Tools

Une fois lancé, on ouvre avec ce programme, le fichier Calculateur.dll

ildasm affiche sous forme d'arborescence le code désassemblé et les métadonnées de tout fichier exécutable ou librairie compilé spécifiquement pour Microsoft .Net.

Lors d'une compilation C#, le compilateur convertit le code source en langage MSIL (Microsoft Intermediate Language), un jeu d'instructions indépendant du processeur qui est converti ensuite en code natif. MSIL inclut des instructions pour le chargement, le stockage, l'initialisation et l'appel de méthodes sur des objets, ainsi que des instructions pour la réalisation d'opérations arithmétiques et logiques, le flux de contrôle, l'accès direct à la mémoire, la gestion des exceptions et d'autres opérations. Avant d'exécuter du code, vous devez d'abord convertir le langage MSIL en code spécifique du processeur, généralement à l'aide du compilateur JIT (Just-In-Time) fourni par le Framework .Net dans le Common Language Runtime (CLR). On dit alors que le code est géré par le CLR, d’où le nom de code managé.

Lorsqu'un compilateur produit un code MSIL, il génère aussi des métadonnées. Les métadonnées décrivent les types contenus dans votre code, y compris la définition de chaque type, les signatures des membres de chaque type, les membres référencés par votre code, et d'autres données que le runtime utilise au moment de l'exécution. Le code MSIL et les métadonnées sont stockés dans un fichier exécutable portable (PE) qui est basé sur le fichier Microsoft PE publié qu'il prolonge et sur le format COFF (Common Object File Format) utilisé traditionnellement pour le contenu exécutable. Ce format de fichier, qui accepte le code MSIL ou le code natif ainsi que les métadonnées, permet au système d'exploitation de reconnaître les images du Common Language Runtime. La présence de métadonnées dans le fichier en même temps que le jeu d'instructions MSIL permet à votre code de se décrire lui-même, ce qui signifie que les bibliothèques de types et IDL (Interface Definition Language) ne sont pas nécessaires. Le runtime recherche les métadonnées dans le fichier et les extrait selon les besoins, au moment de l'exécution.

Le code MSIL ressemble à un assembleur évolué et indépendant de la plateforme ; il vous est possible de le modifier.

On va dumper (File, Dump) le fichier Calculateur que l'on vient d'ouvrir avec le désassembleur et le sauver avec le reste du code, mais au format .il
On ouvre ce fichier .il avec notepad (pour ma part notepad++ car c'est un superbe programme) et on va chercher la ligne de l'addition add et la remplacer par mul
.class public auto ansi beforefieldinit Coach.Calculateur
extends [mscorlib]System.Object
{
.method public hidebysig static int32 Ajouter(int32 Valeur01,
int32 Valeur02) cil managed
{
// Code size 9 (0x9)
.maxstack 2
.locals init (int32 V_0)
IL_0000: nop
IL_0001: ldarg.0
IL_0002: ldarg.1
IL_0003: mul
IL_0004: stloc.0
IL_0005: br.s IL_0007

IL_0007: ldloc.0
IL_0008: ret
} // end of method Calculateur::Ajouter
On sauve le fichier et nous allons le réassembler avec la commande ilasm.exe

Nous devons fermer le désassembleur pour éviter les erreurs, et supprimer la dll.
La commande à taper pour recompiler la dll est la suivante (suivant où se trouve ilasm.exe) :
ilasm calculateur.il /DLL
Par défaut, ilasm.exe tente de compiler le code .il avec une extension .exe. Dans notre cas, la librairie n’ayant pas de point d’entrée (elle n’a pas de bloc static void Main() ), nous devons préciser que nous voulons une librairie en utilisant le switch /DLL .

Dans l'invite de commande, nous allons pouvoir taper PremierProgramme, et normalement (car dans mon cas cela n'a pas fonctionner, mais vu que je n'ai pas la même version de .NET je me suis dit que c'était presque normal...) et nous aurions dû obtenir la réponse 50 au lieu des 15 précédemment.

Comme on vient de le voir, le compilateur C# transforme le code C# en MSIL, puis le code est assemblé dans un fichier d’extension .dll. C’est pour cette raison que nous appelons les librairies compilées avec .Net « assemblage » (ou « assembly » en littérature anglaise).

Comme on vient de le faire, on peut imaginer modifier relativement facilement un assemblage compilé, en le désassemblant avec ildasm.exe, puis en réassemblant avec ilasm.exe. Dans de nombreuses applications, cela ne posera aucun souci, mais il arrive parfois que des enjeux économiques, ou un engagement de sécurité nécessitent de se protéger contre une telle pratique. Nous allons donc signer avec une clé le code. Par la suite, sans cette clé (qu’il ne faudra donc pas distribuer), il sera impossible de réassembler un code MSIL sans générer une erreur lors de l’exécution du programme utilisant cet assemblage.

Je vais zapper cette partie, étant donné que je ne retrouve pas les même commandes entre Visual Studio 2005 et 2008, ainsi qu'entre le2 Framework 2.0 et 3.5 et que je n'ai pas forcément l'envie de chercher cette information, mais je sais que c'est possible de le faire.


Partage de l'assemblage avec d’autres programmes

Pour la plupart des applications .NET Framework, on localise les assemblages qui composent notre application dans le répertoire de l'application. Il est néanmoins possible de les mettre ailleurs, soit dans un sous répertoire de l’application (en paramétrant ce chemin dans la configuration de l’application), soit dans un référentiel centralisé contenant tous les assemblages partagés installés sur notre poste de travail. Ce référentiel centralisé est le Global Assembly Cache ou GAC.

Chaque ordinateur sur lequel le Common Language Runtime (CLR) est installé possède un cache de code à l'échelle de l'ordinateur appelé Global Assembly Cache (GAC). Le GAC stocke les assemblages spécialement destinés à être partagés entre plusieurs applications sur l'ordinateur. Vous ne devez partager des assemblages en les installant dans le GAC qu'en cas de nécessité. En règle générale, vous devez garder les dépendances vers les assemblages privés et rechercher les assemblages dans le répertoire de l'application. En outre, il n'est pas nécessaire d'installer des assemblages dans le GAC pour les rendre accessibles à COM Interop ou au code non managé.

Le GAC est sur le disque de notre ordinateur, dans le répertoire assembly sous le répertoire d’installation de Windows (donc, classiquement dans c:\Windows\assembly).

Le GAC n’est pas un répertoire comme les autres, car il peut contenir des assemblages ayant un même nom, mais des numéros de versions différentes.

Petit test, nous allons créer un fichier CalculateurInfos.cs et le remplir du code suivant :
[assembly: System.Reflection.AssemblyVersion("1.1.2.0")]
[assembly: System.Reflection.AssemblyFileVersion("1.2.2.0")]
[assembly: System.Reflection.AssemblyTitle("Calculateur")]
[assembly: System.Reflection.AssemblyDescription("")]
[assembly: System.Reflection.AssemblyConfiguration("")]
[assembly: System.Reflection.AssemblyCompany("Agilcom")]
[assembly: System.Reflection.AssemblyProduct("Coach")]
[assembly: System.Reflection.AssemblyCopyright("© 2007")]
[assembly: System.Reflection.AssemblyTrademark("")]
[assembly: System.Reflection.AssemblyCulture("")]
Dans l’invite de commande, compilez le code C# du calculateur, en référençant maintenant les informations de l’assemblage et en l’associant avec votre fichier de clés, en tapant l’ordre :
csc /target:library calculateur.cs calculateurinfos.cs
Dans l’invite de commande, recompilez maintenant le programme principal, en tapant l’ordre suivant :
csc premierprogramme.cs /reference:calculateur.dll
En testant PremierProgramme, tout se passe bien, nous avons le bon fonctionnement du programme.
Dans l’invite de commande, tapez l’ordre suivant pour ajouter l’assemblage au GAC : gacutil /i calculateur.dll
Et normalement (je n'ai pas pu tester...) nous devrions retrouver notre dll dans le répertoire assembly

En détruisant la dll qui se trouve dans le dossier où nous avons les sources, le programme devrait quand même fonctionner en allant chercher les infos manquantes dans le GAC.


La documentation

Dans tous les livres, et partout sur le net, on trouvera que la documentation et ce qu'il y'a de plus important dans un code, bien que ce soit pénible à faire... Le C# va nous aider à faire une bonne documentation, sans pénaliser notre principale fonction : développer.

C# propose quatre catégories de commentaires, que nous pouvons utiliser dans nos développements :
- La ligne simple de commentaire, précédée par //
- Les commentaires délimités, encadrés par /* notre commentaire */
- La ligne simple de documentation, précédée par ///
- Et enfin, la documentation délimitée, qui combine les deux possibilités précédentes ;
L’intérêt de la ligne simple de documentation et de la documentation délimitée est qu’au moment de la compilation du code, il est possible de préciser que l’on souhaite l’extraction de la documentation. Un fichier XML est alors généré, et il suffit d’y appliquer une feuille de style XSL-T pour obtenir la documentation de notre code

Nous allons modifier le code Calculateur.cs :
/*
Auteur : Resize
Commentaire : Programme de calcul avancé
Révisions et Modifications
---------------------------------------------------
Date Par Commentaires
03/10/2009 Resize Version Initiale

*/

namespace Coach
{
/// <summary>
/// Cette classe implémente les fonctions de calcul
/// </summary>
public class Calculateur
{
/// <summary>
/// Cette fonction ajoute deux valeurs entières
/// </summary>
/// <param name="Valeur01">Première valeur</param>
/// <param name="Valeur02">Deuxième valeur</param>
/// <returns>l'entier de résultat</returns>
public static int Ajouter(int Valeur01, int Valeur02)
{
return Valeur01 + Valeur02; // retour valeur
}
}
}

On recompile le programme avec la commande suivante :
csc /target:library calculateur.cs calculateurinfos.cs /doc:calculateur.xml
Un nouveau fichier .xml a été créé. On peut l'ouvrir et voir ce qu'il contient. On peut lui ajouter un fichier xsl pour que ce soit plus digeste.