Tutoriel : Apprenez à développer en C#

A qui s’adresse ce tutoriel ?

Aux débutants ! Pas besoin d'avoir fait du développement avant pour suivre ce tutoriel ! Je vais donc faire de mon mieux pour détailler au maximum mes explications, c'est promis.
Mon but est réellement de rendre ce tutoriel accessible pour les débutants.

Bien sûr, il y en a peut-être parmi vous qui ont déjà fait du C, du C++, du Java... Evidemment, si vous avez déjà fait du développement informatique, ce sera plus facile pour vous (surtout pour la première partie qui présente les bases du langage). Attention néanmoins de ne pas vouloir aller trop vite : le C# ressemble à d'autres langages mais il a quand même ses spécificités !

Esprit du tutoriel

Nous allons découvrir ensemble de nombreuses choses en apprenant à développer en C#. Il y aura bien entendu des TP pour vous faire pratiquer, afin que vous puissiez vous rendre compte de ce que vous êtes capables de faire après avoir lu plusieurs chapitres plus théoriques.

Néanmoins, je veux que vous soyez actifs ! Ne vous contentez pas de lire passivement mes explications, même lorsque les chapitres sont plutôt théoriques ! Testez les codes et les manipulations au fur et à mesure. Essayez les petites idées que vous avez pour améliorer ou adapter légèrement le code. Sortez un peu des sentiers battus du tutoriel : cela vous fera pratiquer et vous permettra de découvrir rapidement si vous avez compris ou non le chapitre.
Pas d'inquiétude, si jamais vous bloquez sur quoi que ce soit qui n'est pas expliqué dans ce cours, la communauté qui sillonne les forums saura vous apporter son aide précieuse.

Durée d’apprentissage

Il faut compter plusieurs semaines pour lire, comprendre et assimiler ce tutoriel. Une fois assimilées toutes les notions présentées, il vous faudra plusieurs mois pour atteindre un niveau solide en C#. Après tout, c'est en forgeant qu'on devient forgeron.

D'ailleurs merci de m'informer du temps que vous a pris la lecture de ce cours pour que je puisse indiquer aux autres lecteurs une durée moyenne de lecture.

C'est tout ?

Non rassurez-vous, le tutoriel est loin d'être fini, vous ne voyez donc pas toutes les parties. Vous découvrirez dans ce tutoriel le début des rudiments du développement en C#. Petit à petit je compléterai le tutoriel pour ajouter la suite des rudiments du langage. Ensuite, je présenterai la programmation orientée objet et comment en faire avec le C#. Enfin, pour aller plus loin, nous étudierons l'accès aux données et d'autres surprises encore.

Le début de ce cours sera plutôt théorique. Pour savoir coder, il faut commencer par apprendre les bases du langage, c'est un passage obligé.
Petit à petit j'introduirai la pratique pour illustrer certains points importants ; cela vous permettra de mieux comprendre des fonctionnements et surtout de bien mémoriser le cours.

Allez plus loin !

N'hésitez pas à regarder d'autres tutoriels portant sur le sujet. Il est toujours bon de diversifier ses sources pour avoir différentes approches du sujet.

De manière générale, je vous recommande de ne pas hésiter à tester les codes que je présenterai au fur et à mesure. Surtout, si vous avez des idées pour les améliorer un peu, faites-le ! Ca ne marchera pas à tous les coups, mais cela vous fera beaucoup plus progresser que vous ne le pensez ! Ne comptez donc pas uniquement sur les TP pour pratiquer, ce serait dommage.

Sachez aussi que je suis ouvert à toutes remarques, critiques, questions, ... portant sur ce tutoriel. N'hésitez donc pas à poster des commentaires, surtout si votre message peut être utile pour d'autres personnes. Par contre, veuillez ne pas m'envoyer de MP, sauf en cas de force majeure, parce que je n'aurai pas le temps de vous répondre individuellement, et que s'il s'agit d'une demande d'aide, les forums sont là pour ça et on vous y répondra plus rapidement que moi.

Le C# est un langage de programmation créé par Microsoft en 2002.

Ces applications informatiques peuvent être de beaucoup de sortes, par exemple une application Windows, comme un logiciel de traitement de texte ou une calculatrice ou encore un jeu de cartes. On les appelle également des clients lourds. Il est également possible de développer des applications web, comme un site d’e-commerce, un intranet, … Nous pourrons accéder à ces applications grâce à un navigateur internet que l’on appelle un client léger. Toujours grâce à un navigateur internet, nous pourrons développer des clients riches. Ce sont des applications qui se rapprochent d’une application Windows mais qui fonctionnent dans un navigateur.
Bien d’autres types d'applications peuvent être écrites avec le C#, citons encore le développement d’applications mobiles sous Windows phone 7, de jeux ou encore le développement de web services …

Nous verrons un peu plus en détail en fin de tutoriel comment réaliser de telles applications. Chacun de ces domaines nécessite un tutoriel entier pour être complètement traité, aussi nous nous initierons à ces domaines sans aller trop loin non plus.

Le C# est un langage dont la syntaxe ressemble un peu au C++ ou au Java qui sont d’autres langages de programmation très populaires. Le C# est le langage phare de Microsoft. Il fait partie d’un ensemble plus important. Il est en fait une brique de ce qu’on appelle le « Framework .NET ».
Gardons encore un peu de suspens sur ce qu'est le framework .NET, nous découvrirons ce que c'est un peu plus loin dans le tutoriel.

Une application informatique : qu'est-ce que c'est ?

Comme vous le savez, votre ordinateur exécute des applications informatiques pour effectuer des tâches. Ce sont des logiciels comme :

• Un traitement de texte

• Un navigateur internet

• Un jeu vidéo

• ...

Votre ordinateur ne peut exécuter ces applications informatiques que si elles sont écrites dans le seul langage qu'il comprend, le binaire.
Techniquement, le binaire est représenté par une suite de 0 et de 1.

Il n'est bien sûr pas raisonnablement possible de réaliser une grosse application en binaire, c'est pour ça qu'il existe des langages de programmation qui permettent de simplifier l'écriture d'une application informatique.

Comment créer des programmes "simplement" ?

Je vais vous expliquer rapidement le principe de fonctionnement des langages "traditionnels" comme le C et le C++, puis je vous présenterai le fonctionnement du C#. Comme le C# est plus récent, il a été possible d'améliorer son fonctionnement par rapport au C et au C++ comme nous allons le voir.

Langages traditionnels : la compilation

Avec des langages traditionnels comme le C et le C++, on écrit des instructions simplifiées, lisibles par un humain comme :

printf("Bonjour");

Ce n'est pas vraiment du français, mais c'est quand même beaucoup plus simple que le binaire et on comprend globalement avec cet exemple que l'on va afficher le mot Bonjour.

Bien entendu, l'ordinateur ne comprend pas ces instructions. Lui, il veut du binaire, du vrai. :pirate:
Pour obtenir du binaire à partir d'un code écrit en C ou C++, on doit effectuer ce qu'on appelle une compilation. Le compilateur est un programme qui traduit le code source en binaire exécutable :

