Cours2 : Premier contact avec le C#
Il
est maintenant temps d'apprendre à écrire un
programme C#. Il est possible que vous ne compreniez pas tout ce
que nous ferons. C'est normal, le but de ce chapitre étant
de nous "faire prendre contact".
Ce chapitre et les
suivant partent de l'hypothèse que vous avez installé
la plate-forme de développement .NET correctement comme
expliqué dans le chapitre précédent et que
vous y avez appris à configurer votre environnement.
Sommaire
1. Hello C#
3. Les classes
4. La déclaration d'une classe
6. Les méthodes
7. Entête et corps d'une fonction
9. la présentation du code source
10. Les tokens
11. les commentaires
Ouvrez votre éditeur de texte et saisissez le programme suivant en respectant la mise en forme :
class PremierProgramme
{
public static void Main()
{
System.Console.Out.WriteLine(" Bonjour de la part de C#");
}
}
case
sensitive : En java, les majuscules et les minuscules sont
considérées comme des caractères différents.
Ainsi WriteLine est différent de writeline.
Sauvegardez
ce code source avec le nom bonjour.cs dans un répertoire
que nous nommerons intelligemment chapitre1 à l'intérieur
du dossier que nous avons créé spécialement
pour nos sources C#. Double cliquez sur l'icône de raccourci
pour ouvrir une fenêtre MSDOS et tapez dans celle-ci :
csc bonjour.cs
Puis
validez par la touche Entrée .
Si vous obtenez une
erreur, c'est que le nom du fichier source que vous avez spécifié
comporte des fautes ou ne se trouve pas dans le répertoire
où vous avez appelé csc. Cette commande a pour effet
d'appeler le compilateur (csc.exe) et de lui faire compiler notre
fichier source. Un fichier bonjour.exe va alors être crée
dans le même répertoire. Ce dernier contient le code
IL obtenu à partir de notre source. Si nous appelons
maintenant notre programme ainsi :
bonjour
Le .NET framework va alors compiler de nouveau l'IL en code natif avant de l'exécuter. Au bout de une à deux secondes vous devriez alors avoir la sortie :
Bonjour de la part de C#
Si
vous appelez encore une fois le programme, vous obtiendrez de
nouveau cette sortie mais cette fois-ci instantanément car
le code sera déjà en natif et ne devra pas subir une
phase de pré-compilation.
Si le code IL était
portable, le code natif lui, ne peut être utilisé que
sur les systèmes où il aura été
exécuté pour la première fois.
Legend
Etudions
maintenant le code source que nous venons d'écrire.
Erreurs
: Si le compilateur vous renvoie un autre message que celui énoncé
ci-dessus en respectant les majuscules c'est que vous avez mal
recopié le programme. Vérifiez bien votre source
afin de détecter d'éventuels bugs&.
Legend
Le code que nous allons analyser est pratiquement incompréhensible pour nous à cet instant (bien que nous puissions deviner le rôle de certains bout de code). Nous allons maintenant tenter d'en expliquer la signification. Certains éléments, du fait de nos connaissances encore faibles sur un grand nombre de points, resteront encore obscurs à la fin de ce chapitre
Le C# étant un langage à 99% orienté objet, nous ne pouvions pas éviter les classes dans notre premier programme. Mais aucune crainte à avoir ; leur création, comme nous allons le voir, s'avère très simple.
class PremierProgramme
{
public static void Main()
{
System.Console.Out.WriteLine(" Bonjour de la part de C#");
}
}
La
première ligne de notre programme commence par le mot class
qui indique au compilateur que nous allons créer une
nouvelle classe. Celui-ci est alors suivi du nom de la classe qui
est ici PremierProgramme.
La création d'une classe dans
un fichier se fait en deux étapes. Dans un premier temps sa
déclaration, comme nous venons de le voir, et dans un
second temps sa définition. Ces deux étapes sont
toujours côte à côte.
Legend
class PremierProgramme
{
public static void Main()
{
System.Console.Out.WriteLine(" Bonjour de la part de C#");
}
}
La
définition d'une classe se fait à l'intérieur
de ce qu'on appelle un bloc. Un bloc en C# est une zone de code
délimitée par une accolade ouvrante et une accolade
fermante. A l'intérieur de celui-ci nous définirons
les membres de cette classe.
codeurs
Java : Contrairement au langage Java, un fichier source n'a pas
besoin de porter le même nom que la classe principale qui y
est définie.
La déclaration de classe se
fait ainsi très simplement. Dans le programme ci-dessous
nous créons, en quelques lignes, deux classes de plus :
Inutile et Inutile2 :
class PremierProgramme
{
public static void Main()
{
System.Console.Out.WriteLine(" Bonjour de la part de C#");
}
}
class Inutile
{
}
class Inutile2
{
}
Un code bien rédigé : Le code ci-dessus est là
pour illustrer la simplicité de la création de
classes en C#. Il s'avère malheureusement mal écrit.
Il est, en effet, d'usage de créer une classe par fichier
source, mais nos premiers programmes étant basiques, nous
faisons cela pour des raisons de simplicité
Text
class PremierProgramme
{
public static void Main()
{
System.Console.Out.WriteLine(" Bonjour de la part de C#");
}
}
La premières instructions qui se trouvent dans le bloc de définition de la classe créent une méthode qui se nomme Main.
Une
méthode est un groupe d'instructions reliées
logiquement auquel on attribue un nom.
Tout comme les classes,
les méthodes sont créées en deux étapes.
La première étape est l'entête de la fonction,
la seconde étape est son contenu (corps).
Legend
Les méthodes prennent généralement des valeurs qui vont leur permettre d'effectuer un traitement et renvoient une valeur en retour comme résultat. Les paramètres que prend la méthode sont placés entre les parenthèses ouvrantes et fermantes (nous reviendrons sur les paramètres bientôt). Ici Main ne prend donc aucune valeur en entrée. Le mot clé void qui précède le nom de la fonction indique que celle-ci ne renverra aucune valeur. Les mots public et static décrivent les caractéristiques de notre méthode. public indique que notre méthode peut être utilisée par n'importe quelle autre classe. Le mot clé static indique que tous les objets instances de notre classe utiliseront la même méthode et non pas une version qui leur est propre.
Un
programme peut contenir un nombre illimité de classes qui
peuvent elles-mêmes contenir un nombre illimité de
membres. Mais il devra obligatoirement y avoir une méthode
dont le nom sera Main. C'est par les instructions que contient
cette méthode que débutera en effet notre programme.
Ce dernier a toujours besoin d'un point de départ pour
débuter son traitement.
codeurs Java C++ ou C : La fonction principale d'un programme est
Main et non pas main comme dans les langages dérivés
du C
Généralement cette fonction contient
la déclaration des différents objets qui seront les
principaux acteurs de notre programme, mais aussi l'appel de leurs
méthodes qui vont permettre de les "démarrer".
Main ne fait pas vraiment partie de l'objet qui la contient mais
le C# étant pratiquement à 100% orienté
objet, il n'est pas possible de créer la fonction en dehors
d'une classe comme cela est le cas en C++. Notre objet
PremierProgramme n'aura donc ici qu'un seul but : contenir la
méthode qui lancera notre programme.
Si nous avions créé
un fichier source avec une seule classe sans fonction Main :
class PremierProgramme
{
}
Le compilateur nous aurait renvoyé l'erreur :
Legend
Voyons maintenant l'unique instruction de Main.
class PremierProgramme
{
public static void Main()
{
System.Console.Out.WriteLine(" Bonjour de la part de C#");
}
}
Le
corps de cette méthode est un appel à une à
une autre méthode à laquelle on donne un paramètre.
La méthode appelée est WriteLine. Cette dernière
prend un paramètre de type chaîne de caractères
(ici " Bonjour de la part de C#") et l'affiche sur la
sortie standard en la faisant suivre d'un saut de ligne (console
MSDOS pour Windows, terminal xterm pour Unix et compatible etc.).
Cette chaîne de caractères (placée entre les
parenthèses) est différenciée par le
compilateur des autres instructions parce qu'elle est délimitée
par des guillemets.
La méthode WriteLine est au
départ inconnue du compilateur nous devons donc lui
spécifier où elle se trouve définie afin
qu'il comprenne son fonctionnement et apprenne à
l'utiliser. Nous lui indiquons ainsi que cette fonction fait
partie de l'objet Out qui appartient lui-même à la
classe Console. Le compilateur devra donc connaître la
classe Console pour pouvoir compiler notre programme sans générer
d'erreurs. System peut être considéré comme un
chemin d'accès à cette classe. System est un
namespace.
Legend
Un
namespace est un groupement de fonctions ayant un lien logique. Le
namespace System contiendra donc la plupart des classes dont les
objets auront des actions sur le système d'exploitation sur
lequel est installé le framework.
Il est possible de
spécifier dès le départ où se trouvent
les Classes dont nous allons nous servir dans le programme en
utilisant la directive using.
using System;
class PremierProgramme
{
public static void Main()
{
Console.Out.WriteLine(" Bonjour de la part de C#");
}
}
Dans ce programme le compilateur sait que nous utilisons le namespace System lorsque nous ferons appel à une classe qu'il ne connait pas, il ira y puiser les informations dont il a besoin. Il n'est maintenant plus nécessaire d'indiquer le chemin d'accès de la classe Console comme nous le faisions avant :
System.Console.Out.WriteLine(" Bonjour de la part de C#");
Nous pourrons écrire désormais directement :
Console.Out.WriteLine(" Bonjour de la part de C#");
Maintenant que nous comprenons a peu près correctement notre programme, essayons de le rendre plus lisible.
Ecrire un programme lisible et bien documenté est très important. C'est un élément primordial dans la recherche de bug. Cela permet en outre d'élaborer des programmes bien conçus et de donner une chance à d'autres programmeurs de comprendre votre travail.
Lorsqu'on écrit un texte dans une langue, il faut le faire avec les symboles qui sont admis par cette langue pour la formation de phrases et de mots. Cette liste de symboles est le jeu de caractères de ce langage. En C# le jeu de caractères suivant est admis :
Legend
En assemblant ces caractères d'une certaine manière, il nous est possible de créer des tokens (éléments lexicaux de base) qui seront séparés par les caractères d'espacements (espace, tabulation, retour chariot, ou saut de page).
Using System;
class PremierProgramme
{
public static void Main()
{
Console.Out.WriteLine(" Bonjour de la part de C#");
}
}
dans
le programme, Main, Console Out, WriteLine, les mots clés
class public ou static sont des tokens.
Mot clé : Un mot clé est un nom prédéfini
que le programmeur n'a pas le droit d'utiliser dans son programme
pour ses propres données.(voir annexe pour plus de
détails)
Notre chaîne de caractères
"Bonjour de la part de C#'' est un token. Tout comme la
ponctuation , soit les points, les points virgules, mais aussi les
parenthèses ou les accolades.
Un token ne peut pas être
divisés en plusieurs éléments séparés
par des espacements. Notre fonction principale Main ne peut pas
s'écrire ainsi :
M a in
Par contre il est possible d'espacer à volonté les tokens :
using System;
class
PremierProgramme
{
public
static
void
Main
(
)
{
Console.Out.WriteLine(
" Bonjour de la part de C#"
);
}
}
ou encore :
using System;class PremierProgramme{public static void Main(){Console.Out.WriteLine(
" Bonjour de la part de C#");}}
Dans les deux cas ci-dessus le programme s'avère illisible.
Pour
faciliter la compréhension d'un fichier source lors d'une
relecture, le langage C# permet l'utilisation de commentaires. Les
commentaires peuvent êtres insérés en
n'importe quel endroit d'un fichier source où les
caractères d'espacement sont autorisés sauf dans les
chaînes de caractères.
C# permet deux syntaxes,
les commentaires peuvent être introduits par l'utilisation
d'un // ou délimités par les symboles /* et */.
Lors
de la compilation, les commentaires seront évidemment
enlevés du fichier IL généré.
Ces commentaires sont indiqués au C# en les faisant précéder des deux barres obliques //
//voilà un commentaire&.
Le compilateur en lisant le symbole // ignorera tous les caractères suivants jusqu'à la fin de la ligne. Il est ainsi possible de faire :
using System; //inclusion de la bibliothèque System
les commentaires introduits avec l'aide de // sont donc utilisés pour de brèves explications à l'intérieur d'une ligne. Ils commencent généralement par un verbe à l'infinitif
//afficher le texte
System.Console.Out.WriteLine("atchoum "),
Si nous voulons mettre des commentaires sur plusieurs lignes d'affilée, rajouter des // à chaque fois peut s'avérer être une opération fastidieuse& Il vaut mieux dans ce cas utiliser le second moyen :
Il est possible une fois encore d'introduire un commentaire dans votre source en le délimitant par /* et */. Tous caractères se trouvant entre ces deux bornes est ignoré par le compilateur.
/* voici un commentaire sur plusieurs lignes & */ /** voici un commentaire */ erroné*/ /*par contre celui là est // autorisé*/
Ces commentaires sont généralement utilisés pour la présentation d'un fichier source ou d'un membre d'une classe. Voici comment notre programme aurait pu concilier harmonieusement les deux commentaires :
//bonjour.cs
/**************************************************/
/* */
/* premier programme d'apprentissage du C# */
/* */
/* Valentin BILLOTTE - " Le langage C # " 2001 */
/* */
/**************************************************/
//utiliser le namespace System
using System ;
/**
* objet qui affiche un message de bienvenue
*/
public class PremierProgramme
{
/**
* fonction principale du programme
*/
public static void Main()
{
//afficher le texte
Console.Out.WriteLine("Bonjour de la part de C#") ;
}
}
//fin bonjour.cs
Dans
cette version, notre programme peut être compris par
quelqu'un qui n'a jamais fait du C#.
Pour l'impression : afin de nous permettre de reconnaître du
premier coup d'oeil un source après une impression, il nous
suffit comme dans le code ci-dessus de mettre en commentaire à
la première ligne : //bonjour.cs