Affichage des articles dont le libellé est Références. Afficher tous les articles
Affichage des articles dont le libellé est Références. Afficher tous les articles

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 ;)