Cette méthode est efficace et a fait ses preuves. De nombreuses personnes développent toujours en C et C++ aujourd'hui. Néanmoins, ces langages ont aussi un certain nombre de défauts dus à leur ancienneté. Par exemple, un programme compilé (binaire) ne fonctionne que sur la plateforme pour laquelle il a été compilé. Cela veut dire que si vous compilez sous Windows, vous obtenez un programme qui fonctionne sous Windows uniquement (et sur un type de processeur particulier). Impossible de le faire tourner sous Mac OS X ou Linux simplement, à moins de le recompiler sous ces systèmes d'exploitation (et d'effectuer au passage quelques modifications).

Les programmes binaires ont ce défaut : ils ne fonctionnent que pour un type de machine. Pour les développeurs qui écrivent le code, c'est assez fastidieux à gérer.

Langages récents : le code managé

Les langages récents, comme le C# et le Java, résolvent ce problème de compatibilité tout en ajoutant de nombreuses fonctionnalités appréciables au langage, ce qui permet de réaliser des programmes beaucoup plus efficacement.

La compilation en C# ne donne pas un programme binaire, contrairement au C et au C++. Le code C# est en fait transformé dans un langage intermédiaire (appelé CIL ou MSIL) que l'on peut ensuite distribuer à tout le monde. Ce code, bien sûr, n'est pas exécutable lui-même, car l'ordinateur ne comprend que le binaire.

Regardez bien ce schéma pour comprendre comment cela fonctionne :

Le code en langage intermédiaire (CIL) correspond au programme que vous allez distribuer. Sous Windows, il prend l'apparence d'un .exe comme les programmes habituels, mais il ne contient en revanche pas de binaire.

Lorsqu'on exécute le programme CIL, celui-ci est lu par un autre programme (une machine à analyser les programmes, appelée CLR) qui le compile cette fois en vrai programme binaire. Cette fois, le programme peut s'exécuter, ouf !

Cela offre beaucoup de souplesse au développeur. Le code en langage intermédiaire (CIL) peut être distribué à tout le monde. Il suffit d'avoir installé la machine CLR sur son ordinateur, qui peut alors lire les programmes en C# et les compiler "à la volée" en binaire. Avantage : le programme est toujours adapté à l'ordinateur sur lequel il tourne.

Cette complexité ralentit légèrement la vitesse d'exécution des programmes (par rapport au C ou au C++), mais la différence est aujourd'hui vraiment négligeable par rapport aux gains que cela apporte.

Donc, en théorie, il est possible d'utiliser n'importe quelle application compilée en langage intermédiaire à partir du moment où il y a une implémentation du CLR disponible.
En réalité, il n'y a que sous Windows qu'il existe une implémentation complète du CLR. Il existe cependant une implémentation partielle sous Linux : Mono. Cela veut dire que si votre programme utilise des fonctionnalités qui ne sont pas couvertes par Mono, il ne fonctionnera pas.

J'ai dit juste au dessus que le C# était compilé en langage intermédiaire et qu'on le retrouve sous la forme d'un .exe comme les programmes habituels.

Par contre, c'est un peu incomplet.

Il est possible de créer des programmes (.exe) qui pourront directement être exécuté par le CLR, mais il est également possible de créer des bibliothèques sous la forme d'un fichier possédant l'extension « .dll ».

On appelle ces deux formes de programmes des assemblages, mais on utilise globalement toujours le mot anglais « assembly ».

• Les fichiers .exe sont des assemblys de processus

• Les fichiers .dll sont des assemblys de bibliothèques

Concrètement, cela signifie que le fichier .exe servira à lancer une application et qu'une dll pourra être partagée entre plusieurs applications .exe afin de réutiliser du code déjà écrit.

Nous verrons un peu plus loin comment ceci est possible.

J'ai commencé à vous parler du C# qui était une brique du framework .NET. Il est temps d'en savoir un peu plus sur ce fameux framework.

Commençons par le commencement : comment cela se prononce ?

Citation : Shakespeare

DOTTE NETTE

Citation : maitre Capello

POINT NETTE

Je vous accorde que le nom est bizarre, point trop net pourrions-nous dire …
Surtout que le nom peut être trompeur. Avec l’omniprésence d’internet, son abréviation (net) ou encore des noms de domaines (.net), on pourrait penser que le framework .NET est un truc dédié à internet. Que nenni.

Nous allons donc préciser un peu ce qu’est le framework .NET pour éviter les ambigüités.

Pour simplifier, on peut dire qu’un framework est une espèce de grosse boite à fonctionnalités qui va nous permettre de réaliser des applications informatiques de toutes sortes.

Le framework .NET est un framework créé par Microsoft en 2002, en même temps que le C#, qui est principalement dédié à la réalisation d’applications fonctionnant dans des environnements Microsoft. Nous pourrons par exemple réaliser des programmes qui fonctionnent sous Windows, ou bien des sites web ou encore des applications qui fonctionnent sur téléphone mobile, etc.

Disons que la réalisation d’une application informatique, c’est un peu comme un chantier (je dis pas ça parce que c'est toujours en retard, même si c'est vrai :) ). Il est possible de construire différentes choses, comme une maison, une piscine, une terrasse, etc. Pour réaliser ces constructions, nous allons avoir besoin de matériaux, comme des briques, de la ferraille, etc. Certains matériaux sont communs à toutes les constructions (fer, vis, …) et d’autres sont spécifiques à certains domaines (pour construire une piscine, je vais avoir besoin d’un liner par exemple).

On peut voir le framework .NET comme ces matériaux, c’est un ensemble de composants que l’on devra assembler pour réaliser notre application. Certains sont spécifiques pour la réalisation d’applications web, d’autres pour la réalisation d’applications Windows, etc.

Pour réaliser un chantier, nous allons avoir besoin d’outils pour manipuler les matériaux. Qui envisagerait de visser une vis avec les doigts ou de poser des parpaings sans les coller avec du mortier ? C’est la même chose pour une application informatique, pour assembler notre application, nous allons utiliser un langage de programmation : le C#.

A l’heure où j’écris ces lignes, le C# est en version 4 ainsi que le framework .NET. Ce sont des versions stables et utilisées par beaucoup de personnes. Chaque version intermédiaire a apporté son lot d’évolutions. Le framework .NET et le C# sont en perpétuelle évolution preuve de la dynamique apportée par Microsoft.

C’est tout ce qu’il y a à savoir pour l’instant, nous reviendrons un peu plus en détail sur le framework .NET dans les chapitres suivants. Pour l’heure, il est important de retenir que c’est grâce au langage de programmation C# et grâce aux composants du framework .NET que nous allons pouvoir développer des applications informatiques.

En résumé

• Le C# est un langage de programmation permettant d’utiliser le framework .NET. C’est le langage phare de Microsoft.

• Le framework .NET est une énorme boîte à fonctionnalités permettant la création d’applications.

• Le C# permet de développer des applications de toutes sortes, exécutables par le CLR qui traduit le MSIL en binaire.

• Il est possible de créer des assemblys de deux sortes : des assemblys de processus exécutables par le CLR et des assemblys de bibliothèques.

J’espère vous avoir donné envie de démarrer l’apprentissage du C#, cependant, il nous manque encore quelque chose pour pouvoir sereinement attaquer cet apprentissage.

