Affichage des articles dont le libellé est Visual Studio. Afficher tous les articles
Affichage des articles dont le libellé est Visual Studio. 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 ;)

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.

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