Affichage des articles dont le libellé est C#. Afficher tous les articles
Affichage des articles dont le libellé est C#. Afficher tous les articles

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.

Atelier 01 - Développer un premier programme C#

Avec C#, nous avons la possibilité de développer n'importe quel type d'applications, comme des applications windows (ce qui va être le cas dans le premier chapitre), des applications web, ou des services web.

Le tutorial sera plus basé sur le langage que sur le type d'application.

Objectifs : Ecrire du code sécurisé et propre

Pour commencer, nous allons écrire un petit programme à l'aide du bloc-note, et le compiler avec csc.exe
namespace Coach //espace de nommage
{
class programme
{ //les accolades représentent le début et la fin de chaque bloc
static void Main() //C'est le point d'entrée du programme
{
System.Console.WriteLine("Bonjour à tous");
System.Console.ReadKey(); //Le ; indique la fin de la ligne
}
}
}
Sauver et ça y'est, notre premier programme est fait.

Attention, le langage est sensible à la casse.

La première ligne du programme est namespace Coach. Durant ce tutorial, vous allez créer de nombreux noms d’objets ou de types. Pour éviter les conflits avec des noms déjà existants, l’espace de nommage précise à quoi se rattache le nom. C’est un peu le nom de famille des objets que vous allez créer. Par exemple, la classe programme a comme nom de famille Coach. Son nom complet est donc Coach.Programme.

Afin de nous faciliter la tâche, nous allons rendre accessible la commande csc.exe avec la commande suivante depuis le répertoire où nous avons sauvé notre code :
PATH C:\WINDOWS\Microsoft.NET\Framework\v3.5
A présent, nous pouvons compiler directement depuis le répertoire où se situe notre programme en tapant :
csc.exe PremierProgramme.cs
Ce qui nous génère un fichier PremierProgramme.exe que nous pouvons exécuter.

Nous avons utilisé la commande par défaut. Mais nous allons à présent compiler une librairie.

Il arrive souvent que des codes complexes nécessitent plusieurs fichiers différents pour exprimer des besoins différents, ou que des fonctions soient partagées par plusieurs programmes. Dans ce cas, une bonne pratique est de regrouper ces fonctions partagées dans des librairies qui seront compilées et utilisées par tous les programmes qui en ont besoin.

Dans notre répertoire de travail, nous allons créer un fichier Calculateur.cs
namespace Coach
{
public class Calculateur
{
public static int Ajouter(int Valeur01, int Valeur02)
{
return Valeur01 + Valeur02;
}
}
}
Ce code ne contient pas de bloc static void Main() car c'est une librairie qui va être appelée par l'exécutable et non être lancée toute seule. Les librairies ont une extension .dll

Pour compiler cette librairie, nous allons utiliser la commande suivante :
csc /target:library Calculateur.cs
Nous avons créé une DLL dans le dossier où se trouve notre programme.

Nous allons modifier notre premier programme. A la place de lui faire dire bonjour, nous allons lui faire faire un calcul.
System.Console.WriteLine("L'addition de 10 et 5 est : {0}.", Calculateur.Ajouter(10,5));
à la place de
System.Console.WriteLine("Bonjour à tous !");
Nous allons à nouveau compiler le programme, mais en précisant que nous voulons également utiliser la dll
csc PremierProgramme.cs /reference:Calculateur.dll
Le programme .exe est créé, il ne nous reste plus qu'à l'exécuter et admirer le résultat.


dimanche 4 octobre 2009

Outils de développement

Précédemment, nous avons utilisé le compilateur en mode de commande avec notepad, mais il y'a également la possibilité d'avoir un environnement de travail plus agréable, avec notamment Visual Studio (différentes versions, 2005, 2008, et les Express qui sont gratuites)

Visual Studio est un outil pour tirer parti de la puissance du .NET et gagner en efficacité. C'est un éditeur moderne avec des outils de saisie de code qui permettent d'avoir l'IntelliSense, gagner du temps en saisie de code et éviter les erreurs.

Le FrameWork .NET est composé de différents modules, à commencer (dans l'ordre inverse) par :

L'environnement d'exécution (qui gère les mécanisme, comme la mémoire par exemple.
Un ensemble de librairies (que l'on va manipuler en déveleloppant les applications, qui vont être instanciées en phase d'exécution
  • Base Class Library, où l'on retrouve les fonctionnalités de manipulation de fichiers, les accès d'entrée/sortie
  • ADO.NET, qui va nous permettre la manipulation de bases de données relationnelles ou données XML (soit en lecture de fichiers, soit en export en format XML)
  • Webform, qui permet de développer des applications web, en ASP.NET
  • Mobile Forms, pour développer sur des plateformes PocketPC
  • Windows Forms, qui nous permet de faire des applications développées sous Windows
Au dessus de ça, nous avons le choix du langage, entre C#, Visual Basic .NET, etc...

Le modèle de programmation unifié de .NET

Au départ, nous avions les API Windows (et COM), ensuite 3 différents langages, comme le Visual Basic 6, C++ ou l'ASP, et à présent, tout est unifié en .NET

Migration

La migration ne se passe pas en 1=1, c'est à dire qu'il y'aura certainement quelques adaptations à faire si l'on passe de VB6 à Visual Basic .NET, le code n'est pas tout à faire pareil.

Si on migre de .NET 1.1 à 3.5, pas de problème




Les applications .NET sont prêtes pour le 64-bit

Premier programme

Pour le premier programme, on va utiliser le compilateur csc.exe (csc.exe /? permet de voir tous les paramètres)

Ce premier programme sera le fameux "Hello World"... En ligne de commande, à l'exécution de ce programme, on va obtenir une ligne de texte...

Pour commencer, on va utiliser Nodepad, et créer un simple fichier hello.cs
using System;

namespace HelloWorld
{
class Program
{
static void Main()
{
Console.WriteLine("Hello World !");
}
}
}
(le code n'est pas tout à fait le même que celui présenté dans la vidéo, mais il ne fonctionnait pas... Erreur de compilations, pas de namespaces, etc... Est-dû à la version du Framework ? J'en doute...)

On sauve le fichier, et on le compile : csc hello.cs, ce qui va nous créer un fichier exécutable hello.exe

On peut exécuter ce fichier et admirer notre oeuvre.