Bien sûr, vous allez avoir besoin d’un ordinateur, mais a priori, vous l’avez déjà … S’il n’est pas sous Windows, mais sous linux, vous pouvez utiliser Mono qui va permettre d’utiliser le C# sous linux. Cependant, Mono n’est pas aussi complet que le C# et le framework .NET sous Windows, en l’utilisant vous risquez de passer à côté de certaines parties du tutoriel.

Pour reprendre la métaphore du chantier, on peut dire qu’il va également nous manquer un chef de chantier. Il n’est pas forcément nécessaire en théorie, mais dans la pratique il se révèle indispensable pour mener à bien son chantier.

Ce chef de chantier c’est en fait l’outil de développement. Il va nous fournir les outils pour orchestrer nos développements.

C’est entre autres :

• Un puissant éditeur

• Un compilateur

• Un environnement d’exécution

L’éditeur de texte va nous servir à créer des fichiers contenant des instructions en langage C#.
Le compilateur va servir à transformer ces fichiers en une suite d'instructions compréhensibles par l'ordinateur, comme nous l'avons déjà vu.
Le moteur d’exécution va permettre de faire les actions informatiques correspondantes (afficher une phrase, réagir au clic de la souris, etc.), c'est le CLR dont on a déjà parlé.

Enfin, nous aurons besoin d’une base de données. Nous y reviendrons plus en détail ultérieurement, mais la base de données est un endroit où seront stockées les données de notre application. C’est un élément indispensable à mesure que l’application grandit.

Nous avons donc besoin de notre chef de chantier, l’outil de développement. C’est un logiciel qui va nous permettre de créer des applications et qui va nous fournir les outils pour orchestrer nos développements. La gamme de Microsoft est riche en outils professionnels de qualité pour le développement, notamment grâce à Visual Studio.

Nous aurons recours au terme IDE régulièrement.

Pour apprendre et commencer à découvrir l'environnement de développement, Microsoft propose gratuitement Visual Studio dans sa version express. C’est une version allégée de l’environnement de développement qui permet de faire plein de choses, mais avec des outils en moins par rapport aux versions payantes. Rassurez-vous, ces versions gratuites sont très fournies et permettent de faire tout ce dont on a besoin pour apprendre le C# et suivre ce tutoriel.

Pour réaliser des applications d'envergure, il pourra cependant être judicieux d'investir dans l'outil complet et ainsi bénéficier de fonctionnalités complémentaires qui permettent d'améliorer, de faciliter et d'industrialiser les développements.

Pour développer en C# gratuitement et créer des applications Windows, nous allons avoir besoin de Microsoft Visual C# 2010 Express que vous pouvez télécharger en vous rendant sur cette page.

Pour résumer :

• Visual Studio est la version payante de l'outil de développement.

• Microsoft Visual C# 2010 Express est une version allégée et gratuite de Visual Studio, dédiée au développement en C#. Exactement ce qu'il nous faut :)

Cliquez sur Visual C# 2010 Express et choisissez la langue qui vous convient. Puis cliquez sur Téléchargez.

Une fois l’exécutable téléchargé, il ne reste plus qu’à le lancer et l’installation démarre :

Cliquez sur Suivant pour démarrer l’installation :

Vous devez à présent lire la licence d'utilisation du logiciel et l'accepter pour pouvoir continuer l'installation :

Une application sans données, c'est plutôt rare. C'est un peu comme un site d'e-commerce sans produits, un traitement de texte sans fichiers ou le site du zéro sans tutoriel. On risque de vite s'ennuyer :) .

Heureusement, le programme d’installation nous propose d’installer « Microsoft SQL Server 2008 express Service Pack 1 ».

Microsoft propose en version gratuite un serveur de base de données allégé. Il va nous permettre de créer facilement une base de données et de l’utiliser depuis nos applications en C#.

Nous avons également évoqué dans l'introduction qu'il était possible de réaliser des applications qui ressemblent à des applications Windows mais dans un navigateur, que nous avons appelé « clients riches ». Silverlight va justement permettre de créer ce genre d'application.

Cochez donc tout pour installer Silverlight et Sql Server et cliquez sur suivant :

Cliquez sur Installer en changeant éventuellement le dossier d'installation :

L'installation démarre (vous devez être connecté à Internet) :

Une fois l'installation terminée cliquez sur Quitter.

A l’heure où j’écris ces lignes, il existe un service pack pour visual studio, le service pack 1. C’est un ensemble de corrections qui permettent d’améliorer la stabilité du logiciel.
Je vous invite à télécharger et installer ce service pack.

Vous voilà avec votre copie de Visual C# express qui va vous permettre de créer des programmes en C# gratuitement et facilement. L'installation de l'outil de développement est terminée.

En résumé, nous avons installé un outil de développement, Visual C# 2010 dans sa version express et une base de données, SQL Server express 2008.
Nous avons tous les outils nécessaires et nous allons pouvoir démarrer (enfin !) l'apprentissage et la pratique du C#.

Nous allons vérifier que l'installation de Visual C# express a bien fonctionné. Et pour ce faire, nous allons le démarrer et commencer à prendre en main ce formidable outil de développement.

Il vous semblera surement très complexe au début mais vous allez voir, si vous suivez ce tutoriel pas à pas, vous allez apprendre les fonctionnalités indispensables. Elles seront illustrées par des copies d'écrans vous permettant de plus facilement vous y retrouver. A force d’utiliser Visual C# express, vous verrez que vous vous sentirez de plus en plus à l’aise et peut-être oserez-vous aller fouiller dans les menus ? :D

Commencez par démarrer Visual C# 2010 Express. Le logiciel s’ouvre sur la page de démarrage de Visual C# 2010 Express :

Les deux zones entourées de rouge permettent respectivement de créer un nouveau projet et d’accéder aux anciens projets déjà créés. Dans ce deuxième cas, comme je viens d’installer le logiciel, la liste est vide.

Commençons par créer un nouveau projet en cliquant dans la zone rouge. Cette commande est également accessible via le menu Fichier > Nouveau > Projet

Un projet va contenir les éléments de ce que l’on souhaite réaliser. Cela peut être par exemple une application web, une application Windows, etc …

Le projet est aussi un container de fichiers et notamment dans notre cas de fichiers en langage C# qui vont permettre de construire ce que l’on souhaite réaliser. Le projet est en fait représenté par un fichier dont l’extension est .csproj. Son contenu décrit les paramètres de configuration correspondant à ce que l’on souhaite réaliser et les fichiers qui composent le projet.

Créons donc un nouveau projet. La fenêtre de création de nouveau projet s’ouvre et nous avons plusieurs possibilités de choix. Nous allons dans un premier temps aller dans Visual C# pour choisir de créer une Application console.

Ce que nous faisons ici, c’est utiliser ce qu’on appelle un « modèle » (plus couramment appelé par son équivalent anglais : « template ») de création de projet.

Si vous naviguez à l’intérieur des différents modèles, vous pourrez constater que Visual C# nous propose des modèles de projets plus ou moins compliqués. Ces modèles sont très utiles pour démarrer un projet car toute la configuration du projet est déjà faite. Le nombre de modèles peut être différent en fonction de votre version de Visual Studio ou du nombre de versions express installées.

