Appréciation des lecteurs :
Développement C# (.NET)
Informations sur le tutoriel
Auteurs : JCVasselon, Mangepain, Nisnor, Strimy et Zechiron Difficulté : Plus d'informations
Popularité
Visualisations : 29 960 7 1 12 2762 personnes souhaitent voir ce tutoriel publié en livre ! Vous aussi ?
Publicité
Historique des mises à jour
Rester informé grâce au flux RSSLe 13/03/2011 à 17:53:03
Corrections de fautes
Le 12/03/2011 à 10:05:20
Corrections, ajouts et modifications mineurs
Le 04/03/2011 à 17:09:14
Correction d'une erreur de syntaxe suite au report #4029
Partager
Imprimer Email TwitterFacebook Plus de services
Bienvenue dans ce cours de programmation .NET. Ce cours est destiné à plusieurs types de personnes:
Personnes ayant découvert le C ou le C++ sur le site du zéro et voulant voir autre chose sans être trop dépaysé par la syntaxe du langage. Personnes ayant découvert le VB.net et voulant se mettre au C# et capitalisant leurs acquis sur le framework.
Néophytes en programmation, pour cela, nous commencerons par les points les plus essentiels du C# et du .net. Ce cours est composé des parties suivantes :
Notions fondamentales
Partie 1 : Notions fondamentales
Dans ces premiers chapitres nous reverrons rapidement les bases de la programmation en général avec les types de données, les boucles, les conditions. Nous verrons de même les notions fondamentales de la programmation orienteé objet (dite POO) en C#.Net
1) Le fonctionnement de .NET
Tout d'abord, comment fonctionne un programme? Avantages de .NET par rapport aux autres plateformes
2) Premiers pas avec C#
Quelques outils pour bien développer Qu'est-ce qu'un type primitif? Gérer les entrées/sorties de bases 3) La programmation orientée objet (1/3)
Les nouveaux concepts Création de classes et d'objets
Les classes, champs et méthodes statiques 4) La programmation orientée objet (2/3)
Théorie sur l'encapsulation L'encapsulation en pratique
5) La programmation orientée objet (3/3)
Les objets dans la mémoire Les constructeurs L'héritage
6) Travaux Pratique : le jeux de rôle
Enoncé Une correction 7) Les énumérations et structure
Les énumérations Les structures Exercices d'applications 8) Les opérateurs
Les opérateurs arithmétiques Les opérateurs logiques Les opérateurs bit à bit 9) Un peu d'algorithmique
Les conditions Les boucles
Boucles et conditions : cas pratiques Exercices pratiques
Partie 1 : Notions fondamentales
Dans ces premiers chapitres nous reverrons rapidement les bases de la programmation en général avec les types de données, les boucles, les conditions. Nous verrons de même les notions fondamentales de la programmation orienteé objet (dite POO) en C#.Net
Le fonctionnement de .NET
Bonjour à vous. Ce premier chapitre va vous présenter la structure général de .net, bien que cela puisse vous paraître inutile, vous verrez vite l'importance cruciale de savoir comment tout cela fonctionne.
Tout d'abord, comment fonctionne un programme?
Lorsque l'on écrit un programme, on choisit un langage dans lequel développer. Certes, les choix sont nombreux: C
C++ Java C# Visual Basic
PHP (Oui, on peut faire de vraies applications au-delà d'un site web.) etc
Ces langages se divisent entre deux principales catégories : langages compilés et langages interprétés.
Les langages compilés
Beaucoup de langages sont compilés. C'est-à-dire, qu'après avoir écrit votre code, un programme, le compilateur, le transforme en langage machine que votre processeur comprend. Les langages de bases sont des langages compilés, comme le C ou le C++ expliqués par M@téo. Si une modification doit être apportée dans votre programme, vous devez compiler à nouveau votre code source. Par contre, une fois compilé, ce programme n'aura besoin de rien d'autres pour fonctionner.
Les langages interprétés
Les langages interprétés ne sont pas transformés en langage machine avant d'être exécutés. Généralement, un interpréteur transforme la source en un résultat. Les exemples les plus simples de langages interprétés sont les langages permettant d'afficher une page web, ils sont lu par une programme externe (le navigateur web) qui affichera un résultat. Si une modification est ajoutée à votre code source, il n'y aura pas besoin de compiler une nouvelle fois l'application, par contre ces types de programmes auront besoin d'autres programmes pour être exécutés (ces programmes sont dit "parseurs", ils lisent le code source puis l'exécutent) par exemple le navigateur web. De même, l'exécution peut être plus lente qu'un programme compilé, car le parsage du code demande des ressources processeurs et donc du temps.
Et le C# dans tout ça ?
Il faut tout d'abord savoir que pour développer en .net, nous pouvons faire avec plusieurs langages dont : C#
VB.net
C++ adapté au .net F#
Et bien d'autres
Tous ces langages sont en quelques sortes à mi-chemins entre des langages compilés et interprétés : ils ne sont pas directement compilé en langage machine, mais il ne sont pas non plus interprétés !!
En réalité, ils vont être compilés en un langage intermédiaire (appelé IL pour "Intermediate Language"). Lors de l'exécution ce langage intermédiaire va être compilé en langage machine et exécuté par le CLR (Common Language Runtime), ce "runtime" va en quelque sorte faire l'intermédiaire entre notre code et le système d'exploitation en apportant une importante abstraction vis à vis de fonctions systèmes de bases (entrés/sorties, gestion de la mémoire, etc...).
Avantages de .NET par rapport aux autres plateformes
Mais, c'est vachement compliqué ! Pourquoi ne pas faire simple ?
Cette architecture apporte plusieurs avantages:
le premier est que l'IL va être exécuté plus rapidement qu'un langage interprété puisqu'il aura été au préalable pré-compilé en un langage déjà proche de la machine.
Ensuite, ce CLR (le "Common Language Runtime") permet au développeur de ne pas se préoccuper de certaines choses, surtout concernant la mémoire. Un "garbage collector" (traduire par "ramasse miette" et non "collectionneur de poubelle" ) va s'occuper de libérer les ressources mémoires inutilisées; les fuites de mémoires vont être automatiquement détectées et corrigées.
Peu importe le langage (C#, VB.net, F#, etc...) que l'on utilise, le langage intermédiaire sera exactement le même, c'est à dire que vous pouvez très bien travailler sur un même projet avec plusieurs langages différents, par exemple vous créez la logique et le visuel de votre jeu en C#, puis vous utilisez du F# pour l'intelligence artificielle. Cette "unité" dans ces langages pourtant différent est permise par la CLI (pour "Common Language Infrastructure") qui fournis les spécifications pour qu'un langage puisse être compilé en IL.
Et enfin, peut importe la plateforme Windows que vous avez (XP, Vista, Windows Server, etc..), il vous suffit d'avoir la CLR (en gros d'avoir le framework .net d'installé ) pour que votre programme fonctionne. Une partie du framework fonctionne même sous Unix, une simple copie d'un programme peut suffire pour le faire fonctionner d'un système à l'autre. C'est donc le CLR, qui lui sera compilé en langage machine, qui s'occupera de recompiler à l'exécution l'IL de notre programme
D'accord, je vois que .net c'est bien, mais pourquoi apprendre le C# et pas le VB.net ou même le C++? Eux aussi permettent d'exploiter le framework .net. La réponse est simple, C# a été créé pour .net. C'est le langage qui exploite le mieux le framework. D'autres avantages liés au C# combiné au framework .net sont entre autres (tout ces éléments vont vous paraitre inconnus, mais en lisant ce cours vous allez peu à peu comprendre chacun d'eux) :
Système puissant d'exceptions.
Il n'y a que des références.
Les propriétés évitent de devoir écrire autant d'accesseurs. .net permet de presque tout faire en programmation.
Les événements qui évitent d'alourdir le code avec la déclaration et l'utilisation d'actions. Typage très fort (dans notre cas, c'est un avantage)
Langage tout objet (de même dans notre cas, ceci va apporter certains avantages) Utilisation de XAML, un dérivé du XML pour créer nos interfaces graphiques. XNA, une bibliothèque facile à utiliser qui permet la création de jeux.
Cependant, il faut néanmoins rester conscient que le .net n'a pas que des avantages, les inconvénients sont entre autres: Même si un portage de .net est en cours sous Unix, seul Windows supporte correctement tout le .net.
Les applications peuvent être désassemblées pour retrouver une approximation de la source initiale. Un outil permet néanmoins de rendre illisible ce code désassemblé.
Même si l'IDE de Microsoft est très puissant, il est assez lourd (~600Mo pour la version Express, plusieurs Go pour les versions professionnelles, ce qui même aujourd'hui peut paraitre important)
Néanmoins, si vous êtes sous Windows, que vous voulez faire de jolis programmes de manière simple, et que vous avez un peu d'espace disque, le C# et .net sont faits pour vous .
Maintenant que nous avons un aperçu du fonctionnement du .net, nous allons pouvoir commencer à coder en C#! Tous à vos claviers
Premiers pas avec C#
Hello, les Zéros!
Dans ce chapitre je vous expliquerai comment créer des variables dites primitives, mais vous verrez, elles sont très utiles!
Mais tout d'abord, avant de programmer, il faut avoir un environnement de développement, nous allons donc commencer par le choix de notre IDE. Bon, préparez-vous! On passe à l'attaque !
Quelques outils pour bien développer
Tout d'abord, avant de développer, posons nous la question: "Avec quoi développer?"
Dans ce cours, tout les exemples sont faits sous Visual Studio, qui est l'environnement de développement spécialement créé pour le .net. Pour ceux qui sont sous Unix (Linux ou Mac OS X), il existe aussi un environnement de développement totalement libre spécialement créé pour faire du .net sous Unix: MonoDevellop.
Visual Studio
Visual Studio (actuellement dans sa version finale 2010) est un outil très puissant, il est décliné en plusieurs versions, certaines gratuites, d'autres payantes. Heureusement pour nous, tout ce que nous allons faire pourra être amplement fait sous une version gratuite dite "Express".
Nous allons néanmoins passer en revue les différentes versions.
Il existe tout d'abord une version professionnelle, en plus du C#, elle nous permet de faire du VB.NET, du développement Web avec ASP.NET, ainsi que du C++ (ISO, ou encore C++/CLI).
Viennent ensuite les versions dites "Premium" et "Ultimate" permettant entre autre la gestion de projets avancé avec des outils de modélisation et de gestion de travail collaboratif.
Si vous voulez vous faire une idée, je vous invite à fouiller un peu le site de Microsoft, ici, pour avoir une description plus détaillée des versions.
Venons en maintenant à la version que la plupart d'entre vous téléchargeront: Visual C# 2010 Express Edition. Cette version n'est non pas une version allégé de Visual Studio, mais plutôt une version allégée de la partie C# de Visual Studio. En effet, il existe non pas une seule et unique version express de Visual Studio, mais bien cinq versions express! Ces versions express sont Visual Basic Express (pour développer en VB.NET), Visual C# Express (la partie qui nous intéresse), Visual C++ Express (pour développer en C++) et Visual Web Developper Express (vous l'aurez deviné: pour du développement web ). A ces versions peut s'ajouter une variante de Visual C# Express permettant de développer exclusivement pour Windows Phone 7 en silverlight et XNA, cela sort actuellement de l'objet de ce cours, mais sachez que cela existe.
Rendez-vous donc sur ce lien et télécharger Visual C# Express Edition dans la langue de votre choix. L'installation ne devrait pas poser de problème, il est possible que le framework .net 4.0 se télécharge durant l'installation qui peut donc être longue.
Pour les utilisateurs d'Unix, il est aussi possible de développer en C#. Et tout cela grâce à une initiative de Miguel De Icaza qui n'est qu'autre qu'un des créateurs de Gnome. De 2001 jusqu'à aujourd'hui, Novell, la société gérant la distribution Open Suse, travaille sur une implémentation open source de la plateforme .NET sous Linux. Après quelques années de travail et de négociations avec Microsoft, MonoDevelop voit le jour avec sa documentation MonoDoc, puis un peu plus tard Moonlight qui est l'adaptation de Silverlight sous Linux.
Néanmoins, même s'il conviendra pour le début du cours, MonoDevelop ne permet d'exploiter pleinement qu'une partie de la plateforme .net et se retrouve donc incapable d'effectuer plusieurs parties récentes et importantes du .NET.
Il y énormément de chose à dire sur Mono, mais comme ce n'est pas le sujet de ce cour, je vous propose de jeter un œil là dessus. Ces cours traitent exclusivement de Mono (à l'heure actuelle, il manque encore des chapitres, mais ils sont en cours de rédaction).
Créer un nouveau projet sous Visual Studio
Une fois votre version de Visual Studio installée, lancez là. Dans la fenêtre principale, allez au Menu "Fichier", puis "Nouveau" et "Projet". Dans la fenêtre qui s'ouvre, vous avez le choix entre plusieurs types de projet. Pour l'instant, nous choisirons "Application Console". Une fois votre type de projet sélectionné, vous pouvez choisir un nom de projet et de solution. Le mot "projet" dans Visual Studio a le même sens que celui utilisé en français : "Dessein, idée de ce que l’on pense réaliser, conception des moyens que l’on croit utiles pour exécuter ce qu’on médite" ; en bref si vous avez une idée de programme, tout ce qui vous permettra de réaliser ce programme se retrouvera dans un projet. Mais parfois, il est nécessaire de diviser notre programme en plusieurs projets : par exemple si vous voulez créer un jeu en ligne, le jeu en lui même se retrouvera dans un projet et le site web d'administration du jeu se trouvera dans un autre projet. Une solution sera donc un rassemblement de plusieurs projets. Par défaut, donner le nom à un nouveau projet créera une nouvelle solution du même nom, mais vous pouvez bien sur donner un nom différent à votre projet et à votre solution.
Pour mes cours et mes stages, il m'arrive d'utiliser des outils de Visual Studio absent de la version express, j'utilise donc une version ultimate, néanmoins l'écran est similaire pour la version express.
Une fois validé, dans l'espace central de Visual Studio, un fichier source nommé "Programme.cs" sera ouvert, ce fichier sera le point d'entré de votre programme. Dans l'immédiat je vous propose de remplacer le code présent par le code suivant :
Code : C# - Sélectionner using System;
namespace SiteDuZeroConsole
class Program
{
static void Main(string[] args) {
Console.WriteLine("Hello site du zéro"); }
} }
Pour l'instant, ne vous souciez pas des détails de ce code, c'est juste pour vos donner une idée sur l'apparence de nos premiers programmes.
Maintenant que nous avons notre premier code source, nous allons compiler notre programme et l'exécuter. Pour cela, deux choix s'offrent à vous : démarrer en débogage ou démarrer sans débogage. Le premier choix mènera à une exécution légèrement plus lente que la seconde mais nous permettra plus tard de voir quasiment en direct le code s'exécuter ligne par ligne sous nos yeux . La seconde plus rapide s'occupera juste d'exécuter de manière simple le programme, mais ne permettra pas si un beug se produit de détecter d'où il provient. Pour exécuter en déboguant, allez au menu "Debeug" ("Debug" pour les versions anglaises) puis "Démarrer le débeugage" ("Start debugging") ou appuyez sur la touche F5 de votre clavier, ce que l'on appelle une console va s'ouvrir puis se fermer immédiatement sans que nous ayons le temps de voir ce qui se passe. Pour bien voir, nous allons exécuter sans débogage, pour cela, toujours dans le menu "Debeug" mais cette fois ci "Démarrer sans débogage" ("Start without debugging") ou appuyez simultanément sur les touches Ctrl et F5. Là une console s'ouvrira et vous affichera :
Code : Console - Sélectionner
Hello site du zéro
Press any key to continue . . .
Voici votre premier programme C#! C'est beau non ?
Ce programme ne fait rien de spécial pour l'instant, juste afficher du texte, mais il peut faire bien plus ! Pour cela, nous allons parler des variables et des types primitifs.
Qu'est-ce qu'un type primitif?
Les variables
Tout d'abord, nous allons définir ce qu'est une variable.
Comme son nom l'indique, cela va être quelque chose dont la valeur va être ... variable. Cela pourra être un nombre, une lettre, un mot, une phrase, une valeur de vérité, n'importe quoi... En bref, c'est une valeur temporaire que l'on mettra dans la mémoire vive de l'ordinateur ( la mémoire vive est un composant de l'ordinateur qui sert à stocker temporairement des informations, dès que l'ordinateur s'éteint, cette mémoire est vidée). Cette valeur va servir à certains traitements. Puisqu'un petit exemple vaut mieux qu'un long discours : imaginons que nous voulons calculer un prix d'un objet soumis à une taxe, pour ce calcul, il nous faut deux informations, un prix hors taxe et le montant de la taxe, et nous obtiendrons une troisième information, le prix toute taxe comprise. Chacune de ces information va être une variable, en effet, on pourra calculer un prix toute taxe compris à partir de n'importe quel prix hors taxe et de n'importe quel taux de taxe, ce qui nous donnera un prix toute taxe comprise variable. En gros, un programme informatique va fonctionner comme cela : des variables données en entrée et une valeur de retour. Nous donnerons au programme le calcul à faire à partir des variables sans leur donner des valeurs, et c'est lors de l'exécution que ce programme va se débrouiller pour calculer.
Dans notre cas, nos variables sont des nombres, mais comme nous avons pu le voir plus haut, il peut y en avoir de types de variables différents : des entiers, des nombres décimaux, des chaines de caractères. En .net et en C#, ça va être la même chose, on aura plusieurs types différents : différents types d'entier, différents types de nombre décimaux, un type "lettre" (nous disons plutôt "caractère"), etc.. Les types que nous verrons ici sont dits types "primitifs".
Les types primitifs
Un type primitif c'est un type qui ne nécessite pas une initialisation avant d'être utilisé. Ce sont des types valeur (attention retenez bien ce type, il nous sera très important dans la partie concernant la programmation orientée objet). Voici la liste des types primitifs de .NET :
Nom Description
bool Un type qui peut prendre deux valeurs: true ou false (vrai ou faux)
byte Un type qui prend un octet de mémoire. La valeur ne peut être que positive (ou zéro) et a un maximum de 255 (un nombre codé sur un octet prend, comme son nom l'indique 8 bits en mémoire et a donc 256 "possibilités" ce qui donne de 0 à 255).
char Un type codé sur 2 octets, qui prend un caractère Unicode. decimal Un type codé sur 16 octets qui peut contenir des nombres décimaux
double Deux fois plus petit que decimal (8 octets). Peut contenir des nombres décimaux.
float Deux fois plus petite que double (4 octets). Peut contenir des nombres décimaux mais avec une précision moindre que celle d'un double int Un nombre entier. Peut contenir des valeurs positives ou négatives. Les int sont codés sur 4 octets. Est équivalent à Int32.
long Deux fois plus grand que int (8 octets). Contient des nombres entiers positifs ainsi que des entiers négatifs. Est équivalant à Int64. short Un type signée de 2 octets. Est équivalent à Int16.
sbyte Un byte signé. Cela veut dire que le valeur de la variable peut être positive ou négative. string Un type d'une taille indéfinie. Il contient une chaîne de caractères
uint Un int non-signée. Cela signifie que la valeur ne peut être que positive. En revanche, des nombres deux fois plus grand sont disponibles. ulong Un long non-signé.
Nom Description
ushort Un short non-signé
Les noms énoncés au-dessus sont en fait les alias vers des types ayant des noms plus complexes, par exemple "int" va être la même chose que "Int32", short va être la même chose que "Int16", l'utilisation du "vrai" type ou de son alias reviens au même, mais il faut savoir que ça existe car il arrive qu'on croise le "vrai" type au lieu de l'alias.
Déclarer sa variable
Où taper son code ?
Euh... C'est beau de nous avoir montré tout les types de variables, mais on ne sait même pas comment en créer une!
J'y venais justement. Tout d'abord pour taper du code, il faut bien entendu entrer dans un fichier de code . Dans l'immédiat nous allons écrire dans le fichier "Program.cs" créé automatiquement par Visual Studio lors de la création de notre projet. Chaque fichier de notre solution (un genre de conteneur pour rassembler un ou plusieurs projets), se trouve dans ... l'explorateur de solution (Solution Explorer pour les versions anglophones). Celui se trouve généralement sur la partie droite de Visual Studio (il peut bien sur être déplacé où vous voulez, même en dehors de la fenêtre de Visual Studio ), si vous ne le voyez pas, allez dans le menu "Affichage" ("View") puis "Explorateur de solution" ("Solution explorer") ou faites la combinaisons de touches "Ctrl+W, S".
Une fois que vous voyez bien votre explorateur de solution, double-cliquez sur "Program.cs" pour ouvrir le fichier dans la partie centrale de Visual Studio. A ce niveau là, vous devriez vous trouver en face de ce code si vous avez garder le même fichier que tout à l'heure :
Code : C# - Sélectionner using System; namespace SiteDuZeroConsole { class Program {
static void Main(string[] args) {
Console.WriteLine("Hello site du zéro"); }
} }
Ou de celui là si vous avez créé un nouveau projet :
Code : C# - Sélectionner using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; namespace SiteDuZeroConsole { class Program {
static void Main(string[] args) {
} } }
Pour plus de simplicité et pour ceux qui arriveraient ici sans avoir lu la partie précédente, je vais me baser sur ce dernier code (celui généré automatiquement lors de la création du projet).
Avant d'écrire notre propre code ici, laissez-moi vous expliquer ce que sont ces quelques lignes:
Ligne 1 à 5 : les directives "using", elles permettent d'importer des classes d'ailleurs, je vous expliquerais plus en détail le concept de classes un peu plus loin. Sachez que nos types énumérés un peu plus haut sont contenus dans l'espace de nom "System" (la première ligne du fichier), les quatre suivantes sont utilisées assez fréquemment, mais ici nous n'en aurons pas besoin.
Si le nombre de "using" vous fait peur et que vous voulez seulement utiliser ceux dont vous avez besoin, effectuez un clic droit n'importe où dans le code, et dans le menu contextuel allez à "Organiser les usings/Supprimer et trier" ("Organize usings/Remove and Sort" pour les versions anglaises de Visual Studio). Nous pourrons par la suite en ajouter de manière simple (Visual Studio le ferras pour nous )
Ligne 7 : le "namespace" ("espace de nom" pour ceux qui veulent franciser ) de notre projet, si vous ne l'avez pas modifié, cela prend le même nom que le projet que vous avez créé ("SiteDuZeroConsole" dans mon cas). Un namespace va être en quelque sorte un conteneur pour toutes les classes que vous créez.
Les directives using en haut sont suivies d'un namespace à inclure, ceux-ci peuvent être "contenus" les uns dans les autres, par exemple "System.Linq" est inclus dans "System".
Repérez l'accolade ouvrante à la ligne 8 et l'accolade fermante à la ligne 16, ce sont nos délimiteurs de notre espace de nom, tout ce qui seras dans ces accolades appartiendra à notre espace de nom.
Ligne 9 : déclaration de la classe, comme je vous l'ai dit un peu plus haut, nous verrons dans le chapitre suivant le concept de classe. Sachez juste qu'ici, notre classe "Program" va être la première classe de notre programme.
Les accolades à la ligne 10 et 15 sont les délimiteurs de notre classes, tout ce qui est entre ces accolades appartient à cette classe
Ligne 11 : le point d'entrée de notre programme, la méthode Main. Lorsque notre programme sera exécuté, ce sera cette méthode qui sera exécutée en premier. Comme pour les classes je reviendrais dans le chapitre suivant sur les méthodes de manière plus détaillée.
Notre méthode commence après l'accolade ligne 12 et se termine juste avant l'accolade ligne 14.
Ligne 13 : rien ... et c'est normal, c'est à nous d'écrire du code ici . Tout les extraits de code suivant sont à écrire ici. Vous pouvez écrire autant de lignes que vous voulez tant que vous restez entre les accolades de la méthode Main.
Syntaxe
Par souci de faire un code compréhensible, je serais mené à mettre des commentaires dans ce code, les commentaires se mettent en fin de ligne et ont la syntaxe suivante:
Code : C# - Sélectionner
//Commentaire sur une fin de ligne
Donc si vous voyez un double slash quelque part, lisez bien ce qui suit, ça risque de vous donner beaucoup d'indications Pour créer (le mot "déclarer" est plus correct) une variable on utilise la syntaxe suivante :
type nom;
La déclaration est une instruction. Une instruction va être une quelque sorte une étape insécable dans notre code, et pour avoir une instruction syntaxiquement correcte en C# on doit OBLIGATOIREMENT la finir par un point virgule (' ; ').
Voici comment je ferais pour déclarer un int (code à taper à la ligne 13):
Code : C# - Sélectionner int monEntier;
Affectation
On peut donner une valeur (ou plutôt affecter une valeur) à une variable déjà déclarée comme ceci :
Code : C# - Sélectionner
monEntier = 32;
L'affectation est aussi une instruction.
Cependant, nous savons tous que les programmeurs ce sont une bande de paresseux. Pour cette raison, les concepteurs de C# se sont dits que ça serait très pratique de pouvoir déclarer et affecter en même temps. Savez-vous comment faire?
Secret (cliquez pour afficher)
Rien de plus simple.
Vous pouvez faire ainsi avec n'importe-quel type que vous voulez. La seule différences résidera dans les caractères (char) dont la valeur sera placée entre simple quotes ( ' ) et les chaines de caractères (string) dont la valeur sera placée entre doubles quotes ( " ) comme dans l'exemple suivant :
Code : C# - Sélectionner
char caractere = 'c';//une variable de type caractère (char) dont on affecte la valeur grâce à un caractère placé entre simples quotes
string chaine = "une chaine"; //une chaine de caractère délimitée par des doubles quotes
Ecrire autant en moins de lignes
Lorsque que nous avons plusieurs variables du même type, il nous est possible de toutes les déclarer sans répéter le type, il suffira alors de les séparer par des virgules lors de la déclaration. Le premier code qui suit est le code "de base", le suivant est le code raccourci
Code : C# - Sélectionner int entier1 = 3;
int entier2 = 5;
int entier3 = 17;
Code : C# - Sélectionner
int entier1 = 3, entier2 = 5, entier3 = 17;
En général, il ne pas sacrifier la lisibilité du code au dépend de la longueur du fichier, ici nous ne perdons pas en lisibilité, car en lisant la ligne on voit facilement de quel type sont nos variables.
Donc lorsque vous pouvez raccourcir votre code sans nuire à la lisibilité, surtout n'hésitez pas !
Conversions
Parfois, il est utile de pouvoir convertir un type primitif en un autre, aussi bien d'entiers à décimaux, de décimaux à entiers, de chaine de caractère en booléen, d'entier en chaines de caractère... En bref, tout est possibles (ou presque ^^)
Conversion en chaine de caractère : méthode ToString()
C'est la conversion la plus simple, pour tout les types de données (sans exception) nous avons ToString(). Pour ceux qui ne parlent pas trop anglais, nous pourrions traduire par "EnChaineDeCaractere". La syntaxe est simple : maVariable.ToString() et ce avec n'importe quel type de donnée :
Code : C# - Sélectionner int entier = 1;
double flottant = 3.5;
bool booleen = true;
char caractere = 'c';
string chaine = "salut";
string entierEnChaine = entier.ToString();//1 devient "1"
string flottantEnChaine = flottant.ToString();// 3.5 devient "3.5"
string boolEnChaine = booleen.ToString();// true devient "True"
string caractereEnChaine = caractere.ToString(); // 'c' devient "c"
string chaineEnChaine = chaine.ToString(); // "salut" devient... "salut" :D
Rien de plus compliqué : vous voulez une chaine de caractère, ajoutez ".ToString()" derrière votre variable, vous pouvez le faire avec n'importe quoi, même avec une chaine de caractère (bon là l'intérêt est pas immédiat, mais avec quelques options que nous verrons plus tard, cela peut devenir plus intéressant).
Conversion de types numériques en d'autres types numériques
Là, cela devient un tout petit peu plus délicat, car il faut prendre en compte que les différents types ne sont pas codés sur le même nombre d'octets donc par exemple pour convertir un byte vers un short, il n'y aura aucun problème, mais par contre l'inverse peut révéler quelques surprise. Pour comprendre plongeons nous un peu dans du binaire : les nombres au sein d'un ordinateur sont codés en binaires, ce sont donc des suites de 0 et de 1 (digits), nos variables étant codées sur des nombres d'octets différents, ces suites de digits vont avoir différentes longueurs, ce qui donne pour un même nombre dans différents types de données (par exemple 14) :
0000 1110 pour un byte 0000 0000 0000 1110 pour un short
0000 0000 0000 0000 0000 0000 0000 1110 pour un int
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1110 pour un long
Vous voyez que pour un même nombre, la place occupée peut aller du simple au double (et même du simple à l'octuple ). Donc gardez bien à l'esprit que même si aujourd'hui ces tailles de variables sont insignifiantes par rapport aux tailles de mémoires vives disponibles (en comparaison, un ordinateur neuf aujourd'hui "milieu/haut de gamme" avec 4 Go de RAM peut théoriquement contenir à peu près 500 millions de "long" simultanément ), il est important de rester conscient de la taille prise pas nos variables en mémoire et de pourvoir l'optimiser. En effet, des tas de développeurs (moi compris) utilisent systématiquement des int (4 octets) pour des entiers et des doubles (8 octets) pour des flottants, alors qu'honnêtement on a pas souvent besoin d'avoir une variable pouvant aller de -2 147 483 648 à 2 147 483 647, vous pouvez généralement très bien vous en sortir avec un short (2 octets) et même un byte (1 octet) parfois. Pour la petite histoire, il y a de cela quelque mois, je faisais de la génération d'images en C#, et avant de créer l'image, je devais contenir l'information pour chaque pixel (3 couleurs, rouge, vert et bleu), chacune de ces couleurs avait une "valeur" entre 0 et 255 (un octet), et je me suis vite rendu compte qu'en utilisant le type byte au lieu de int, j'économisais à peu près 61 Mo de mémoire vive (22 Mo contre 83 Mo) pour une image full HD (1920 pixels par 1200). Certes, j'avais encore beaucoup de mémoire vive inoccupée sur mon PC, mais imaginons ce programme sur un périphérique mobile, dans ce cas économiser 61 Mo de mémoire vive c'est énorme !!
J'avoue que cette dernière explication peut faire peur , rassurez-vous, je ne vais pas sans arrêt vous prendre la tête avec l'optimisation maximale de votre mémoire vive, car en effet, l'optimisation ne concerne pas seulement la mémoire vive ! Il faut que vous sachiez que, globalement, un int se modifie en mémoire plus rapidement que les autres types d'entiers, donc pour un entier qui doit changer souvent de valeur, nous préférons un int et nous nous attachons à l'optimisation de nos types seulement lorsqu'un très grand nombre de variable est utilisé (par exemple dans le cas de la génération d'image ).
Si la conversion se fait sans perte de donnée, c'est à dire vers un type "petit" vers un grand type, tout ce fait automatiquement comme pour le code suivant:
Code : C# - Sélectionner byte unByte = 4;
short unShort = unByte;
Nous voyons ici que nous assignons un short à partir d'un byte, les types ne sont pas les mêmes et pourtant cet extrait de code fonctionne parfaitement. La raison est simple, du côté binaire il n'y a qu'à "compléter" avec des 0 pour passer d'un byte en short. Par contre, le code suivant ne fonctionnera pas (enfin, pas directement):
Code : C# - Sélectionner short unShort = 4;
byte unByte = unShort;
En effet, même si, dans notre cas, il n'y a pas de perte de donnée lors de la conversion (un byte a une taille suffisante pour stocker 4), il pourrait y en avoir une avec un short ayant une valeur supérieur à 255, donc Visual Studio nous signale qu'on ne peut pas implicitement convertir un short en byte. Si on analyse un peu ce message d'erreur, on peut deviner que, puisqu'on ne peut pas le faire implicitement, on doit pouvoir le faire explicitement (logique ). En C#, pour convertir explicitement une variable d'un type en un autre type, il nous suffit de préciser le type entre parenthèses juste devant notre variable, le code précédant corrigé donnera donc :
Code : C# - Sélectionner short unShort = 4;
byte unByte = (byte)unShort; // On converti explicitement un short en byte
Ici, il n'y aura pas de problème particulier, par contre, si votre short était plus grand que 255, notre byte aurait valu à la sortie la valeur du short modulo 256 (par exemple si le short valait 260, le byte aurait valu 4) car le compilateur vas juste se contenter de prendre les bits de poids faibles jusqu'à remplir l'espace alloué à un byte puis "oubliera" le reste (les bits de poids fort).
Gardez donc bien à l'esprit qu'il peut y avoir de la perte d'information lorsque vous effectuez des conversions d'un type vers un type "plus petit"
Conversions de string vers autres types de données : méthodes Parse() et TryParse()
Parfois, nous allons avoir besoin de convertir des chaînes de caractères en d'autres types de données. Par exemple convertir "123" (chaine de caractère) en 123 (entier), ou convertir "false" en un booléen valant false. Pour chacune de ces conversions, nous allons avoir deux manières de procéder, l'une étant légèrement plus complexe que l'autre, mais permet de voir plus facilement s'il y a eu une erreur de conversion.
Mais tout d'abord voyons la plus simple : Parse. "Parser" va signifier parcourir tout les éléments d'une chaine de caractère pour un obtenir autre chose, dans notre cas on va parcourir chaque caractère de la chaine, voir si c'est un chiffre, et si on n'a vu que des chiffres, on retourne le nombre correspondant. Cela peut paraitre bien compliqué mais, ne vous en faites pas, la méthode Parse le fait pour nous. Voyons son utilisation:
Code : C# - Sélectionner
string nombreEnString = "123";//On a un nombre en chaine de caractère
int nombreEntier = int.Parse(nombreEnString);//Grace à int.Parse(...) on en fait un entier
La syntaxe de int.Parse(..) nous importe peu pour l'instant. Retenez juste que int.Parse(...) va permettre de convertir en entier une chaine de caractères passée en paramètres (entre les parenthèses de "Parse(...)"). Dans notre exemple, nombreEntier vaudra 123 comme vous pouvez le deviner.
Pour convertir une chaine de caractère en nombre décimal ou en booléen, cela va être identique, on remplacera juste "int" par le type que l'on veut. Par exemple :
Code : C# - Sélectionner
bool booleen = bool.Parse("true");//Booleen vaudra true
double unDecimal = double.Parse("123.4");//unDecimal vaudra 123,4
C'est bien, mais essayer de donner à Parse quelque chose de "imparsable" et votre programme plantera lamentablement . Essayez donc ça :
Heureusement, nous avons aussi une méthode qui ne fait pas tout crasher : la méthode TryParse !
Pour les non-anglophones, "try" signifie "essayer" ; cette méthode va donc essayer de parser ce que nous lui donnons en paramètre et renverra un booléen si le parsage n'a pas réussi. La syntaxe va être légèrement différente, par exemple avec le même exemple que tout à l'heure:
Code : C# - Sélectionner
string nombreEnString = "123";
int unEntier;
int.TryParse(nombreEnString, out unEntier);
L'entier ne va pas être renvoyé directement, il nous faudra créer une variable de type int au préalable et la passer en second paramètre à la méthode. Vous pouvez remarquer le mot-clé "out", celui-ci est obligatoire pour l'utilisation de cette méthode, nous expliquerons l'utilité de mot clé dans un chapitre suivant, pour l'instant retenez juste qu'il nous faut absolument le mettre (le programme ne compile pas sinon).
Pour l'instant, rien de fabuleux par rapport au simple "Parse", ceci est dû au fait qu'ici j'utilise TryParse de la manière dont j'utiliserais Parse. Et oui, ces deux méthodes ne s'utilisent pas vraiment pareil, pour bien utiliser TryParse, je préfèrerais le code suivant:
Code : C# - Sélectionner
string nombreEnString = "123";
int unEntier;
bool aReussi = int.TryParse(nombreEnString, out unEntier);//TryParse renvoie un booléen valant vrai en cas de succès, sinon il renvoie faux
Voyons l'ajout de la variable booléenne récupérant le résultat de TryParse, si le parsage a réussi, "aReussi" vaudra true, si ça échoue, cela ne vas pas planter et fermer le programme comme avec Parse, mais cela va renvoyer false. Ainsi, nous pourrions vérifier si le parsage a réussi au lieu de croiser bêtement les doigts pour que cela ne plante pas
Gérer les entrées/sorties de bases
Avant d'attaquer pleinement la programmation orientée objet, nous allons apprendre comment gérer les entrées et sorties de bases : écrire quelque chose à l'écran et lire une entrée utilisateur.
Utiliser Console.WriteLine(...)
Comme le titre l'indique, nous allons utiliser Console.WriteLine(); pour écrire quelque chose sur la console. Pour les observateurs bilingues, vous devinerez facilement que cette instruction demande à la console d'écrire quelque chose à l'écran. Les concepts sous-jacents à la syntaxe de cette instruction seront vues dans le chapitre juste après (et oui, vous en saurez des choses dans le chapitres suivants ).
Si vous écrivez simplement Console.WriteLine(); et que vous exécutez (bouton vert en forme de triangle sous le menu, ou dans le menu "Debug/Start Debugging" ("Débogage/Démarrer le débogage") ou en appuyant sur la touche F5 de votre clavier), rien ne semblera se passer. En réalité, une ligne sera sautée dans la console et cette dernière se fermera d'elle même. Pour évitez cette fermeture automatique, plusieurs choix s'offrent à vous, le plus simple est d'exécuter sans débogage, pour cela, allez au menu "Debug/Start Without Debugging" ("Débogage/Exécuter sans Débogage") ou pressez la combinaison de touche Ctrl + F5 ; ainsi, vous verrez qu'une ligne a été sautée sur la console par votre code avant qu'il vous soit demandé de presser une touche pour que la console se ferme. Certes cette manière de sauter une ligne dans la console vous paraitra pratique, mais je vous déconseille fortement de l'utiliser, car il y a mieux pour cela, comme les caractères "\r" et "\n" que j'utiliserais brièvement dans un des chapitres suivants, mais j'y reviendrais dessus à ce moment là, promis .
Venons en maintenant à une utilisation un peu plus compliquée (pas de quoi vous taper la tête contre les murs quand même ) , écrire une ou plusieurs chaines de caractères !!
Pour une seule chaine comme ceci:
Code : C# - Sélectionner
Console.WriteLine("Coucou les zéros !");
Qui donnera le résultat suivant:
Code : Console - Sélectionner
Coucou les zéros !
On peut aussi afficher en une seule fois plusieurs chaînes de caractères concaténées, c'est à dire mises les unes à la suite des autres. Pour concaténer plusieurs chaînes, nous allons simplement utiliser l'opérateur "+".
Nous pourrons donc écrire l'instruction suivante:
Console.WriteLine("Je suis une chaine. " + "Moi aussi!! " + "Et moi alors!!");
Qui affichera:
Code : Console - Sélectionner
Je suis une chaine. Moi aussi!! Et moi alors!!
Vous pouvez aussi très bien écrire des nombres:
Code : C# - Sélectionner
Console.WriteLine(3.5);
Qui donnera :
Code : Console - Sélectionner
3.5
Attention toute fois si vous voulez concaténer des nombres (l'idée est assez bête mais bon peut être que certain y ont pensés ), ceux-ci vont s'additionner:
Code : C# - Sélectionner
Console.WriteLine(3.5 + 2);
Qui donnera :
Code : Console - Sélectionner
5.5
Si vous n'avez vraiment pas le choix et que vous devez absolument concaténer des nombres, convertissez simplement chacun des nombres en chaine de caractères.
Code : C# - Sélectionner
Console.WriteLine((3.5).ToString() + (2).ToString());
Et là magique :
Code : Console - Sélectionner
3.52
Un grand intérêt qui réside est que vous n'êtes pas obligés de taper directement la chaîne à afficher, vous pouvez passer par des variables intermédiaires :
Code : C# - Sélectionner
string chaine1 = "Bonjour ";
string chaine2 = "les ";
string chaine3 = "zéros ";
Console.WriteLine(chaine1 + chaine2 + chaine3);
Qui affichera comme tout à l'heure
Code : Console - Sélectionner
Remarquez qu'il existe aussi la méthode Write qui produira exactement le même résultat, mais sans sauter de ligne. WriteLine reste néanmoins plus utilisée, si bien que Visual Studio intègre un raccourci clavier pour écrire Console.WriteLine();, pour l'utiliser, tapez à l'endroit adéquat "cw" (comme Console et WriteLine) puis pressez deux fois la touche tabulation, l'extrait de code est ainsi automatiquement ajouté.
Utiliser Console.ReadLine()
A présent, nous allons voir comment demander à l'utilisateur de rentrer une chaîne de caractère (puis par extension un nombre).
Pour les heureux bilingues qui lisent ce cours, la logique est de mise ici, en effet on écrit avec Console.WriteLine(...) donc nous lirons avec... Console.ReadLine()!! La syntaxe est beaucoup plus simple pour les entrées standards:
Code : C# - Sélectionner
string uneChaineDeCaractere;
uneChaineDeCaractere = Console.ReadLine();
Lorsque le programme arrivera à cette instruction dans le code, l'utilisateur devra écrire une ligne de texte dans la console et finir en appuyant sur la touche 'entrée'.
Toute la ligne écrite sera stockée dans la variable uneChaineDeCaractere.
Si nous combinons ReadLine() avec les conversions vues dans un chapitre précédent, pour récupérer un entier entré par l'utilisateur nous ferrons:
Code : C# - Sélectionner int unEntier;
Console.WriteLine("Entrez un nombre");
bool aReussi = int.TryParse(Console.ReadLine(), out unEntier);
Console.WriteLine("aReussi vaut " + aReussi.ToString() + " et l'entier vaut " + unEntier.ToString());
Ainsi, si nous entrons un nombre, cela affichera:
Code : Console - Sélectionner
Entrez un nombre 3
aReussi vaut True et l'entier vaut 3
Et en cas de faute de frappe, cela affichera:
Code : Console - Sélectionner
Entrez un nombre "
aReussi vaut False et l'entier vaut 0
Nous verrons plus tard comment faire pour demander à l'utilisateur d'entrer un nombre tant qu'il n'a effectivement pas tapé un nombre correct (sans aucun autre caractère qu'un chiffre)
Ceux qui auront commencé à explorer les propositions de l'auto-complétion (appelée "intellisense" sous Visual Studio) auront remarqué une méthode "Read()" et auront fait le rapprochement avec la méthode "Write()", c'est à dire une méthode "capable de lire une chaine de caractère entrée à l'écran sans sauter de ligne". Or ce n'est pas le cas !! La méthode "Read()" va seulement récupérer le dernier caractère du flux d'entrée standard, son utilisation ne nous intéresse pas encore, nous utiliserons donc pour le moment exclusivement la méthode "ReadLine()".
A cela, s'ajoutera aussi Console.ReadKey() qui se contentera elle de lire un seul caractère, nous ne verrons pas tout de suite comment l'utiliser pour stocker un seul caractère, nous l'utilisons généralement en fin de programme pour éviter que la console ne se ferme toute seule, de la manière suivante:
Code : C# - Sélectionner
//Contenu du Main()...
Console.WriteLine("Appuyez sur une touche pour continuer..."); Console.ReadKey();
Grâce à ce code, vous pouvez lancer votre programme en mode debeug sans que la console se ferme toute seule à la fin
Il peut être intéressant de noter que, par défaut, Console.ReadKey() affiche le caractère tapé. Pour ne pas l'afficher, préférez le code suivant:
//Contenu du Main()...
Console.WriteLine("Appuyez sur une touche pour continuer..."); Console.ReadKey(true);
Sachez qu'en programmation, si on n'avait que des types primitifs, on n'irait pas très loin ... Néanmoins, ils sont à la base de tout, et nous verrons dans le chapitre suivant comment créer et utiliser des types complexes composés d'un nombre plus ou moins important de types primitifs. Les chapitres qui suivent sont certainement les plus importants, en effet on va parler de la Programmation Orientée Objet (POO pour abréger). Même pour ceux qui ne feront pas du C# toute leur vie (comment ça, il y en a ? ), vous pouvez avoir besoin de ces concepts dans de nombreux autres langages.
La programmation orientée objet (1/3)
Enfin, nous voici à la première partie des trois mini-tutos sur les classes. Les classes c'est... ben, vous le verrez ! Ce sont des parties fondamentales de C# et même de .NET ! Sans elles, vous ne pourrez quasiment rien faire ! Écrire dans la console, lire dans un fichier, même juste commencer le programme nécessite une classe.
Les nouveaux concepts
Les champs
Au premier abord un objet peut être défini par sa structure interne et son comportement. Par "structure interne" on entend un ensemble de champs, aussi appelés attributs. Un champ va être tout simplement une variable. Imaginons par exemple un objet "voiture", il aura un champ "nombre de portes" qui va être un entier, un champs "puissance" qui va être un nombre décimal, un champ "marque" qui va être une chaine de caractère, un champ "propriétaire" qui va être un objet de type "personne", quatre champs "roue1", "roue2", ... de type "roue" etc...
Le premier concept que nous apporte donc ici la programmation orientée objet va être un ensemble de champs définissant la structure interne d'un objet comme on peut se le représenter dans la réalité.
Sachez que l'on peut aussi parler d'attributs, néanmoins ce mot a un autre sens, je préfèrerais donc utiliser le mot champ.
Les méthodes
Ensuite un objet est défini par son comportement, c'est à dire par les traitements qu'il peut réaliser. Notre voiture par exemple pourra avancer, tourner, allumer ses phares, etc... Ces différents traitements vont être réalisés dans des méthodes qui vont manipuler les champs (par exemple la méthode avancer fera tourner chaque roue à la même vitesse).
Le second concept que nous apporte la programmation objet est donc un ensemble de méthodes définissant le comportement de notre objet.
Différence entre classes et objets
Tu es bien gentil, mais le chapitre s'appelle "Programmation orientée objet" mais tu ne nous a pas encore parlé d'objet. Qu'est ce que c'est ?
J'y arrive . Un peu plus haut, j'ai évoqué le concept de "classes", ces classes sont liés aux objets de manière simple : nous pouvons comparer les classes à des types comme int ou char et les objets à des variables. Nous pouvons comparer la classe à un moule et l'objet ce qui est créé à partir de ce moule. Les objets créés à partir à partir d'une classe seront appelés "instances de la classe".
Nous dirons donc "instancier la classe" lorsque que nous créerons un objet
Et le C# dans tout ça ?
La première partie de ce chapitre est volontairement assez théorique, mais nous en venons à présent à quelque chose de plus concret, vous allez à présent voir comment créer des classes et des objets en C#.
Création de classes et d'objets
Création de classes
("Add", "Class" pour les versions anglophones). La fenêtre d'ajout de nouvel élément va apparaitre et l'élément "classe" sera présélectionné, vous n'avez plus qu'à choisir un nom pour votre classe dans le champ de texte du bas puis à cliquer sur "Ajouter". Un code de base sera créé, par exemple pour une classe "Personne".
Code : C# - Sélectionner using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace SiteDuZeroConsole { class Personne { } }
Création de champs
Un champ va être en quelque sorte une "variable interne" à la classe, la syntaxe pour créer un champ va être la suivante:
Code : C# - Sélectionner
Accessibilite Type Nom;
L'accessibilité représente la "visibilité" de notre champs en dehors de la classe, pour le moment nous nous contentons de mettre "public" pour l'accessibilité, mais lorsque nous verrons l'encapsulation, nous mettrons tout en "private".
Si nous ajoutons un champ nom, un champ prénom et un champ age, notre code sera le suivant :
Code : C# - Sélectionner using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace SiteDuZeroConsole { class Personne {
public string _nom; public string _prenom; public int _age; }
}
Hey!! Mais c'est quoi ces underscores ( "_" ) devant tes noms ?
C'est ce qu'on appelle une convention de nommage. Généralement les développeurs C# utilisent la suivante: Pascal Case (par exemple "ClassePersonne") pour les noms de méthodes, de classes et de propriétées camel Case (par exemple "maVariable") pour les champs internes aux méthodes
underscore ( "_" ) suivi de camel Case (par exemple "_monAge") pour les champ internes aux classes
Création de méthodes
Comme je l'ai dis auparavant, les méthodes sont le comportement de notre objet. La syntaxe est la suivante:
Code : C# - Sélectionner
[static] Accessibilite TypeDeRetour Nom([Parametre[s]]) {
[return Valeur]; }
Concernant la première ligne, appelée "définition ou signature de la méthode", les éléments à renseigner sont les suivants:
Le mot clé "static" présent ici et devant la méthode Main() du fichier "Program.cs" doit vous intriguer, nous l'expliquerons un peu plus loin, ne vous inquiétez pas. Pour l'instant, comme pour les champs nous mettons "public" comme accessibilité de notre méthode.
Le type de retour peut être aussi bien un type primaire qu'une classe. Si la méthode ne doit rien renvoyer nous mettrons comme type de retour "void". Par convention, comme je vous l'expliquais un peu plus haut, le nom des méthodes commencent par une majuscule (PascalCase).
Viennent ensuite les paramètres, on peut en mettre un seul, plusieurs de même types ou de types différents, ou même ne pas en mettre du tout!!
Concernant la partie entre accolade, appelée "corps de la méthode", on mettra notre logique à exécuter lors de l'appel de la méthode, la seule partie obligatoire sera le "return" suivi d'un objet du type spécifié dans la définition (sauf si la méthode ne retourne rien, dans ce cas "return;" ne sera pas obligatoire).
Comme exemple, nous allons créer deux méthodes, l'une permettant de retourner le nom suivi du prénom et de l'age de la personne, l'autre permettant de modifier la valeur de l'age. Code : C# - Sélectionner using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace Formation { class Personne {
public string _nom; public string _prenom; public int _age;
public string GetIdentite() {
return _prenom + " " + _nom + " a " + _age + " ans"; }
public void SetAge(int newAge) {
_age = newAge; }
} }
La methode "SetAge" ne sert certe pas à grand chose ici vu que nous pouvons modifier directement "_age", le plus important ici est de voir l'utilisation de paramètre et les types de retour de méthodes.
Création d'objet : instanciation de classes
Comme une bon exemple vaut mieux qu'un long discours, je vais d'abord vous montrer un exemple avant de vous l'expliquer.
Code : C# - Sélectionner
Nous voyons ici l'apparition d'un nouveau mot clé : "new". Il nous servira chaque fois que nous instancierons une classe.
Nous avons effectué quelques opérations de bases, l'assignation des valeurs de "_nom", "_prenom" et "_age", l'appel d'une méthode avec valeur de retour et l'appel d'une méthode avec paramètre modifiant les valeurs de champs. Le résultat visuel sera le suivant :
Code : Console - Sélectionner
Cynthia Prion a 30 ans Cynthia Prion a 32 ans
Les classes, champs et méthodes statiques
Lorsque vous avez créé votre projet, vous avez du remarquer le mot clé "static" devant la méthode Main. Pour faire simple, pour une méthode ou un champ, si nous mettons le mot clé "static" devant, nous n'avons pas besoin d'instancier sa classe. Nous y accédons directement ainsi: Classe.Methode();.
Mais, cette syntaxe ne vous rappelle rien ?
En réalité, Console est une classe statique, et WriteLine() et ReadLine() sont des méthodes statiques, pas besoin d'instancier Console pour utiliser ses méthodes. D'ailleurs, vous ne pourrez pas instancier Console, en effet, une classe statique ne peut pas être instanciée, du coup (on devine facilement pourquoi) tout ses champs et toutes ses méthodes doivent être statiques.
Si vous ne voyez pas trop l'intérêt des méthodes statiques, voyez plutôt l'exemple de la classe Math qui, comme certains peuvent le deviner, permet d'effectuer certains calculs. Il peut paraitre stupide de devoir l'instancier pour accéder à ses méthodes, on ne vas pas créer un objet de type Math pour accéder à Pi et un autre pour calculer un logarithme, nous ferrons tout simplement ceci :
Code : C# - Sélectionner
double pi = Math.PI;//pi vaudra 3.1415926535897931
double nombre = Math.Log10(1000);//nombre vaudra 3.0
La méthode Main est statique car elle est exécutée directement lorsque le programme démarre, c'est à dire sans instanciation de la classe Program. Ceci veut dire que vous pouvez très bien créer des membres dans la classe Program, mais ils doivent absolument être eux aussi en static pour être appelés depuis la méthode Main (et c'est logique), il en est de même pour les méthodes de Program qui doivent être statiques pour être appelées depuis la méthode Main.
L'utilité de créer un champ statique est de pouvoir accéder à cette valeur unique depuis n'importe quelle instance de sa classe (ou même sans instance de la classe comme pour Math.PI), il vaudra toujours la même valeur. Nous utiliserons par exemple un champ statique pour faire un compteur du nombre d'objet instanciés à partir d'un certaine classe ou pour réaliser un singleton (objet qui ne peut être instancié qu'une seule fois).
Bon, vous en savez maintenant ce qu'est une classe, un objet, un champ et une méthode. Vous êtes capables de créer vos propres classes ( ce que je vous encourage à faire, essayez par exemple de représenter tout ce qui se trouve dans votre chambre en POO, vous verrez c'est un bon exercice )
Néanmoins, il vous reste encore des choses très importantes à voir sur la programmation orientée objet comme le comportement des objets en mémoire et les constructeurs, ce qui est d'ailleurs au sujet du prochaine chapitre (le hasard fait bien les choses non ? )
La programmation orientée objet (2/3)
Vous savez déjà créer et utiliser des objets. Vous pouvez déjà commencer à créer vos classes sans ce chapitre, mais quelques notions importantes de plus ne ferrons pas de mal
En effet, dans ce chapitre, je vais vous parler de l'encapsulation, une concept de base de la programmation orientée objet. Nous verrons donc ici comment modifier la visibilité des champs et des méthodes et dans quels cas nous devons rendre un champ ou une méthode plus ou moins accessible.
Théorie sur l'encapsulation
Le problème
Imaginons un objet comme une mécanique très complexes, avec des multitudes d'engrenages, de pistons, de mécanismes... comme dans une voiture. Cette mécanique est tellement complexe qu'on a créé des commandes pour manipuler ces différents éléments de manière simple. Par exemple tourner la clé actionnera le démarreur qui injectera de l'essence dans le moteur et allumera les bougies pour déclencher l'explosion, ... et ainsi de suite jusqu'à que les roues soient entrainées. Ainsi, même si la mécanique est complexe dans le moteur, il nous suffit globalement de savoir tourner une clé, appuyer sur des pédales et tourner un volant.
L'encapsulation
En programmation orientée objet, c'est la même chose, nous allons "cacher" tout les champs pour ne pouvoir les manipuler qu'au sein de notre classe, ces manipulations seront faites par les méthodes qui pourront quant à elles être publiques. Nous allons nommer ce concept "encapsulation", il va apporter un niveau d'abstraction supplémentaire.
Mais rendre nos champs privés, ça ne va pas complexifier l'utilisation de la classe ?
La réponse est non, bien au contraire, cela va simplifier beaucoup de chose, non pas lors de la conception de la classe, mais lors de son utilisation !! Imaginez un instant que dans votre voiture vous ayez accès dans l'habitacle à chaque partie du moteur ! D'une part cela va déstabiliser quelqu'un n'a jamais appris à conduire, d'autres part c'est parfaitement inutile et même pire cela pourrait être dangereux si jamais vous essayez de manipuler directement un élément du moteur. Pour une classe (mais avec des enjeux moins vitaux je vous rassure ) cela va être la même chose, avoir accès à tout les champs peut nous perdre dans un premier temps (quel champ faut-il récupérer ? Quelle méthode faut-il utiliser?), ensuite c'est inutile puisque nous pouvons utiliser de manière simple une méthode qui manipulera les données à notre place et enfin en manipulant des champs qui n'ont pas lieu d'être modifiés directement pourrait "dérégler" le fonctionnement des méthodes.
Différentes accessibilités
Publique
Une accessibilité publique sur un champ ou une méthode permet d'être accessible en dehors de la classe. Le mot clé pour une accéssibilité publique est public. Observons l'extrait de code suivant :
Code : C# - Sélectionner class Program
{
static void Main(string[] args) {
ClasseChampPublic champPublic = new ClasseChampPublic();
ClasseChampPasPublic champNonPublic = new ClasseChampPasPublic(); Console.WriteLine(champPublic.nombre);
Console.WriteLine(champNonPublic.nombre);//Impossible, nombre n'est pas public!
} }
class ClasseChampPublic
{
public int nombre; }
class ClasseChampPasPublic
{
int nombre; }
Cela ne compilera pas à cause de la ligne numéro 8, en effet, on ne pourra pas accéder au champ "nombre" ainsi.
Privée
Une accessibilité privée est l'accéssibilité par défaut pour les champs, les classes et les méthodes. Lorsque nous ne mettons accessibilité devant un champ ou une méthode, ce champ ou cette méthode sera privée. Le mot clé pour une accessibilité privée est private. La classe suivante aura tout ses champs et toutes ses méthodes privées.
Code : C# - Sélectionner
class ClasseToutePrivee
{
private int nombre; private void DireBonjour() {
Console.WriteLine("Bonjour"); }
}
Le code donnerait exactement le même résultat sans les mot clé public, à vous de voir si vous préférez un code plus court ou un code plus explicite
Protégée
Une accessibilitée protégée sera presque identique à une accessibilité privée. La seule différente se fera lorsqu'une classe héritera d'une autre. En effet, une classe fille n'aura pas accès aux champs et méthodes privés mais aura accès aux champs et méthodes protégées. Sinon, en dehors de la classe mère et des classes filles, l’accessibilité sera identique à privée. Le mot clé pour une accessibilité protégée est protected. Observons le code suivant :
Code : C# - Sélectionner class Program
{
static void Main(string[] args) {
ClasseFille fille = new ClasseFille();
Console.WriteLine(fille.nombrePrive);//Impossible, nombrePrivee n'est pas public
Console.WriteLine(fille.nombreProtege);//Impossible, nombreProtege n'est pas public
} }
class ClasseMere
{
private int nombrePrive; protected int nombreProtege; }
class ClasseFille : ClasseMere {
public ClasseFille() {
nombreProtege = 5;//Possible, champ protégé provenant de la classe mere
} }
Nous voyons que depuis la classe Program, nous n'avons accès ni à "nombrePrive", ni à "nombreProtege", sur ce point une accessibilité publique ou privée reviens au même. Néanmoins, nous voyons que dans "ClasseFille" nous avons accès à "nombreProtegee" car ce champ provient de la classe mère et est signalé comme protégé.
L'encapsulation en pratique
Les accessibilités recommandées
Généralement en POO pour les champs on applique une règle simple : tout en privé! Et c'est d'ailleurs ce que quasiment tout développeur recommande (sauf parfois certains champs en protégés quand on n'a pas le choix).
Quant aux méthodes, on les déclare comme publiques, sauf bien sur pour les méthodes ne servant qu'aux traitements internes et n'ayant aucun intérêt d'être accessibles en dehors de la classe.
Code : C# - Sélectionner class Personnage
{
private string _nom; private int _age;
public Personnage(string nom, int age) {
this._nom = nom; this._age = age;
Console.WriteLine(GetIdentite() + " a été créé"); }
private string GetIdentite() {
return (_nom.ToString() + ", " + _age.ToString() + " ans"); }
public void SePresenter() {
Console.WriteLine("---"); Console.WriteLine("Bonjour, je suis " + GetIdentite()); Console.WriteLine("---"); }
}
La classe précédente est un cas typique d'utilisation des accessibilités publiques et privées : tout les champs sont privés, une méthode est publique, et une méthode privée a été créée pour éviter de dupliquer du code entre le constructeur et l'autre méthode. Ici, la méthode privée "GetIdentite" n'a pas vraiment d'intérêt à être publique, donc nous la laissons privée et nous l'utilisons uniquement pour la logique interne.
Accéder aux méthodes c'est bien. Mais comment faire si on veut accéder à des champs ?
La question est bonne, différentes manières peuvent être appliquées, nous allons les voir dans la partie suivante.
Accéder aux champs : accesseurs, mutateurs et propriétés
Pour accéder aux champs, comme je l'ai dis, plusieurs manières existent, l'une est plus spécifique au C# que les autres, néanmoins je nous allons voir la technique "plus générale" qui fonctionne tout aussi bien et qui sera applicable si vous apprenez un autre langage orienté objet.
Les accesseurs et les mutateurs
La première manière est assez simple, d'ailleurs je l'ai déjà utilisé sans le dire dans le premier chapitre sur la programmation orientée objet et certains auront peut être deviné comment faire tout seuls.
Nous allons tout simplement utiliser des méthodes publiques pour récupérer ou modifier nos champs! Une méthode dite "accesseur" qui ne prendra aucun paramètre et qui aura comme type de retour le type du champ à récupérer (par convention, le nom de cette méthode commencera par "Get" suivi du nom du champ) et une seconde méthode dite "mutateur" sans type de retour prenant en paramètre la nouvelle valeur à affecter (par convention son nom commencera par "Set" suivant du nom du champ). En ajoutant accesseurs et mutateurs à la classe précédente nous aurons le code suivant (pour plus de clarté, j'ai ajouté des "régions" permettant de délimiter les différentes parties du code):
class Personnage
{
#region Champs
private string _nom; private int _age; #endregion
#region Accesseurs/Mutateurs
public string GetNom() {
return _nom; }
public void SetNom(string nouveauNom) {
_nom = nouveauNom; }
public int GetAge() {
return _age; }
public void SetAge(int nouvelAge) {
_age = nouvelAge; }
#endregion
#region Constructeur
public Personnage(string nom, int age) {
this._nom = nom; this._age = age;
Console.WriteLine(GetIdentite() + " a été créé"); }
#endregion
#region Methodes
private string GetIdentite() {
return (_nom.ToString() + ", " + _age.ToString() + " ans"); }
public void SePresenter() {
Console.WriteLine("---"); Console.WriteLine("Bonjour, je suis " + GetIdentite()); Console.WriteLine("---"); }
#endregion
}
Mais attend, mettre un accesseur et un mutateur, cela revient au même que de mettre le champ en public mais en plus compliqué ?
Oui et non. Au premier abord on pourrait dire que cela revient au même, mais en réalité on contrôle plus l'accès aux champs de cette manière. Si nous voulions fournir un accès en lecture seule à _age et à _nom, nous enlèverions les mutateurs, ainsi la modification ne pourrait se faire qu'à l'intérieur de la classe. De même on pourrait rajouter des traitements à chaque accès ou à chaque modification, comme afficher un message.
Cela fait tout de même beaucoup de code pour pas grand chose, et on s'y perd un peu entre les accesseurs et mutateurs mêlés avec les autres méthodes. Il n'y a pas un moyen de faire plus simple ?
Justement, j'allais y venir. Cette manière passe par ce qu'on appelle les propriétés !!
Les propriétés
Les propriétés sont plus spécifiques au C# (mais existent peut être dans d'autres langages ). Elles vont être quelques chose entre un champ et une méthode. Par exemple :
Code : C# - Sélectionner private int _unChamp;
