Introduction aux techniques de base de la programmation avec le langage C#
![Introduction aux techniques de base de la programmation avec le langage C#](/images/remos_downloads/id-5616.5616.pdf_thumb_prev.jpg)
Programmer objet dans .Net Framework avec le langage C# version Orcas
757 pages de cours + 94 pages d’exercices corrigés
Rm di Scala
Mise à jour d’octobre 2007
Pour les mises à jour et les autres cours pdf du même auteur, consultez le site suivant :
SOMMAIRE
Types, opérateurs, instructions |
|
Introduction …………………………………..…. ………. |
P.3 |
Les outils élémentaires …………………………………..……… |
P.4 |
Les éléments de base .………………………………… ……. |
P.12 |
Les opérateurs + exemples .……………………………………. |
P.21 |
Les instructions .…………………………………….………. |
P.35 |
Les conditions .………………………………………………. |
P.40 |
Les itérations .………………. …………………………………. |
P.46 |
Les ruptures de séquence .……. ………………………………. |
P.50 |
Classes avec méthodes static ……….………………. ………… |
P.54 |
Structures de données de base |
|
Classe String …………………………………..…. |
P.73 |
Tableaux, matrices …………………………………..…. |
P.81 |
Collections, hash, piles, files, listes …….……………….. |
P.96 |
C# est orienté objet |
|
Classes, objets et méthodes …………………………………..…. |
P.125 |
Polymorphisme d'objet ……………….………………………..…. |
P.160 |
Polymorphisme de méthode ……………………..….…………..…. |
P.172 |
Polymorphisme d'interfaces ……………………………………..…. |
P.198 |
Classe de délégation ………………………….…………..…. |
P.223 |
Traitement des exceptions ………………………….…………..…. |
P.239 |
Processus et multi-threading ……………………….…………..…. |
P.263 |
IHM avec C# |
|
Programmation événementielle ……………………………..……. |
P.293 |
Les événements en C # ……………………………………………. |
P.317 |
Propriétés et indexeurs …….………………………………… … |
P.338 |
Fenêtres et ressources mémoires ……………..…………….…… |
P.366 |
Contrôles dans les formulaires ………………..……………… . |
P.405 |
Exceptions comparées à Delphi et java …………..…………….. ![]() |
P.429 |
Données simples flux et fichiers …………..……………………. P.433 |
|
Eléments principaux depuis la version C# 2.0 |
Les generics ……………………………………………..….……… P.466
Les classes partielles … ….…………………………………….….. P.476
Les méthodes anonymes ……………..……………………..…….. P.484
TAD de liste, pile, file et classes génériques …………….……..…… P.495
TAD d’arbre binaire et classes génériques …………….……..….… P.513
Principes des bases de données relationnelles ………………….. P.554 et données relationnelles …………..………………….. P.580
et SQL serveur 2005 …………..……………………….. P.593
Programmation web avec
Page web écrite uniquement avec des contrôles HTML simples ……… P.636
Page web écrite uniquement avec des contrôles serveurs……… ………P.649
Communication entre pages web………………………… …………… P.669
Page web et BD avec GridView…………………………. ……….………P.680
Cookie dans une page web …………………………. ……….……… …P.698
Annexes javascript ………………………….…….….……… .…P.710 Webservices …………………………. …………………..….……… …P.735
Bibliographie……………………………………………………….………….…..Exercices……………………………………………………………………….……..
94 pages d'exercices avec solutions
Pour pouvoir s’initier à C# avec ce cours et à peu de frais dans un premier temps, il faut télécharger gratuitement sur le site de CodeGear, l’environnement Borland studio Delphi 2006 édition personnelle, ou aller sur le site de Microsoft et télécharger gratuitement Visual C# express, ou bien utiliser la denière version de l'environnemnt open source Sharpdevelop qui fonctionne sous Net framework run-time..
Remerciements : (pour les corrections d'erreurs)
A tous ceux qui m'ont envoyé un petit mail me signalant une erreur, une omission …
A mon épouse Dominique pour son soutien et sa patience qui me permettent de consacrer de nombreuses heures à la construction du package et des cours inclus et surtout qui a eu la constance de relire entièrement toutes les pages de la version initiale de l'ouvrage, alors que l'informatique n'est pas sa tasse de thé.
A michel Veuillerot ex-Manager européen Information Technology and Telecom Architecture and Delivery Services chez Eastman Kodak, qui a relu attentivement la version précédente de l’ouvrage et testé tous les exemples.
Remerciements : (diffusion de la connaissance)
- • A l'université de Tours qui supporte et donne accès à la partie Internet du package pédagogique à partir de sa rubrique "cours en ligne", à partir duquel ce document a été élaboré.
- • Au club des développeurs francophones qui héberge gratuitement un site miroir du précédent et qui recommande le package pédagogique ( ) à ses visiteurs débutants.
Remerciements : (anticipés)
Aux lecteurs qui trouveront nécessairement encore des erreurs, des oublis, et autres imperfections et qui voudront bien les signaler à l’auteur afin d’améliorer le cours, e-mail :
Site de consultation et de téléchargement des autres ouvrages en pdf ( Bases de l'informatique, Java 2 ) :
Introduction à .Net
2001 par Microsoft, elle porte le nom de .NET (ou en anglais dot net). La conception de cette nouvelle architecture s'appuie sur quelques idées fondatrices que nous énonçons ci-dessous :
? Une disparition progressive des différences entre les applications et l'Internet, les serveurs ne fourniront plus seulement des pages HTML, mais des services à des applications distantes.
? Les informations au lieu de rester concentrées sur un seul serveur pourront être réparties sur plusieurs machines qui proposeront chacune un service adapté aux informations qu'elles détiennent.
? A la place d'une seule application, l'utilisateur aura accès à une fédération d'applications distantes ou locales capables de coopérer entre elles pour divers usages de traitement.
? L'utilisateur n'aurait plus la nécessité d'acheter un logiciel, il louerait plutôt les services d'une action spécifique.
? Le micro-ordinateur reste l'intermédiaire incontournable de cette stratégie, il dispose en plus de la capacité de terminal intelligent pour consulter et traiter les informations de l'utilisateur à travers Internet où qu'elles se trouvent.
? Offrir aux développeurs d'applications .NET un vaste ensemble de composants afin de faire de la programmation par composant unifiée au sens des protocoles (comme l’utilisation du protocole SOAP) et diversifiée quant aux lieux où se trouvent les composants.
Afin de mettre en place cette nouvelle stratégie, microsoft procède par étapes. Les fondations de l'architecture .NET sont posées par l'introduction d'un environnement de développement et d'exécution des applications .NET. Cet environnement en version stabilisée depuis 2002 avec une révision majeure en 2005, porte la dénomination de .NET Framework, il est distribué gratuitement par microsoft sur toutes les versions de Windows (98, Me, , Xp, ). La dernière version de .NET Framework est directement intégrée à Windows Vista.
L'outil Visual Studio .NET contient l'environnement RAD de développement pour l'architecture .NET. Visual Studio .NET permet le développement d'applications classiques Windows ou Internet.
Les versions gratuites soit "Express" de Microsoft, soit l'environnement complet enversion professionnelle de Visual Studio .NET, soit sharpDevelop de l'open source démocratisent les outils de programmation.
Les outils élémentaires
- La plate forme .NET Framework
Elle comporte plusieurs couches les unes abstraites, les autres en code exécutable :
La première couche CLS est composée des spécifications communes à tous les langages qui veulent produire des applications .NET qui soient exécutables dans cet environnement et les langages eux-même. Le CLS est une sorte de sous-ensemble minimal de spécifications autorisant une interopérabilité complète entre tous les langages de .NET les règles minimales (il y en a en fait 41 ) sont :
- • Les langages de ..NET doivent savoir utiliser tous les composants du CLS
- • Les langages de .NET peuvent construire de nouvelles classes, de nouveaux composants conformes au CLS
Le C# est le langage de base de .NET, il correspond à une synthèse entre Delphi et Java (le concepteur principal de .NET. et de C# est l'ancien chef de projet Turbo pascal puis Delphi de Borland).
Afin de rendre Visual Basic interopérable sur .NET, il a été entièrement reconstruit par microsoft et devient un langage orienté objet dénommé VB.NET.
La seconde couche est un ensemble de composants graphiques disponibles dans Visual Studio .NET qui permettent de construire des interfaces homme-machine orientées Web (services Web) ou bien orientées applications classiques avec IHM.
Les données sont accédées dans le cas des services Web à travers les protocoles qui sont des standards de l'industrie : HTTP, XML et SOAP.
Toutes ces classes sont accessibles telles quelles à tous les langages de .NET et cette librairie peut être étendue par adjonction de nouvelles classes. Cette librairie a la même fonction que la bibliothèque des classes de Java.
La librairie de classe de .NET Framework est organisée en nom d'espace hierarchisés, exemple ci-dessous de quelques espaces de nom de la hiérarchie System :
Un nom complet de classe comporte le "chemin" hiérarchique de son espace de nom et se termine par le nom de la classe exemples :
- • La classe DataSet qui se trouve dans l'espace de noms "" se déclare comme ".Dataset".
- • La classe Console qui se trouve dans l'espace de noms "System" se déclare comme "System.Console".
- • La classe DataAdapter qui se trouve dans l'espace de noms ".Common " se déclare comme ".Common.DataAdapter ".
La quatrième couche forme l'environnement d'exécution commun (CLR ou Common Language Runtime) de tous les programmes s'exécutant dans l'environnement .NET. Le CLR exécute un bytecode écrit dans un langage intermédiaire (MSIL ou MicroSoft Intermediate Language)
Rappelons qu'un ordinateur ne sait exécuter que des programmes écrits en instructions machines compréhensibles par son processeur central. C# comme pascal, C etc fait partie de la famille des langages évolués (ou langages de haut niveau) qui ne sont pas compréhensibles immédiatement par le processeur de l'ordinateur. Il est donc nécesaire d'effectuer une "traduction" d'un programme écrit en langage évolué afin que le processeur puisse l'exécuter.
Les deux voies utilisées pour exécuter un programme évolué sont la compilation ou l'interprétation :
Uncompilateurdu langage X pour un processeur P, est un logiciel quitraduitun programme source écrit en X en unprogramme cibleécrit en instructions machines exécutables par le processeur P.
Uninterpréteurdu langage X pour le processeur P, est un logiciel qui ne produit pas de programme cible mais quieffectue lui-mêmeimmédiatement les opérations spécifiées par le programme source.
Un compromis assurant la portabilité d'un langage : une pseudo-machine
Lorsque le processeur P n'est pas une machine qui existe physiquement mais un logiciel simulant (ou interprétant) une machine on appelle cette machinepseudomachineoup-machine. Le programme source est alors traduit par le compilateur eninstructions de la pseudo-machineet se dénommepseudo-code. La p-machine standard peut ainsi être implantée dans n'importe quel ordinateur physique à travers un logiciel qui simule son comportement; un tel logiciel est appeléinterpréteur de la p-machine.
La première p-machine d'un langage évolué a été construite pour le langage pascal assurant ainsi une large diffusion de ce langage et de sa version UCSD dans la mesure où le seul effort d'implementation pour un ordinateur donné était d'écrire l'interpréteur de p-machine pascal, le reste de l'environnement de développement (éditeurs, compilateurs, ) étant écrit en pascal était fourni et fonctionnait dès que la p-machine était opérationnelle sur la plate-forme cible.
Donc dans le cas d'unep-machineleprogramme source est compilé, mais le programme cible estexécuté par l'interpréteurde lap-machine.
Beaucoup de langages possèdent pour une plate-forme fixée des interpréteurs ou des compilateurs, moins possèdent une p-machine, Java de Sun est l'un de ces langages. Tous les langages de la plateforme .NET fonctionnent selon ce principe, C# conçu par microsoft en est le dernier, un programme C# compilé en p-code, s'exécute sur la p-machine virtuelle incluse dans le CLR.
![](/images/remos_downloads/detail/56/id-5616.5616.pdf-064.jpg)
Nous décrivons ci-dessous le mode opératoire en C#.
Compilation native
La compilation native consiste en la traduction du source C# (éventuellement préalablement traduit instantanément en code intermédiare) en langage binaire exécutable sur la plate-forme concernée. Ce genre de compilation est équivalent à n'importe quelle compilation d'un langage dépendant de la plate-forme, l'avantage est la rapidité d'exécution des instructions machines par le processeur central.La stratégie de développement multi-plateforme de .Net, fait que Microsoft ne fournit pas pour l’instant, de compilateur C# natif, il faut aller voir sur le net les entreprises vendant ce type de produit.
Programe source C# : xxx.cs
Programe exécutable sous Windows : xxx.exe (code natif processeur)
Bytecode ou langage intermédiaire
La compilation en bytecode (ou pseudo-code ou p-code ou code intermédiaire) est semblable à l'idée du p-code de N.Wirth pour obtenir un portage multi plate-formes du pascal. Le compilateur C# de .NET Framework traduit le programme source xxx.cs en un code intermédiaire indépendant de toute machine physique et non exécutable directement, le fichier obtenu se dénomme PE (portable executable) et prend la forme : xxx.exe.
Seule une p-machine (dénommée machine virtuelle .NET) est capable d'exécuter ce bytecode. Le bytecode est aussi dénommé MSIL. En fait le bytecode MSIL est pris en charge par le CLR et n'est pas interprété par celui-ci mais traduit en code natif du processeur et exécuté par le processeur sous contrôle du CLR..
ATTENTION
Bien que se terminant par le suffixe exe, un programme issu d'une compilation sous .NET n'est pas un exécutable en code natif, mais un bytecode en MSIL; ce qui veut dire que vous ne pourrez pas faire exécuter directement sur un ordinateur qui n'aurait pas la machine virtuelle .NET, un programme PE "xxx.exe" ainsi construit.
Ci-dessous le schéma d'un programme source traduit par le compilateur C# sous .NET en un programme cible écrit en bytecode nommé
Programe source C# : Exemple.cs
Programe exécutable sous .NET : Exemple.exe (code portable IL)
2. L'environnement d'exécution du CLR
Rappelons que le CLR (Common Language Runtime) est un environnement complet d'exécution semblable au JRE de Sun pour Java, il est indépendant de l'architecture machine sous-jacente. Le CLR prend en charge essentiellement :
- • le chargement des classes,
- • les vérifications de types,
- • la gestion de la mémoire, des exceptions, de la sécurité,
- • la traduction à la volée du code MSIL en code natif (compilateur interne JIT),
- • à travers le CTS (Common Type System) qui implémente le CLS (Common Language Specification), le CLR assure la sécurité de compatibilité des types connus mais syntaxiquement différents selon les langages utilisés.
Une fois le programme source C# traduit en bytecode MSIL, la machine virtuelle du CLR se charge de l'exécuter sur la machine physique à travers son système d'exploitation (Windows, Unix, )
Le CLR intégré dans l'environnement .NET est distribué gratuitement.
La compilation JIT progressive
L'interprétation et l'exécution du bytecode ligne par ligne pourrait prendre beaucoup de temps et cela a été semble-t-il le souci de microsoft qui a adopté une stratégie d'optimisation de la vitesse d'exécution du code MSIL en utilisant la technique Just-in-time.
JIT(Just-in-time) est une technique de traduction dynamique durant l'interprétation. La machine virtuelle CLR contient un compilateur optimiseur qui recompile localement le bytecode MSIL afin de n'avoir plus qu'à faire exécuter des instructions machines de base. Le compilateur JIT du CLR compile une méthode en code natif dès qu'elle est appelée dans le code MSIL, le processus recommence à chaque fois qu'un appel de méthode a lieu sur une méthode non déjà compilée en code natif.
On peut mentalement considérer qu'avec cette technique vous obtenez un programme C# cible compilé en deux passages :
- • le premier passage est dû à l'utilisation du compilateur C# produisant exécutable portable ( PE ) en bytecode MSIL,
- • le second passage étant le compilateur JIT lui-même qui optimise et traduit localement à la volée et à chaque appel de méthode, le bytecode MSIL en instructions du processeur de la plate-forme. Ce qui donne au bout d'un temps très bref, un code totalement traduit en instruction du processeur de la plateforme, selon le schéma ci-après :
La compilation AOT
Toujours à des fins d'optimisation de la vitesse d'exécution du code MSIL, la technique AOTAhead-Of-Time est employée dans les versions récentes de .Net depuis 2005.
AOT(ahead-of-time) est une technique de compilation locale detoutle bytecode MSIL avant exécution (semblable à la compilation native). Le compilateur AOT du CLR compile, avant une quelconque exécution et en une seule fois, toutes les lignes de code MSIL et génère des images d’exécutables à destination du CLR.
Les éléments de base
Tout est objet dans C#, en outre C# est un langage fortement typé. Comme en Delphi et en Java vous devez déclarer un objet C# ou une variable C# avec son type avant de l'utiliser. C# dispose de types valeurs intrinsèques qui sont définis à partir des types de base du CLS (Common Language Specification).
- Les types valeurs du CLS dans .NET Framework
Struct
Les classes encapsulant les types élémentaires dans .NET Framework sont des classes de type valeur du genre structures. Dans le CLS une classe de type valeur est telle que les allocations d'objets de cette classe se font directement dans la pile et non dans le tas, il n'y a donc pas de référence pour un objet de type valeur et lorsqu'un objet de type valeur est passé comme paramètre il est passé par valeur.
Dans .NET Framework les classes-structures de type valeur sont déclarées comme structures et ne sont pas dérivables, les classes de type référence sont déclarées comme des classes classiques et sont dérivables.
Afin d'éclairer le lecteur prenons par exemple un objet x instancié à partir d'une classe de type référence et un objet y instancié à partir d'un classe de type valeur contenant les mêmes membres que la classe par référence. Ci-dessous le schéma d'allocation de chacun des deux objets :
En C# on aurait le genre de syntaxe suivant :
Déclaration de classe-structure : struct StructAmoi { int b; void meth(int a){ b = 1000+a; } } |
instanciation : StructAmoi y = new StructAmoi ( ) ; |
Déclaration de classe : class ClassAmoi { int b; void meth(int a) { b = 1000+a; } } |
instanciation : ClassAmoi x = new ClassAmoi ( ) ; |
Les classes-structures de type valeur peuvent comme les autres classes posséder un constructeur explicite, qui comme pour toute classe C# doit porter le même nom que celui de la classestructure.
Exemple ci-desssous d'une classe-structure dénommée Menulang:
public struct Menulang { public String MenuTexte; public String Filtre; public Menulang(String M, String s) { MenuTexte = M; Filtre = s; } } |
On instancie alors un objet de type valeur comme un objet de type référence.
En reprenant l'exemple de la classe précédente on instancie et on utilise un objet Rec :
Menulang Rec = newMenulang ( Nomlang , FiltreLang );
Rec.MenuTexte = "Entrez" ;
![](/images/remos_downloads/detail/56/id-5616.5616.pdf-067.jpg)
Rec.Filtre = "*.ent" ;
Classe-structure |
intervalle de variation |
nombre de bits |
Boolean |
false , true |
1 bit |
SByte |
octet signé -128 +127 |
8 bits |
Byte |
octet non signé 0 255 |
8 bits |
Char |
caractères unicode (valeurs de 0 à 65535) |
16 bits |
Double |
Virgule flottante double précision ~ 15 décimales |
64 bits |
Single |
Virgule flottante simple précision ~ 7 décimales |
32 bits |
Int16 |
entier signé court [ -215 +215-1 ] |
16 bits |
Int32 |
entier signé [ -231 +231-1 ] |
32 bits |
Int64 |
entier signé long [ -263 +263-1 ] |
64 bits |
UInt16 |
entier non signé court 0…216-1 |
16 bits |
UInt32 |
entier non signé 0…232 -1 |
32 bits |
UInt64 |
entier non signé long 0…264-1 |
64 bits |
Decimal |
réeel = entier* 10n (au maximum 28 décimales exactes) |
128 bits |
Compatibilité des types de .NET Framework
Le type System.Int32 est le type valeur entier signé sur 32 bits dans le CLS. Voici selon 4 langages de .NET Framework ( VB, C#, C++, J# ) la déclaration syntaxique du type Int32 : [Visual Basic] Public Structure Int32 Implements IComparable, IFormattable, IConvertible [C#] public struct Int32 : IComparable, IFormattable, IConvertible [C++] public__valuestruct Int32 : public IComparable, IFormattable, IConvertible [J#] public class Int32 extends System.ValueType implements System.IComparable, System.IFormattable, System.IConvertible |
Les trois premières déclarations comportent syntaxiquement le mot clef struct ou Structure indiquant le mode de gestion par valeur donc sur la pile des objets de ce type. La dernière déclaration en J# compatible syntaxiquement avec Java, utilise une classe qui par contre gère ses objets par référence dans le tas. C'est le CLR qui va se charger de maintenir une cohérence interne entre ces différentes variantes; ici on peut raisonnablement supposer que grâce au mécanisme d'emboîtage (Boxing) le CLR allouera un objet par référence encapsulant l'objet par valeur, mais cet objet encapsulé sera marqué comme objet-valeur.
![](/images/remos_downloads/detail/56/id-5616.5616.pdf-072.jpg)
enum
Un type enum est un type valeur qui permet de déclarer un ensemble de constantes de base comme en pascal. En C#, chaque énumération de type enum, possède un type sous-jacent, qui peut être de n'importe quel type entier : byte, sbyte, short, ushort, int, uint, long ou ulong.
Le type int est le type sous-jacent par défaut des éléments de l'énumération. Par défaut, le premier énumérateur a la valeur 0, et l'énumérateur de rang n a la valeur n-1.
Soit par exemple un type énuméré jour :
enum jour { lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche} par défaut : rang de lundi=0, rang de mardi=1, , rang de dimanche=6
1°) Il est possible de déclarer classiquement une variable du type jour comme un objet de type jour, de l'instancier et de l'affecter :
jour unJour = new jour ( ); unJour = jour.lundi ; int rang = (int)unJour; // rang de la constante dans le type énuméré System.Console.WriteLine("unJour = "+unJour.ToString()+" , place = '+rang); Résultat de ces 3 lignes de code affiché sur la console : unJour = lundi , place = 0 |
2°) Il est possible de déclarer d'une manière plus courte la même variable du type jour et de l'affecter :
jour unJour ; unJour = jour.lundi ; int rang = (int)unJour; System.Console.WriteLine("unJour = "+unJour.ToString()+" , place = '+rang); Résultat de ces 3 lignes de code affiché sur la console : unJour = lundi , place = 0 |
Remarque
C# accepte que des énumérations aient des noms de constantes d'énumérations identiques :
enum jour { lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche} enum weekEnd { vendredi, samedi, dimanche}
Dans cette éventualité faire attention, la comparaison de deux variables de deux types différents, affectées chacune à une valeur de constante identique dans les deux types, ne conduit pas à l'égalité de ces variables (c'est en fait le rang dans le type énuméré qui est testé). L'exemple ci-dessous illustre cette remarque :
enum jour { lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche} enum weekEnd { vendredi, samedi, dimanche} jour unJour ; weekEnd repos ; unJour = jour.samedi ; repos = weekEnd.samedi; if ( (jour)repos == unJour ) // il faut transtyper l'un des deux si l'on veut les comparer System.Console.WriteLine("Le même jour"); else System.Console.WriteLine("Jours différents"); Résultat de ces lignes de code affiché sur la console : Jours différents |
2. Syntaxe des types valeurs de C# et transtypage
Les types servent à déterminer la nature du contenu d'une variable, du résultat d'une opération, d'un retour de résultat de fonction.
Ci-dessous le tableau de correspondance syntaxique entre les types élémentaires du C# et les classes de .NET Framework (table appelée aussi, table des alias) :
Types valeurs C# |
Classe-structure de .NET Framework |
nombre de bits |
bool |
Boolean |
1 bit |
sbyte |
SByte |
8 bits |
byte |
Byte |
8 bits |
char |
Char |
16 bits |
double |
Double |
64 bits |
float |
Single |
32 bits |
short |
Int16 |
16 bits |
int |
Int32 |
32 bits |
long |
Int64 |
64 bits |
ushort ![]() |
UInt16 |
16 bits |
uint |
UInt32 |
32 bits |
ulong |
UInt64 |
64 bits |
decimal |
Decimal |
128 bits |
Rappelons qu'en C# toute variable qui sert de conteneur à une valeur d'un type élémentaire précis doit préalablement avoir été déclarée sous ce type.
Remarque importante
Unevariable de type élémentaireen C# est (pour des raisons de compatibilité CLS) automatiquement unobjet de type valeur(Par exemple une variable de typefloatpeut être considérée comme un objet de classeSingle).
Il est possible d'indiquer au compilateur le type d'une valeur numérique en utilisant un suffixe :
• |
l ou L pour désigner un entier du type long |
• |
f ou F pour désigner un réel du type float |
• |
d ou D pour désigner un réel du type double |
• |
m ou M pour désigner un réel du type decimal |
Exemples :
45l ou 45Lreprésente la valeur 45 en entier signé sur 64 bits.
45f ou 45Freprésente la valeur 45 en virgule flottante simple précision sur 32 bits.
45d ou 45Dreprésente la valeur 45 en virgule flottante double précision sur 64 bits.
5.27e-2f ou 5.27e-2Freprésente la valeur 0.0527 en virgule flottante simple précision sur 32 bits.
Transtypage opérateur ( )
Les conversions de type en C# sont identiques pour les types numériques aux conversions utilisées dans un langage fortement typé comme Delphi par exemple. Toutefois C# pratique la conversion implicite lorsque celle-ci est possible. Si vous voulez malgré tout, convertir explicitement une valeur immédiate ou une valeur contenue dans une variable il faut utiliser l'opérateur de transtypage noté ( ). Nous nous sommes déjà servi de la fonctionnalité de transtypage explicite au paragraphe précédent dans l'instruction : int rang = (int)unJour; et dans l'instruction if ( (jour)repos == unJour )
Transtypage implicite en C# :
- • int n = 1234;
- • float x1 = n ;
- • double x2 = n ;
- • double x3 = x1 ;
- • long p = n ;
..
Transtypage explicite en C# :
int x; x = (int) y ; signifie que vous demandez de transtyper la valeur contenue dans la variable y en un entier signé 32 bits avant de la mettre dans la variable x.
- • Tous les types élémentaires peuvent être transtypés à l'exception du type bool qui ne peut pas être converti en un autre type (différence avec le C).
- • Les conversions peuvent être restrictives quant au résultat; par exemple le transtypage du réel 5.27e-2 en entier ( x = (int)5.27e-2) mettra l'entier zéro dans x.
3. Variables, valeurs, constantes en C#
Comme en Java, une variable C# peut contenir soit une valeur d'un type élémentaire, soit une référence à un objet. Les variables jouent le même rôle que dans les langages de programmation classiques impératifs, leur visibilité est étudiée dans le prochain chapitre.
Les identificateurs de variables en C# se décrivent comme ceux de tous les langages de programmation :
Identificateur C# :
Attention C# fait une différence entre majuscules et minuscules, c'est à dire que la variable BonJour n'est pas la même que la variable bonjour ou encore la variable Bonjour. En plus des lettres, les caractères suivants sont autorisés pour construire une identificateur C# : "$" , "_" , "µ" et les lettres accentuées.
Exemples de déclaration de variables :
int Bonjour ; int µEnumération_fin$;
float Valeur ; char UnCar ; bool Test ; etc
Exemples d'affectation de valeurs à ces variables :
Affectation |
Déclaration avec initialisation |
Bonjour = 2587 ; Valeur = -123.5687 UnCar = 'K' ; Test = false ; |
int Bonjour = 2587 ; float Valeur = -123.5687 char UnCar = 'K' ; bool Test = false ; |
Exemple avec transtypage :
int Valeur ; char car = '8' ;
Valeur = (int)car - (int)'0';
fonctionnement de l'exemple :
Lorsque la variable car est l'un des caractères '0', '1', ,'9', la variable Valeur est égale à la valeur numérique associée (il s'agit d'une conversion car = '0' ---> Valeur = 0, car = '1' ---> Valeur = 1, , car = '9' ---> Valeur = 9).