L’application Console est la forme de projet pouvant produire une application exécutable la plus simple. Elle permet de réaliser un programme qui va s’exécuter dans la console noire qui ressemble à une fenêtre ms-dos, pour les dinosaures comme moi qui ont connu cette époque … A noter que les projets de type « Bibliothèque de classes » permettent de générer des assemblys de bibliothèques (.dll).

Dans cette console, nous allons pouvoir notamment afficher du texte simple.
Ce type de projet est parfait pour démarrer l’apprentissage du C# car il n’y a besoin que de savoir comment afficher du texte pour commencer alors que pour réaliser une application graphique par exemple, il y a beaucoup d’autres choses à savoir.

En bas de la fenêtre de création de projet, nous avons la possibilité de choisir un nom pour le projet, ici ConsoleApplication1. Changeons le nom de notre application, par exemple "MaPremiereApplication", dans la zone correspondante.

Cliquons sur OK pour valider la création de notre projet.

Visual C# Express crée alors pour nous les fichiers composant une application console vide, qui utilise le C# comme langage et que nous avons nommé MaPremiereApplication.

Avant toute chose, nous allons enregistrer le projet. Allons dans le menu Fichier > Enregistrer (ou utiliser le raccourci bien connu ctrl+s) :

Visual C# Express nous ouvre la fenêtre d’enregistrement de projet :

Nous pouvons donner un nom, préciser un emplacement où nous souhaitons que les fichiers soient enregistrés et un nom de solution. Une case à cocher pré-cochée nous propose de créer un répertoire pour la solution. C’est ce que nous allons faire et cliquons sur Enregistrer.

Allons dans l’emplacement renseigné (ici c:\users ico\documents\visual studio 2010\Projects), nous pouvons constater que Visual C# Express a créé un répertoire MaPremiereApplication, c’est le fameux répertoire pour la solution qu’il nous a proposé de créer.

Dans ce répertoire, nous remarquons notamment un fichier MaPremiereApplication.sln.

C’est ce qu'on appelle le fichier de solution ; il s’agit juste d’un container de projets qui va nous permettre de visualiser nos projets dans visual C# express.

En l’occurrence, pour l’instant, nous avons un seul projet dans la solution: l’application MaPremiereApplication, que nous retrouvons dans le sous répertoire MaPremiereApplication et qui contient notamment le fichier de projet : MaPremiereApplication.csproj.

Il y a encore un fichier digne d’intérêt (pour l’instant) dans ce répertoire, il s’agit du fichier Program.cs. Les fichiers dont l’extension est .cs contiennent du code C#, c’est dans ce fichier que nous allons commencer à taper nos premières lignes de code …

Si nous retournons dans l’interface de Visual C# express, nous pouvons retrouver quelque chose comme ça :

La zone verte numéro 1 contient les différents fichiers ouverts sous la forme d’un onglet. On voit que par défaut, Visual C# nous a créé et ouvert le fichier Program.cs.

Dans la zone rouge numéro 2, c’est l’éditeur de code. Il affiche le contenu du fichier ouvert. Nous voyons des mots que nous ne comprenons pas encore. C’est du code qui a été automatiquement généré par Visual C#. Nous pouvons observer que les mots sont de différentes couleurs. En effet, l’éditeur Visual C# express possède ce qu’on appelle une coloration syntaxique, c'est-à-dire que certains mots clés sont colorés d’une couleur différente en fonction de leur signification ou de leur contexte afin de nous permettre de nous y retrouver plus facilement.

La zone numéro 3 en violet est l’explorateur de solutions, c’est ici que l’on voit le contenu de la solution sur laquelle nous travaillons en ce moment. En l’occurrence, il s’agit de la solution « MaPremiereApplication » qui contient un unique projet « MaPremiereApplication ». Ce projet contient plusieurs sous éléments :

• Properties : contient des propriétés de l’application, on ne s’en occupe pas pour l’instant

• Références : contient les références de l’application, on ne s’en occupe pas pour l’instant

• Program.cs est le fichier qui a été généré par Visual C# et qui contient le code C#. Il nous intéresse fortement !!

La zone 4 en brun est la zone contenant les propriétés de ce sur quoi nous travaillons en ce moment. Ici, nous avons le curseur positionné sur le projet, il n’y a pas beaucoup d’informations excepté le nom du fichier de projet. Nous aurons l’occasion de revenir sur cette fenêtre plus tard.

La zone 5 en jaune n’est pas affichée au premier lancement, elle contient la liste des erreurs, des avertissements et des messages de notre application. Nous verrons comment l’afficher un peu plus bas.

La zone 6 en noir est la barre d'outils, elle possède plusieurs boutons que nous pourrons utiliser, notamment pour exécuter notre application.

Allons donc dans la zone 2 réservée à l’édition de notre fichier Program.cs qui est le fichier contenant le code C# de notre application.

Les mots présents dans cette zone sont ce qu’on appelle des instructions de langage. Elles vont nous permettre d’écrire notre programme.
Nous reviendrons plus loin sur ce que veulent dire les instructions qui ont été générées par Visual C#, pour l’instant, rajoutons simplement l’instruction suivante après l'accolade ouvrante :

Console.WriteLine("Hello World !!");

de manière à avoir :

static void Main(string[] args)
{
    Console.WriteLine("Hello World !!");
}

Nous venons d’écrire une instruction qui va afficher la phrase “Hello World !!”, pour l’instant vous avez juste besoin de savoir ça. Nous étudierons plus en détail ultérieurement à quoi cela correspond exactement.

Comme je vous comprends.

La première chose à faire est de transformer le langage C# que nous venons d’écrire en programme exécutable. Cette phase s’appelle la « génération de la solution » sous Visual C#. On l’appelle souvent la « compilation » ou en anglais le « build ».

Allez dans le menu Déboguer et cliquez sur « Générer la solution » :

Visual C# lance alors la génération de la solution et on voit dans la barre des taches en bas à gauche qu’il travaille jusqu’à nous indiquer que la génération a réussi :

Si nous allons dans le répertoire contenant la solution, nous pouvons voir dans le répertoire MaPremiereApplication\MaPremiereApplication\bin\Release qu’il y a deux fichiers :

• MaPremiereApplication.exe

• MaPremiereApplication.pdb

Le premier est le fichier exécutable, possédant l’extension .exe, qui est le résultat du processus de génération. Il s’agit bien de notre application.

Le second est un fichier particulier qu’il n’est pas utile de connaitre pour l’instant, nous allons l’ignorer.

Exécutons notre application en lançant le fichier exécutable depuis l’explorateur de fichiers. Déception, nous voyons à peine un truc noirâtre qui s’affiche et qui se referme immédiatement. Que s’est-il passé ?
En fait, l’application s’est lancée, a affiché notre message et s’est terminée immédiatement. Et tout ça un brin trop rapidement … ça ne va pas être pratique tout ça.
Heureusement, Visual C# express arrive à la rescousse. Retournons dans notre IDE préféré. Nous allons ajouter un bouton dans la barre d’outils. J’avoue ne pas comprendre pourquoi ce bouton est manquant dans l’installation par défaut. Nous allons remédier à ce problème en cliquant sur la petite flèche qui est à côté de la barre d’outils tout à droite et qui nous ouvre le menu déroulant permettant d’ajouter ou supprimer des boutons et cliquez sur « Personnaliser » :

Cliquez sur « Ajouter une commande » :

Allez dans la catégorie « déboguer » et choisissez « Exécuter sans débogage » puis cliquez sur « OK » :

Enfin, fermez la fenêtre. Vous avez désormais un nouveau bouton dans la barre d’outils :

Si vous avez eu la flemme d’ajouter le bouton précédemment, vous pouvez utiliser le raccourci ctrl+F5 ou bien cliquer sur ce nouveau bouton pour exécuter l’application depuis Visual c#. La console s’ouvre nous délivrant le message tant attendu :

Le message est désormais visible car Visual C# nous demande d’appuyer sur une touche pour que l’application se termine, ce qui nous laisse donc le temps d’apprécier l’exécution de notre superbe programme.

Wahouu, ça y est, notre première application en C# !!! :)

Je suis fier de nous, mais nous n’allons pas en rester là, nous sommes désormais fin parés pour apprendre le C#.

En résumé

• Visual C# Express est l’outil de développement gratuit de Microsoft permettant de démarrer avec le C#.

• Visual Studio est l’outil de développement payant de Microsoft permettant d’être efficace dans le développement d’applications .NET.

• Microsoft SQL Server Express est le moteur de base de données utilisable facilement avec Visual C# Express.

• L’environnement de développement nous permet de créer du code C# qui sera contenu dans des projets, qui peuvent être réunis dans une solution.

Les lignes de code écrites avec le langage de développement C# doivent s’écrire dans des fichiers dont l’extension est .cs. Nous avons vu dans le chapitre précédent que nous avons écrit dans le fichier Program.cs qui est le fichier qui a été généré par Visual C# lors de la création du projet. Nous y avons notamment rajouté une instruction permettant d’afficher du texte.
Les lignes de code C# se lisent et s’écrivent de haut en bas et de gauche à droite, comme un livre normal.
Aussi, une instruction écrite avant une autre sera en général exécutée avant celle-ci.

Par exemple, si à la fin de mon instruction, je retire le point-virgule ou si j’orthographie mal le mot WriteLine, j’aurai :

Visual C# Express me signale qu’il y a un problème en mettant en valeur un manque au niveau de la fin de l’instruction et il me souligne également le mot « WritLine ».
Dans la fenêtre du bas, il m’indique qu’il a deux erreurs et me donne des précisions sur celles-ci avec éventuellement des pistes pour résoudre ces erreurs.

Si je tente de lancer mon application (raccourci ctrl+F5), Visual C# Express va tenter de compiler et d’exécuter l’application. Ceci n’étant pas possible, il m’affichera un message indiquant qu’il y a des erreurs.

Ce sont des erreurs de compilation qu’il va falloir résoudre si l’on souhaite que l’application console puisse s’exécuter.

Nous allons voir dans les chapitres suivant comment écrire correctement des instructions en C#. Mais il est important de noter à l’heure actuelle que le C# est sensible à la casse, ce qui veut dire que les majuscules comptent !
Ainsi le mot « WriteLine » et le mot « WriTEline » sont deux mots bien distincts et peuvent potentiellement représenter deux instructions différentes. Ici, le deuxième mot est incorrect car il n’existe pas.

En général, une instruction en code C# s’écrit sur une ligne et se termine par un point-virgule.
Ainsi, l’instruction que nous avons vue plus haut :

Console.WriteLine("Hello World !!");

se termine au niveau du point-virgule.
Il aurait été possible de remplacer le code écrit :

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Hello World !!");
    }
}

par :

class Program {static void Main(string[] args) {Console.WriteLine("Hello World !!");}}

ou encore :

class Program
{
static void Main(string[] args)
    {
        Console
                
                
.WriteLine("Hello World !!"
                
            );
    }
}

En général, pour que le code soit le plus lisible possible, on écrit une instruction par ligne et on indente le code de façon à ce que les blocs soient lisibles.

Visual C# express nous aide pour faire correctement cette indentation quand nous écrivons du code. Il peut également remettre toute la page en forme avec la combinaison de touche : ctrl+k+ctrl+d.

Décortiquons à présent cette ligne de code :

Console.WriteLine("Hello World !!");

Pour simplifier, nous dirons que nous appelons la méthode WriteLine qui permet d’écrire une chaine de caractères sur la Console.

L’instruction "Hello World !!" représente une chaine de caractères et est passée en paramètre de la méthode Console.WriteLine à l’aide des parenthèses. La chaine de caractères est délimitée par les guillemets. Enfin, le point-virgule permet d’indiquer que l’instruction est terminée et qu’on peut enchainer sur la suivante.

Certains points ne sont peut-être pas encore tout à fait clairs, comme ce qu’est vraiment une méthode, ou comment utiliser des chaines de caractères, mais ne vous inquiétez pas, nous allons y revenir plus en détail dans les chapitres suivants et découvrir au fur et à mesure les arcanes du C#.

Pour faciliter la compréhension du code ou pour se rappeler un point précis, il est possible de mettre des commentaires dans son code. Les commentaires sont ignorés par le compilateur et n’ont qu’une valeur informative pour le développeur.
Dans un fichier de code C# (.cs), on peut écrire des commentaires de 2 façons différentes :

• Soit en commençant son commentaire par /* et en le terminant par */ ce qui permet d’écrire un commentaire sur plusieurs lignes.

• Soit en utilisant // et tout ce qui se trouve après sur la même ligne est alors un commentaire.

Visual C# express colore les commentaires en vert pour faciliter leurs identifications.

/* permet d'afficher du texte
    sur la console */
Console.WriteLine("Hello World !!"); // ne pas oublier le point virgule

Visual C# express est un formidable outil qui nous facilite à tout moment la tâche, notamment grâce à la complétion automatique.
La complétion automatique est le fait de proposer de compléter automatiquement ce que nous sommes en train d’écrire en se basant sur ce que nous avons le droit de faire.
Par exemple, si vous avez cherché à écrire l’instruction :

Console.WriteLine("Hello World !!");

vous avez pu constater que lors de l’appui sur la touche C, Visual C# express nous affiche une fenêtre avec tout ce qui commence par « C » :

Au fur et à mesure de la saisie, il affine les propositions pour se positionner sur la plus pertinente. Il est possible de valider la proposition en appuyant sur la touche Entrée. Non seulement cela nous économise des appuis de touches, paresseux comme nous sommes, mais cela nous permet également de vérifier la syntaxe de ce que nous écrivons et d’obtenir également une mini-aide sur ce que nous essayons d’utiliser.

Ainsi, finies les fautes de frappe qui résultent en une erreur de compilation ou les listes de mots clés dont il faut absolument retenir l’écriture.

De la même façon, une fois que vous avez fini de saisir « Console » vous allez saisir le point « . » et Visual C# express va nous proposer toute une série d’instruction en rapport avec le début de l’instruction :

Nous pourrons ainsi facilement finir de saisir « WriteLine » et ceci sans erreur d’écriture, ni problème de majuscule.

En résumé

• Le code C# est composé d’une suite d’instructions qui se terminent par un point virgule.

• La syntaxe d’un code C# doit être correcte sinon nous aurons des erreurs de compilation.

• Il est possible de commenter son code grâce aux caractères « // », « /* » et « */ ».

• Visual C# Express dispose d’un outil puissant qui permet d’aider à compléter ses instructions : la complétion automatique.

Comme tous les langages de programmations, le C# va pouvoir conserver des données grâce à des variables. Ce sont en fait des blocs de mémoire qui vont contenir des nombres, des chaines de caractères, des dates ou plein d’autres choses.
Les variables vont nous permettre d’effectuer des calculs mathématiques, d’enregistrer l’âge du visiteur, de comparer des valeurs, etc.
On peut les comparer à des petits classeurs possédant une étiquette. On va pouvoir mettre des choses dans ces classeurs, par exemple, je mets 30 dans le classeur étiqueté « âge de Nicolas » et 20 dans le classeur « âge de Jérémie ». Si je veux connaitre l’âge de Nicolas, je n’ai qu’à regarder dans ce classeur pour obtenir 30. Je peux également remplacer ce qu’il y a dans mon classeur par autre chose, par exemple changer 30 en 25. Je ne peux par contre pas mettre deux choses dans mon classeur, il n’a qu’un seul emplacement.

Une variable est représentée par son nom, caractérisée par son type et contient une valeur.

Par exemple, l’âge d’une personne pourrait être stockée sous la forme d’un entier et accessible par la variable « age », ce qui s’écrit en C# :

int age;

On appelle ceci « la déclaration de la variable age ».

Le mot clé int permet d’indiquer au compilateur que la variable « age » est un entier numérique. int correspond au début d’ « integer » qui veut dire « entier » en anglais.

Ici, la variable « age » n’a pas été initialisée, elle ne pourra pas être utilisée car le compilateur ne sait pas quelle valeur il y a dans la variable age.

Pour l’initialiser (on parle également « d’affecter une valeur ») on utilisera l’opérateur égal (« = »).

int age;
age = 30;

Notre variable « age » possède désormais l’entier numérique « 30 » comme valeur.

L’initialisation d’une variable peut également se faire au même moment que sa déclaration. Ainsi, on pourra remplacer le code précédent par :

int age = 30;

Pour déclarer une variable en C#, on commence toujours par indiquer son type (int, ici un entier) et son nom (age). Il faudra impérativement affecter une valeur à cette variable avec l’opérateur « = », soit sur la même instruction que la déclaration, soit un peu plus loin dans le code, mais dans tous les cas, avant l’utilisation de cette variable.

Nous pouvons à tout moment demander la valeur contenue dans la variable age, par exemple :

int age = 30;
Console.WriteLine(age); // affiche 30

Il est possible de modifier la valeur de la variable à n’importe quel moment grâce à l’emploi de l’opérateur = que nous avons aperçu :

int age = 30;
Console.WriteLine(age); // affiche 30
age = 20;
Console.WriteLine(age); // affiche 20

Vous pouvez nommer vos variables à peu près n’importe comment, à quelques détails près. Les noms de variables ne peuvent pas avoir le même nom qu’un type. Il sera alors impossible d’appeler une variable int. Il est également impossible d’utiliser des caractères spéciaux, comme des espaces ou des caractères de ponctuation. De même, on ne pourra pas nommer une variable en commençant par des chiffres.

En général, une variable commence par une minuscule et si son nom représente plusieurs mots, on démarrera un nouveau mot par une majuscule. Par exemple :

int ageDuVisiteur;

C’est ce qu’on appelle le camel case.

Attention, suivant le principe de sensibilité à la casse, il faut faire attention car ageduvisiteur et ageDuVisiteur seront deux variables différentes :

int ageduvisiteur = 30;
int ageDuVisiteur = 20;
Console.WriteLine(ageduvisiteur); // affiche 30
Console.WriteLine(ageDuVisiteur); // affiche 20

Nous avons vu juste au-dessus que la variable « age » pouvait être un entier numérique grâce au mot clé int. Le framework .NET dispose de beaucoup de types permettant de représenter beaucoup de choses différentes.

Par exemple, nous pouvons stocker une chaine de caractères grâce au type string.

string prenom = "nicolas";

ou encore un décimal avec :

decimal soldeCompteBancaire = 100;

ou encore un boolean (qui représente une valeur vraie ou fausse) avec

bool estVrai = true;

On ne peut par exemple pas stocker le prénom "Nicolas" dans un entier.

Les principaux types de base du framework .NET sont :

Vous verrez plus loin qu'il existe encore d'autres types dans le framework .NET et qu'on peut également construire les siens.

Il est possible d’effectuer des opérations sur les variables et entre les variables. Nous avons déjà vu comment affecter une valeur à une variable grâce à l’opérateur =.

int age = 30;
string prenom = "nicolas";

En plus de la simple affectation, nous pouvons également faire des opérations, par exemple :

int resultat = 2 * 3;

ou encore

int age1 = 20;
int age2 = 30;
int moyenne = (age1 + age2) / 2;

Les opérateurs « + », « * », « / » ou encore « - » (que nous n’avons pas encore utilisé) servent bien évidemment à faire les opérations mathématiques qui leur correspondent, à savoir respectivement l’addition, la multiplication, la division et la soustraction.
Vous aurez donc surement deviné que la variable « resultat » contient 6 et que la moyenne vaut 25.

Il est à noter que les variables contiennent une valeur qui ne peut évoluer qu’en affectant une nouvelle valeur à cette variable.
Ainsi, si j’ai le code suivant :

int age1 = 20;
int age2 = 30;
int moyenne = (age1 + age2) / 2;
age2 = 40;

la variable moyenne vaudra toujours 25 même si j’ai changé la valeur de la variable « age2 ». En effet, lors du calcul de la moyenne, j’ai rangé dans mon classeur la valeur 25 grâce à l’opérateur d’affectation « = » et j’ai refermé mon classeur. Le fait de changer la valeur du classeur « age2 » n’influence en rien le classeur « moyenne » dans la mesure où il est fermé. Pour le modifier, il faudrait ré-exécuter l’opération d’affectation de la variable moyenne, en écrivant à nouveau l’instruction de calcul, c’est-à-dire :

int age1 = 20;
int age2 = 30;
int moyenne = (age1 + age2) / 2;
age2 = 40;
moyenne = (age1 + age2) / 2;

L’opérateur « + » peut également servir à concaténer des chaines de caractères, par exemple :

string codePostal = "33000";
string ville = "Bordeaux";
string adresse = codePostal + " " + ville;
Console.WriteLine(adresse); // affiche : 33000 Bordeaux

D’autres opérateurs particuliers existent que nous ne trouvons pas dans les cours de mathématiques. Par exemple, l’opérateur ++ qui permet de réaliser une incrémentation de 1, ou l’opérateur -- qui permet de faire une décrémentation de 1.
De même, les opérateurs que nous avons déjà vus peuvent se cumuler à l’opérateur = pour simplifier une opération qui prend une variable comme opérande et cette même variable comme résultat.
Par exemple :

int age = 20;
age = age + 10; // age contient 30 (addition)
age++; // age contient 31 (incrémentation de 1)
age--; // age contient 30 (décrémentation de 1)
age += 10; // équivalent à age = age + 10 (age contient 40)
age /= 2; // équivalent à age = age / 2 => (age contient 20)

Comme nous avons pu le voir dans nos cours de mathématiques, il est possible de grouper des opérations avec des parenthèses pour agir sur leurs priorités.

Ainsi, l’instruction précédemment vue :

int moyenne = (age1 + age2) / 2;

effectue bien la somme des deux âges avant de les diviser par 2, car les parenthèses sont prioritaires.

Cependant, l’instruction suivante :

int moyenne = age1 + age2 / 2;

aurait commencé par diviser l’age2 par 2 et aurait ajouté l’age1, ce qui n’aurait plus rien à voir avec une moyenne. En effet, la division est prioritaire par rapport à l’addition.

Prenons cet exemple :

int moyenne = 5 / 2;
Console.WriteLine(moyenne);

Si nous l'exécutons, nous voyons que moyenne vaut 2.

Oui et non.
Si nous divisions 5 par 2, nous obtenons bien 2.5.
Par contre, ici nous divisons l'entier 5 par l'entier 2 et nous stockons le résultat dans l'entier moyenne. Le C# réalise en fait une division entière, c'est-à-dire qu'il prend la partie entière de 2.5, c'est-à-dire 2.

De plus, l'entier moyenne est incapable de stocker une valeur contenant des chiffres après la virgule. Il ne prendrait que la partie entière.

Pour avoir 2.5, il faudrait utiliser le code suivant :

double moyenne = 5.0 / 2.0;
Console.WriteLine(moyenne);

Ici, nous divisons deux « doubles » entre eux et nous stockons le résultat dans un « double ». (Rappelez-vous, le type de données « double » permet de stocker des nombres à virgule.)

En ce qui concerne l’affectation de chaines de caractères, vous risquez d’avoir des surprises si vous tentez de mettre des caractères spéciaux dans des variables de type string.
En effet, une chaine de caractères étant délimitée par des guillemets " ", comment faire pour que notre chaine de caractères puisse contenir des guillemets ?

C’est là qu’intervient le caractère spécial \ qui sera à mettre juste devant le guillemet, par exemple le code suivant :

string phrase = "Mon prénom est \"Nicolas\"";
Console.WriteLine(phrase);

affichera :

Si vous avez testé par vous-même l’instruction Console.WriteLine et enchainé plusieurs instructions qui écrivent des lignes, vous avez pu remarquer que nous passions à la ligne à chaque fois. C’est le rôle de l’instruction WriteLine qui affiche la chaine de caractères et passe à la ligne à la fin de la chaîne de caractères.

Nous pouvons faire la même chose en utilisant le caractère spécial « ». Il permet de passer à la ligne à chaque fois qu’il est rencontré.
Ainsi, le code suivant :

string phrase = "Mon prénom est \"Nicolas\"";
Console.WriteLine(phrase);
Console.WriteLine("Passe\nà\nla\nligne\n\n\n");

affichera :

où nous remarquons bien les divers passages à la ligne.
Vous me diriez qu’on pourrait enchaîner les Console.WriteLine et vous auriez raison.

Mais les caractères spéciaux nous permettent de faire d’autres choses comme une tabulation par exemple grâce au caractère spécial « ». Le code suivant :

Console.WriteLine("Choses à faire :");
Console.WriteLine("\t - Arroser les plantes");
Console.WriteLine("\t - Laver la voiture");

permettra d’afficher des tabulations, comme illustré ci-dessous :

Nous avons vu que le caractère \ était un caractère spécial et qu’il permettait de dire au compilateur que nous voulions l’utiliser combiné à la valeur qui le suit, permettant d’ avoir une tabulation ou un retour à la ligne. Comment pourrons-nous avoir une chaine de caractères qui contienne ce fameux caractère ?

Le principe est le même, il suffira de faire suivre ce fameux caractère spécial de lui-même :

string fichier = "c:\\repertoire\\fichier.cs";
Console.WriteLine(fichier);

Ce qui donnera :

Pour ce cas particulier, il est également possible d’utiliser la syntaxe suivante en utilisant le caractère spécial @ devant la chaine de caractères :

string fichier = @"c:\repertoire\fichier.cs"; // contient : c:\repertoire\fichier.cs

Bien sur, nous pouvons stocker des caractères spéciaux dans des variables pour faire par exemple :

string sautDeLigne = "\n";
Console.WriteLine("Passer" + sautDeLigne + "à" +
        sautDeLigne + "la" + sautDeLigne + "ligne");

Ce qui permet d’avoir le code suivant :

Console.WriteLine("Passer" + Environment.NewLine + "à" + 
                  Environment.NewLine + "la" + Environment.NewLine + "ligne");

permettant d’afficher :

En fait, je triche un peu sur les mots. Pour faciliter la compréhension, on peut considérer que Environment.NewLine est une variable, au même titre que la variable « sautDeLigne » que nous avons défini. En réalité, c’est un peu plus complexe qu’une variable. Nous découvrirons plus loin de quoi il s’agit vraiment.

En résumé

• Une variable est une zone mémoire permettant de stocker une valeur d'un type particulier.

• Le C# possède plein de types prédéfinis, comme les entiers (int), les chaînes de caractères (string), etc.

• On utilise l'opérateur = pour affecter une valeur à une variable.

• Il est possible de faire des opérations entre les variables.

Une condition se construit grâce à des opérateurs de comparaison. On dénombre plusieurs opérateurs de comparaisons, les plus courants sont :

Nous allons voir comment les utiliser en combinaison avec les instructions conditionnelles.

L’instruction if permet d’exécuter du code si une condition est vraie (if = si en anglais).
Par exemple :

decimal compteEnBanque = 300;
if (compteEnBanque >= 0)
    Console.WriteLine("Votre compte est créditeur");

Ici, nous avons une variable contenant le solde de notre compte en banque. Si notre solde est supérieur ou égal à 0 alors nous affichons que le compte est créditeur.

Pour afficher que le compte est débiteur, on pourrait tester si la valeur de la variable est inférieure à 0 et afficher que le compte est débiteur :

decimal compteEnBanque = 300;
if (compteEnBanque >= 0)
    Console.WriteLine("Votre compte est créditeur");
if (compteEnBanque < 0)
    Console.WriteLine("Votre compte est débiteur");

Une autre solution est d’utiliser le mot clé else, qui veut dire « sinon » en anglais.

« Si la valeur est vraie, alors on fait quelque chose, sinon, on fait autre chose », ce qui se traduit en C# par :

decimal compteEnBanque = 300;
if (compteEnBanque >= 0)
    Console.WriteLine("Votre compte est créditeur");
else
    Console.WriteLine("Votre compte est débiteur");

Il faut bien se rendre compte que l’instruction if teste si une valeur est vraie (dans l’exemple précédent la comparaison compteEnBanque >= 0).

On a vu rapidement dans les chapitres précédents qu’il existait un type de variable qui permettait de stocker une valeur vraie ou fausse : le type bool, autrement appelé booléen (boolean en anglais).
Ainsi, il sera également possible de tester la valeur d’un booléen. L’exemple précédent peut aussi s’écrire :

decimal compteEnBanque = 300;
bool estCrediteur = (compteEnBanque >= 0);
if (estCrediteur)
    Console.WriteLine("Votre compte est créditeur");
else
    Console.WriteLine("Votre compte est débiteur");

À noter que les parenthèses autour de l’instruction de comparaison sont facultatives, je les ai écrites ici pour clairement identifier que la variable « estCrediteur » va contenir une valeur qui est le résultat de l’opération de comparaison « compte en banque est supérieur ou égal à 0 », en l’occurrence vrai.

Voici d’autres exemples pour vous permettre d’appréhender plus précisément le fonctionnement du type bool :

int age = 30;
bool estAgeDe30Ans = age == 30;
Console.WriteLine(estAgeDe30Ans); // affiche True
bool estSuperieurA10 = age > 10;
Console.WriteLine(estSuperieurA10); // affiche True
bool estDifferentDe30 = age != 30;
Console.WriteLine(estDifferentDe30); // affiche False

Un type bool peut prendre deux valeurs, vrai ou faux, qui s’écrivent avec les mots clés true et false.

bool estVrai = true;
if (estVrai)
    Console.WriteLine("C'est vrai !");
else
    Console.WriteLine("C'est faux !");

Il est également possible de combiner les tests grâce aux opérateurs de logique conditionnelle, par exemple && qui correspond à l’opérateur ET.

Dans l’exemple qui suit, nous affichons le message de bienvenue uniquement si le login est « Nicolas » ET que le mot de passe est « test ». Si l’un des deux ne correspond pas, nous irons dans l’instruction else.

string login = "Nicolas";
string motDePasse = "test";
if (login == "Nicolas" && motDePasse == "test")
    Console.WriteLine("Bienvenue Nicolas");
else
    Console.WriteLine("Login incorrect");

D’autres opérateurs de logiques existent, nous avons notamment l’opérateur || qui correspond au OU logique :

if (civilite == "Mme" || civilite == "Mlle")
    Console.WriteLine("Vous êtes une femme");
else
    Console.WriteLine("Vous êtes un homme");

L’exemple parle de lui-même ; si la civilité de la personne est Mme ou Mlle, alors nous avons à faire avec une femme.

A noter ici que si la première condition du if est vraie alors la deuxième ne sera pas évaluée. C’est un détail ici, mais cela peut s’avérer important dans certaines situations dont une que nous verrons un peu plus loin.

Un autre opérateur très courant est la négation que l’on utilise avec l’opérateur « ! ». Par exemple :

bool estVrai = true;
if (!estVrai)
    Console.WriteLine("C'est faux !");
else
    Console.WriteLine("C'est vrai !");

Ce test pourrait se lire ainsi : « Si la négation de la variable estVrai est vraie, alors on écrira c’est faux ».
La variable « estVrai » étant égale à true, sa négation vaut false.
Dans cet exemple, le programme nous affichera donc l’instruction correspondant au else, à savoir « C’est vrai ! ».

Rappelez-vous, nous avons dit qu’une instruction se finissait en général par un point-virgule. Comment cela se fait-il alors qu’il n’y ait pas de point-virgule à la fin du if ou du else ?
Et si nous écrivions l’exemple précédent de cette façon ?

bool estVrai = true;
if (!estVrai) Console.WriteLine("C'est faux !");
else Console.WriteLine("C'est vrai !");

Ceci est tout à fait valable et permet de voir où s’arrête vraiment l’instruction grâce au point-virgule. Cependant, nous écrivons en général ces instructions de la première façon afin que celles-ci soient plus lisibles.
Vous aurez l’occasion de rencontrer dans les chapitres suivants d’autres instructions qui ne se terminent pas obligatoirement par un point-virgule.

Remarquons enfin qu'il est possible d’enchaîner les tests de manière à traiter plusieurs conditions en utilisant la combinaison else-if. Cela donne :

if (civilite == "Mme")
    Console.WriteLine("Vous êtes une femme");
else if (civilite == "Mlle")
    Console.WriteLine("Vous êtes une femme non mariée");
else if (civilite == "M.")
    Console.WriteLine("Vous êtes un homme");
else
    Console.WriteLine("Je n'ai pas pu déterminer votre civilité");

L’instruction switch peut être utilisée lorsqu’une variable peut prendre beaucoup de valeurs. Elle permet de simplifier l’écriture.
Ainsi, l’instruction suivante :

string civilite = "M.";
if (civilite == "M.")
    Console.WriteLine("Bonjour monsieur");
if (civilite == "Mme")
    Console.WriteLine("Bonjour madame");
if (civilite == "Mlle")
    Console.WriteLine("Bonjour mademoiselle");

pourra s’écrire :

string civilite = "M.";
switch (civilite)
{
    case "M." :
        Console.WriteLine("Bonjour monsieur");
        break;
    case "Mme":
        Console.WriteLine("Bonjour madame");
        break;
    case "Mlle":
        Console.WriteLine("Bonjour mademoiselle");
        break;
}

Switch commence par évaluer la variable qui lui est passée entre parenthèses. Avec le mot clé case on énumère les différents cas possible pour la variable et on exécute les instructions correspondante jusqu’au mot clé break qui signifie que l’on sort du switch.

Nous pouvons également indiquer une valeur par défaut en utilisant le mot clé default, ainsi dans l’exemple suivant tout ce qui n’est pas « M. » ou « Mme » ou « Mlle » donnera l’affichage d’un « Bonjour inconnu » :

switch (civilite)
{
    case "M." :
        Console.WriteLine("Bonjour monsieur");
        break;
    case "Mme":
        Console.WriteLine("Bonjour madame");
        break;
    case "Mlle":
        Console.WriteLine("Bonjour mademoiselle");
        break;
    default:
        Console.WriteLine("Bonjour inconnu");
        break;
}

Nous pouvons également enchainer plusieurs cas pour qu’ils fassent la même chose, ce qui reproduit le fonctionnement de l’opérateur logique OU (« || »). Par exemple, on pourra remplacer l’exemple suivant :

string mois = "Janvier";
if (mois == "Mars" || mois == "Avril" ||  mois == "Mai")
    Console.WriteLine("C'est le printemps");
if (mois == "Juin" || mois == "Juillet" || mois == "Aout")
    Console.WriteLine("C'est l'été");
if (mois == "Septembre" || mois == "Octobre" || mois == "Novembre")
    Console.WriteLine("C'est l'automne");
if (mois == "Decembre" || mois == "Janvier" || mois == "Février")
    Console.WriteLine("C'est l'hiver");

par :

switch (mois)
{
    case "Mars":
    case "Avril":
    case "Mai":
        Console.WriteLine("C'est le printemps");
        break;
    case "Juin":
    case "Juillet":
    case "Aout":
        Console.WriteLine("C'est l'été");
        break;
    case "Septembre":
    case "Octobre":
    case "Novembre":
        Console.WriteLine("C'est l'automne");
        break;
    case "Décembre":
    case "Janvier":
    case "Février":
        Console.WriteLine("C'est l'hiver");
        break;
}

Qui allège quand même l’écriture et la rend beaucoup plus lisible.

En résumé

• Les instructions conditionnelles permettent d'exécuter des instructions seulement si une condition est vérifiée.

• On utilise en général le résultat d'une comparaison dans une instruction conditionnelle.

• Le C# possède beaucoup d'opérateurs de comparaison, comme l'opérateur d'égalité ==, l'opérateur de supériorité >, d'infériorité <, etc.