CSharp Base PDF

Notions fondamentales du
langage C#
Version 1.0
Z
2 [Notions fondamentales du langage Csharp] [Date : 25/03/09]
Sommaire
1 Tout ce quil faut savoir pour bien commencer ................................................... 3

1.1 Quest ce quun langage de programmation ? ........................................................................ 3
1.1.1 Introduction ..................................................................................................................... 3
1.1.2 Ncessit dun langage intermdiaire ............................................................................. 3
1.2 Introduction la programmation oriente objet .................................................................... 4
1.2.1 Les diffrences avec un langage procdural ................................................................... 4
1.2.2 Les avantages de la programmation oriente objet ....................................................... 4
1.3 Prsentation du Framework .Net ........................................................................................... 4
1.3.1 Introduction ..................................................................................................................... 4
1.3.2 Le Common Language Specification et le Common Language Runtime. ........................ 5
1.4 Quest ce que le C# .................................................................................................................. 6
1.4.1 Un langage simple et performant pour .NET................................................................... 6
2 Les bases du C# ................................................................................................................. 7

2.1 Environnement de dveloppement ........................................................................................ 7
2.1.1 Installation de Visual studio 2008 ................................................................................... 7
2.1.2 Cration dun projet C# ................................................................................................... 7
2.2 Les bases de la programmation C# ......................................................................................... 9
2.2.1 Les pr-requis .................................................................................................................. 9
2.2.2 Variables ........................................................................................................................ 11
2.2.3 Oprateurs..................................................................................................................... 14
2.2.4 Les conditions ................................................................................................................ 20
2.2.5 Les boucles .................................................................................................................... 22
3 Conclusion ........................................................................................................................ 25
Dotnet France Association

1 Tout ce quil faut savoir pour bien commencer

Dans cette premire partie, nous allons prsenter les concepts de base quil faut connaitre pour
apprendre programmer et aussi introduire la plateforme .NET. Ce sont des concepts simples mais
fondamentaux. videmment, les personnes ayant dj des notions avances de programmation ne
verront ici rien de bien savant et pourront passer directement la partie consacre lapprentissage
du langage C# (prononcez ci-sharpe).
1.1 Quest ce quun langage de programmation ?

1.1.1 Introduction
Nous, humains, communiquons avec un langage complexe. En effet, notre langage est
compos de phrases, construites avec des mots qui sont eux-mmes constitus de diffrentes
lettres. Mais malheureusement pour nous, les ordinateurs, eux, ne comprennent que des 1 et des 0.
Le problme est donc de savoir comment nous allons faire pour pouvoir communiquer avec eux, car
notre but final est tout de mme de programmer lordinateur afin dobtenir ce que nous voulons de
lui. Tout cela en gardant lesprit que programmer en binaire nest pas une alternative envisageable.
1.1.2 Ncessit dun langage intermdiaire

Cest donc pour cette raison que lon a invent le langage de programmation :
afin de pouvoir communiquer avec la machine dans un langage un temps soit peu Langage
comprhensible par lhumain, ce qui nest de toute vidence pas le cas du humain
langage binaire. Le langage de programmation est
Langage de
donc un langage mi-chemin entre notre langage et celui de lordinateur. programmation
Grossirement, Cest un langage qui est comprhensible la fois par
lhomme et par le processeur de la machine. Langage binaire
010100101010010101
Une fois notre code crit en langage de programmation, un logiciel appel compilateur va se
charger de le traduire en langage binaire comme indiqu sur le schma ci-dessous.
Langage de programmation
Compilateur
Code binaire
Le compilateur est une sorte de traducteur langage de programmation binaire.

1.2 Introduction la programmation oriente objet

1.2.1 Les diffrences avec un langage procdural
Avant dintroduire quelque diffrence que ce soit, nous allons dabord dfinir ce quest un
langage procdural. Un langage procdural est, comme son nom lindique, un langage compos de
procdures. Une procdure est ce qui va permettre au programme de traiter une suite
dinformations, c'est--dire quon lui envoie simplement une instruction quil se doit dexcuter. Dans
un programme, une procdure na pas de place prdfinie, donc une mme procdure peut tre en
dbut, en milieu, en fin de programme, ou les trois la fois. Le C#, lui, nest pas un langage
procdural, mais un langage de programmation orient objet, souvent abrg en POO . Nous
allons voir ce quest cette notion.
Tout dabord de quoi parle-t-on lorsque lon parle dobjet ?
Un objet est en fait une structure de donnes, cest-a-dire une structure qui sert contenir des
donnes pour faire de leur traitement un acte plus simple.
A quoi cela sert-il ?
On a vu prcdemment ce quest un objet. Cet objet contient lintrieur de lui du code. Ce code va
contenir tout ce qui est fonctions et variables voulues. On va donc pouvoir se servir dun objet, ce
qui est relativement simple, pour utiliser un code complexe. La principale diffrence entre ces deux
mthodes de programmation est que lorsque lon utilise un langage procdural, le programmeur doit
tout coder, alors que lorsque lon utilise un langage orient objet, le programmeur peut utiliser des
objets afin de rendre son code moins lourd et plus facile programmer. Il y a un gain de temps et de
simplicit dans cette approche.
1.2.2 Les avantages de la programmation oriente objet

Le but de la POO est avant tout de rendre la programmation complexe plus facile. Cest--
dire, dans un sens, la rendre plus familire lHomme. Cependant, que connat et par quoi est
entour particulirement lHomme : des objets. Cest pourquoi la POO nous aide, concrtise
certaines notions qui seraient difficiles coder en langage procdural. Prenons par exemple la
modlisation dune voiture. Dans un langage procdural, le programmeur va devoir utiliser des outils
abstraits. Alors quen POO, le programmeur pourra faire un objet "voiture" et lui donner ses
caractristiques, un objet "roue" par exemple, ainsi de suite, ce qui rend la programmation plus
simple et surtout plus instinctive.
Ceci est un avantage non ngligeable dans le monde de la programmation, qui permet donc un gain
de temps, de comprhension mais aussi defficacit.
1.3 Prsentation du Framework .Net

Ici nous allons voir ce quest la plateforme .NET. Nous commenceront par un bref historique
puis nous rentreront dans le vif du sujet en nous intressant son mode de fonctionnement.
1.3.1 Introduction
Nous sommes aujourdhui la version 3.5 du Framework .NET (et bientt 4.0). La premire
version exploitable de celui-ci est sortie en 2002 et celle-ci na pas cess dvoluer de mme que son
environnement de programmation ddi : Visual Studio. En effet la version 1 .1 est sortie en 2003
puis la 2.0 en 2005 la 3.0 en 2006 et la version actuelle 3.5 sortie en 2007. Chaque mise jour
apportant dimportantes nouveauts et amliorations.
Nativement, la plate-forme .NET fut cre pour Windows, mais celle-ci est dsormais portable sur des
systmes Linux ou Unix, grce un projet intitul MONO.

Le Framework .NET regroupe un ensemble doutils pour le programmeur. En effet les technologies
.Net vont nous permettre de programmer autant des applications console et WindowsForm que des
services Web, des applications Windows mobile et bien dautres.
Un des avantages du Framework .Net, cest quil est multi-langages. C'est--dire que lon va pouvoir
programmer en VB.NET, en C#, en C++, en J# et aussi en dautres langages compatibles. Nous allons
voir comment larchitecture du Framework va nous permettre cela.
1.3.2 Le Common Language Specification et le Common Language Runtime.

Nous allons voir ici le
fonctionnement de la plateforme
.NET grce un schma simple.
Pour commencer on code dans
un langage compatible .NET. La
Common Language Specification
(CLS) soccupe, elle, de la
compatibilit de chaque langage
avec le Framework de sorte
quen codant avec nimporte quel
langage compatible, on aboutisse
au mme code intermdiaire.
Chaque langage est donc compil
par son compilateur associ pour
aboutir un code intermdiaire :
le MicroSoft Intermediate
Language (MSIL).
Cette caractristique est typique
du Framework.NET, et elle nest
pas l par hasard. Bien
videmment, cette compatibilit
multi-langages vise faciliter la
migration dun langage de
dveloppement spcifique vers
la plateforme .Net (exemple du
Visual Basic et le VB.Net). Le
processus de compilation est
assez semblable au fonctionnement du langage JAVA. Notre code source est Pr compil dans un
langage intermdiaire et celui-ci sera interprt lors de lexcution par une machine virtuelle qui le
traduira en code natif.
Cette machine virtuelle dans le Framework .Net, cest la Common Language Runtime (CLR).
La CLR a deux grandes fonctions : dabord, elle soccupe de linterprtation du code la vole. C'est-
-dire quelle va compiler le code MSIL en fonctions des besoins ce qui optimise les performances.
Cela sappelle la compilation Just in Time ou JIT . Grce cette mthode on va uniquement
compiler du code utile . Et ensuite la Common Language Runtime va grer la mmoire.

1.4 Quest ce que le C#

1.4.1 Un langage simple et performant pour .NET
est le langage par excellence de .Net, apparu en 2001. Ce langage est comme dit
prcdemment un langage de programmation oriente objet, tant un carrefour entre
diffrent langage comme le Java, le C++ ou encore le Visual Basic, tout en restant un langage part.
Cest un langage typage fort, cest dire que le type des variables est fix la compilation et que
celle-ci peut vrifier les erreurs de typage ( la diffrence du langage PHP par exemple). Le C Sharp
est trs polyvalent, Il permet de coder de simples applications consoles jusqu de gros programmes
avec une multitude de fentres, en passant par les jeux.
Souvent, le langage C# a t compar au java, pour qui, tout comme le C#, tout est objet.
Cependant, le langage de .NET, de part ses amlioration au fur et mesure de son existence, a su se
forger son propre profil. En effet depuis sa parution, on est pass de la version 2.0 2.5, de 2.5 3.0
et enfin de la version 3.0 3.5, ayant dans chaque volution bien entendu son nombre de
nouveauts. De nouveaux mots cls sont ajouts, de nouvelles sortes de classes et certaines syntaxes
simplifies Cest donc au fil des annes que ce langage devint de plus en plus efficace et plus facile
daccs que beaucoup dautres langages orients objet, ce qui fait aujourdhui sa popularit.

2 Les bases du C#
2.1 Environnement de dveloppement

Microsoft Visual studio 2008 est lenvironnement de dveloppement ddi la plateforme
.NET, son utilisation est donc ici plus que vivement conseille. Toutefois les codes de C# prsents
ici pourront galement tre crits au bloc-notes puis compils par un compilateur C# en lignes de
commande.
2.1.1 Installation de Visual studio 2008

Linstallation du logiciel Visual studio 2008 est toute simple, slectionnez le premier lien sur
la premire fentre dinstallation et suivez les diffrentes tapes.
2.1.2 Cration dun projet C#

Nous allons crer ici notre premier projet C# avec notre premire application console. Lancer
Visual Studio 2008 et dans le menu suprieur allez dans : File/New/Project comme indiqu sur la
capture dcran ci-dessous.

Puis, dans la fentre qui souvre, on va choisir Visual C# dans le menu droulant et Console
Application et donner un nom notre projet.

Si tout sest bien pass, vous devriez avoir un code qui ressemble a :
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace DotnetFrance
{
class Program
{
static void Main(string[] args)
{
}
}
}
A prsent, direction ltape suivante pour comprendre un peu tout .
2.2 Les bases de la programmation C#

2.2.1 Les pr-requis
2.2.1.1 La structure de base

Nous allons tout dabord voir la structure de notre code de base. Le mot cl using est
une directive qui indique avec quel espace de noms nous allons travailler, cest peut tre un peu flou
pour le moment mais vous allez rapidement voir son utilit dans un exemple. Le mot cl
namespace dfini lui un espace de nom facultatif. Ceci est essentiel comprendre car cest afin
de mieux organiser le code. Nous avons ensuite la classe Program qui est le cur de notre
programme. static void Main indique notre mthode principale, cest la que lon va placer notre
code source, cest le code plac dans cette partie qui sera excut en premier.
Voyons alors larchitecture gnrique :
//C#
using <notre espace de noms>
namespace <espace de noms facultatif>

{
class Program
{
{
//Notre code source principal sera plac ici.
}
}
}
Nous allons maintenant excuter notre premier programme.
2.2.1.2 Afficher un message dans la console

La commande System.Console.WriteLine(" ") permet dafficher un message
dans la Console.

Excutez ce code dans Visual Studio (F5 pour excuter).
//C#
class Program
{
{
System.Console.WriteLine("Bienvenue sur Dotnet-France!!!");
}
}
Il ne se passe rien ? La console apparait et disparat instantanment ? Ne vous inquitez pas

cest tout fait normal car le code sexcute, le message saffiche bien mais le programme se ferme
car aucune instruction ne lui demande de se mettre en pause. Nous allons donc rajouter une
instruction qui attend une entre utilisateur. Cette instruction va mettre notre programme en
pause attendant une entre, ce qui va nous permettre de voir le message safficher.
2.2.1.3 Attendre une entre utilisateur

La commande qui permet de rcuprer une entre au clavier est :
System.Console.ReadLine();
Ajouter-la en fin de code comme ceci puis excutez :
//C#
class Program
{
{
System.Console.WriteLine("Bienvenue sur Dotnet-France!!!");
System.Console.ReadLine();
}
}
Ici, la chane de caractre rcupre par System.Console.ReadLine(); nest stocke

dans aucune variable. Cette fonction aura donc le rle de mettre le programme en pause.
Voil ! Nous avons prsent tout le temps de contempler notre message.
Bienvenue sur Dotnet-France !!!
2.2.1.4 La directive using

Nous allons maintenant voir lutilit de la directive using. Le mot cl using va nous
permettre de ne pas rcrire chaque fois le chemin entier des commandes. Dans lexemple, on
utilisait System. devant nos commandes. A prsent nous allons insrer using System; au
dbut de notre programme comme ceci :

//C#
using System;
class Program
{
{
Console.WriteLine("Bienvenue sur Dotnet-France!!!");
Console.ReadKey();
}
}
Cela nous permet dcrie Console.WriteLine au lieu de

System.Console.WriteLine ce qui est quand mme bien plus pratique si on utilise souvent
cette commande.
Grce la ligne using System; notre programme "sait" maintenant o trouver linstruction
Console.WriteLine sans que nous ayons lui indiquer le chemin absolu chaque fois.
2.2.2 Variables
2.2.2.1 Introduction
Comme vous le savez certainement, les variables nous permettent de stocker des valeurs en
mmoire. Nous allons voir comment dclarer une variable en C#. Pour ceux qui auraient des
connaissances en langage C, C++, ou Java cette partie ne sera quun rappel car la syntaxe du C# est
quasiment identique aux langages noncs prcdemment.
2.2.2.2 Les types de variable

La premire notion savoir est quil y a plusieurs sortes de variables, selon la place prise en
mmoire par celles-ci. En effet la dclaration de la variable va rserver un espace en mmoire. Vous
imaginer bien que lon ne va pas demander lordinateur de rserver une place mmoire pouvant
accepter des nombres 10 chiffres si on dsire stocker une valeur binaire. Ce serait ne pas tenir
compte du fait que le C# est un langage typage fort ! Cest pour cela quavant le nom de notre
variable, nous allons placer un mot cl indiquant le type de celle-ci. Le tableau ci-dessous fait la
correspondance entre le type de variable, le mot cl et la place rserve en mmoire.
Mot cl Le Type de notre variable Place rserve

en mmoire
bool Valeur boolenne 8 bits
char Caractre Ascii 16 bits
string Chane de caractres *
sbyte De -128 127 8 bits
byte De 0 255 8 bits
short De -32768 32767 16 bits
ushort De 0 65535 16 bits
int De -2147483648 2147483647 32 bits
uint De 0 4294967295 32 bits
long De -9223372036854775808 64 bits
9223372036854775807
ulong De 0 18446744073709551615 64 bits
float De 1.5 x 10-45 3.4 x 1038 32 bits
double De 5.0 x 10-324 1.7 x 10308 64 bits
decimal De 1.0 x 10-28 7.9 x 1028 128 bits

2.2.2.3 Les constantes

Les constantes fonctionnent comme des variables, lexception que lon indique au
compilateur que leur valeur restera inchange tout au long de lexcution du programme. Pour cela
on viendra juste placer le mot cl const devant le type de la variable et on sassurera
dinitialiser la constante des la dclaration.
2.2.2.4 Dclaration de variable

Le code suivant va vous paraitre un peu consquent, mais il est en fait assez simple. Il
prsente un exemple de dclaration et une initialisation pour chaque type de variable que nous
avons vu.
//C#
using System;
class Program
{
{
//Ceci est un commentaire, il sera ignor par le
compilateur !
bool exempleBooleen = true; //true ou false
char exempleChar = 'w'; //caractre alphanumrique
string exempleString = "une chane de caractres!";
sbyte exempleSbyte = 8;
byte exempleByte = 139;
short exempleShort = -345;

ushort exempleUshort = 35000;
int exempleEntier = 40000;

uint exempleUint = 79500;
long exempleLong = 402340540607;

ulong exempleUlong = 345678905768;
float exempleFloat = 1.72f;

//Cest un point et pas une virgule !(f la fin)
double exempleDouble = 8.76543987652354235525e12d;

//(d la fin)
decimal exempleDecimal = 1.2456723425734738590342849249e-4m;

// nombres trs grande prcision (m la fin)
//dclaration dune constante

const float g = 9.80665f;
//Ici on fait afficher nos valeur la console.
Console.WriteLine(exempleBooleen);
Console.WriteLine(exempleChar);
Console.WriteLine(exempleString);
Console.WriteLine(exempleSbyte);

//C#
Console.WriteLine(exempleByte);
Console.WriteLine(exempleShort);
Console.WriteLine(exempleUshort);
Console.WriteLine(exempleEntier);
Console.WriteLine(exempleUint);
Console.WriteLine(exempleLong);
Console.WriteLine(exempleUlong);
Console.WriteLine(exempleFloat);
Console.WriteLine(exempleDouble);
Console.WriteLine(exempleDecimal);
Console.WriteLine(g);
Console.ReadLine();
//Cette instruction attends une entre utilisateur, elle
nous permet donc de voir ce qui s'est affich dans la
console.
}
}
Ce qui nous donne laffichage suivant :
True
w
une chane de caractres !
8
139
-345
35000
40000
79500
402340540607
345678905768
1.72
8765439876523.54
00.0001245672342573473859034285
9.80665

2.2.3 Oprateurs
2.2.3.1 Oprateurs arithmtiques

Ces oprateurs nous permettent deffectuer du calcul arithmtique sur nos variables.
Operateur Signification
+ Addition
- Soustraction
* Multiplication
/ Division
% Modulo
Le code suivant prsente des exemples de calculs :
//C#
using System;
class Program
{
{
int x; //dclaration d'un entier x sans initialisation.
int y = 5; //dclaration d'un entier y ayant pour valeur 7.
x = 7; //affectation de x
//On initialise les rsultats 0

int resultatAddition = 0;
int resultatSoustraction = 0;
int resultatMultiplication = 0;
int resultatDivision = 0;
int resultatModulo = 0;
//On effectue les calculs et on les assignent aux rsultats

//correspondants.
resultatAddition = x + y;
resultatSoustraction = x - y;
resultatMultiplication = x * y;
resultatDivision = x / y;
resultatModulo = x % y;
//Ici on fait afficher nos rsultats la console.

Console.WriteLine(resultatAddition);
Console.WriteLine(resultatSoustraction);
Console.WriteLine(resultatMultiplication);
Console.WriteLine(resultatDivision);
Console.WriteLine(resultatModulo);
Console.ReadLine();//Cette instruction attend une entre

//utilisateur, elle nous permet donc de
//voir ce qui s'est affich dans la
console.
}
}

La console nous renvoie les rsultats suivants :
12
2
35
1
2
Pour vous entrainer, vous pouvez changer les valeurs de x et y et observer les nouveaux rsultats.
2.2.3.2 Oprateurs de test

Ces oprateurs nous permettent de tester des propositions. Ils renvoient donc une valeur
boolenne (true ou false).
> Strictement suprieur
< Strictement infrieur
>= Suprieur ou gal
<= Infrieur ou gal
!= Diffrent de
== Egal

Le code suivant prsente des exemples de tests :
//C#
using System;
class Program
{
{
//l'utilisation de la virgule permet de condenser
//les dclarations de variables de meme type.
//On dclare a et b deux entiers que nous allons comparer

int a = 3, b = 8;
//On dclare nos rsultats.

bool resultat1, resultat2, resultat3, resultat4;
//Ici on effectue nos tests.

resultat1 = a > b;
resultat2 = a < b;
resultat3 = a != b;
resultat4 = a == b;
//Ici on fait afficher nos rsultats la console.

Console.WriteLine(resultat1);
Console.ReadLine();
//Cette instruction attend une entre utilisateur, elle
nous permet donc de voir ce qui s'est affich dans la
console.
}
}
La console nous renvoie les rsultats des tests effectus :
False
True
True
False

2.2.3.3 Oprateurs conditionnels
|| OU
&& ET
? : (oprateur ternaire) Condition ? valeur_si_Vrai : valeur_si_Faux
?? ?? valeur si null
//C#
using System;
class Program
{
{
int a = 3; //trois entiers pour les trois tests.

int b = 6;
int c = 1;
string d = null;
bool test1; //trois rsultat des tests.

bool test2;
string test3;
string test4;
test1 = ((a == 2) || (a == 5)); //vrai si a=2 ou a=5.
test2 = ((b >= 0) && (b <= 10)); //vrai si b est compris

//entre zro et dix.
test3 = (c == 1) ? "c est gal 1" : "c n'est pas gal 1";
//enregistre la premier chane si c==1 sinon enregistre la
//deuxiemme chane.
test4 = d ?? "d est null";

//test4 vaut d ou 5 si d vaut null
//on affiche les rsultats dans la console.

Console.WriteLine(test1);
Console.ReadLine();
}
}

La console nous renvoie :
False
True
c est gal 1
Je vous conseille vivement de reprendre ce code et de changer les valeurs de a, b et c afin de bien
comprendre le fonctionnement de ces oprateurs.
2.2.3.4 Oprateurs dattribution
= Permet dassigner une valeur une variable
+=, -=, *=, /=, %= Opration puis rassignation
Nous allons tout de suite expliquer le concept des oprateurs de la deuxime ligne du tableau dont la
signification doit tre encore un peu floue.
Soit lopration suivante :
a +=4 quivaut crire a = a+4. La premire expression nous permet donc de condenser la
premire dans le but de ne pas avoir rpter le nom de la variable rassigner .
Le code suivant va donner un exemple pour chacun deux :

//C#
using System;
class Program
{
{
int a; // on dclare un entier a.
a = 3; //oprateur "=" assigne la valeur "3" la variable "a".

Console.WriteLine(a);
a += 1; //quivaut a = a+1, donc ici a = 4.

a -= 2; //quivaut a = a-2,donc ici a = 2.

a *= 3; //quivaut a = a*3,donc ici a = 6.

a /= 6; //quivaut a = a/6,donc ici a = 1.

Console.ReadLine();
}
}
Nous avons suivi chaque opration de linstruction Console.WriteLine(a); ce qui va nous

permettre de retracer les rsultats prvus dans les commentaires. Cela nous donne laffichage de la
console suivant
3
4
2
6
1
Ce qui correspond parfaitement aux rsultats prvus.
2.2.3.5 Oprateurs dincrmentation

Les Oprateur dincrmentation drivent eux aussi dune criture condense.
variable++ , variable-- +1 ou -1 aprs utilisation de la variable
++variable , --variable +1 ou -1 avant lutilisation de la variable

Voici un exemple dincrmentation :
//C#
using System;
class Program
{
{
//a++ quivaut a+=1 qui quivaut a=a+1.
int a = 0;
// on initialise a 0.
Console.WriteLine(a++);
//affiche a,soit 0, puis l'incrmente.
//affiche la valeur courante de a, soit 1.
Console.WriteLine(++a);
//incrmente a, puis affiche sa valeur, soit 2.
Console.ReadLine();
}
}
Ce qui nous donne :
0
1
2
Le systme de la dcrmentation est totalement identique si ce nest que lopration effectue est
-1 au lieu de +1 .
2.2.4 Les conditions

Nous allons voir dans cette partie les mots-cls qui vont nous permettre deffectuer des tests
lintrieur de notre code. Encore une fois, la structure des ces conditions est 95% identique celle
du langage C, C++ ou Java. Les personnes ayant dj des connaissances dans ces langages ny verront
donc rien de nouveau.
2.2.4.1 If
Le mot cl if signifie Si en franais. La syntaxe dune structure if est dtaille ci-dessous :
if( condition )
{
instruction effectuer;
instruction effectuer;
}

Linstruction if traite une expression boolenne, si la condition place entre parenthse est
vraie, alors on excute le code entre accolades.
2.2.4.2 If else
Au simple si , on peut galement ajouter un sinon si qui sera test aprs le premier
si, puis un sinon qui sexcute si aucune des clauses si nest vraie.
Exemple :
if(conditionA) //si conditionA vraie.

{
instructionA; //alors j'effectue cette partie de code.
}
if else(conditionB) //sinon si la conditionB est vrai.

{
instructionB; //alors jeffectue cette partie de code.
}
else // si aucune condition n'est vraie alors executer ce code.

{
instructionC
}
On peut mettre autant de if else que lon souhaite pour tester autant de conditions que lon
veut.
2.2.4.3 Switch
La structure dun switch est la suivante :
switch (expression) //dfinit la variable sur laquelle vont se baser

{
//les difrents cas.
// Si expression == constanteEntire1 alors instruction1.

case a :
instruction_a;
break;
//Si expression == constanteEntire2 alors instruction2.

case b :
Instruction_b;
break;
//Si expression == constanteEntire3 alors instruction3.

case c :
Instruction_c;
break;
//Sinon effectuer ce code par dfaut.

default:
instructionParDefaut;
break;
}

videmment, on peut placer autant de case que lont souhaite.
2.2.5 Les boucles

Nous allons prsent tudier les structures itratives en langage C#.
2.2.5.1 While
While signifie Tant que .Cette boucle tourne tant que lexpression quon lui donne
est vraie.
Sa structure est la suivante :
while (expression) //la boucle tourne tant que l'expression est vraie
{
instruction;
}
Nous allons voir un exemple simple, une boucle qui demande lutilisateur dentrer 0 pour sortir,
et qui se rpte tant que lutilisateur ne tape pas 0.
using System;
class Program
{
{
//on dclare x un entier que notre boucle va tester.
int x;
//on lui assigne la valeur 1 pour pouvoir rentrer dans la boucle.

x = 1;
while (x!=0) //la boucle tourne tant que x est diffrent de 0

{
Console.WriteLine("Entrez 0 pour sortir de la boucle");
//On stocke la valeur entre par l"utilisateur dans x

x = Convert.ToInt16(Console.ReadLine());
}
}
}
Rien de bien difficile dans ce code, mais une ligne en particulier mrite des explications, la ligne :
x = Convert.ToInt16(Console.ReadLine());
Pour stocker lentre au clavier dans la variable x, pourquoi na-t-on pas tout simplement crit :
x = Console.ReadLine(); .
Si vous crivez cela, vous obtiendrez une erreur de Visual Studio, car vous essayer de stocker une
chane de caractres dans un entier. En effet, la fonction Console.ReadLine() renvoi une
chaine de caractre, on ne peut donc pas la stocker dans une variable entire.
Cest pour cela que lon utilise la fonction Convert.ToInt16() afin de transformer la chaine
de caractre rcupre en entier.

2.2.5.2 Do while
La boucle do while signifie Faire tant que .Elle est identique la boucle While
deux dtails prs :
- Le code lintrieur de la boucle est effectu au moins une fois, car lexpression est teste
la fin.
- On met un ; aprs lexpression.
Voici la structure dune structure itrative do while :
do //Excuter ce code.
{
instruction;
}while(expression); //Puis si cette expression est vraie,

//repartir dans la boucle.
2.2.5.3 For
La boucle for correspond la structure itrative Pour en algorithmique.
Sa structure est la suivante :
for (initialisation; expression; pas)

{
//code de la boucle
}
Prenons par exemple un programme qui affiche Bonjour autant de fois que lon veut. Nous allons
dabord dclarer une variable i initialise 1, et lincrmenter chaque tour de boucle jusquau
nombre de bonjour dsirs :
using System;
class Program
{
{
for (int i = 1; i <= 10; i++) // On veut afficher 10 "Bonjour"
{
Console.WriteLine("Bonjour " + i + " fois"); //le "+" met les chaines
bout bout (concatenation).
}
Console.ReadLine(); //Met le programme en pause la fin de l'affichage.
}
}

Ce qui nous renvoie le code suivant :
Bonjour 1 fois
Bonjour 2 fois
Bonjour 3 fois
Bonjour4 fois
Bonjour 5 fois
Bonjour 6 fois
Bonjour 7 fois
Bonjour 8 fois
Bonjour 9 fois
Bonjour 10 fois

3 Conclusion
Dans ce chapitre, nous avons abord des concepts fondamentaux qui nous permettrons de
poursuivre sereinement lapprentissage du C# et de ses notions plus avances. Nous avons tudi le
fonctionnement du Framework .NET, appris dclarer des variables et a implmenter des structures
slectives (if else, switch case ) et itratives (les boucles).
Nous avons galement vu que le langage C# encore jeune, tait un langage qui bnficiait de
frquentes modifications visant amliorer ses services et quil possdait tous les critres dun
langage davenir. En effet cest un langage, simple et performant, parfaitement adapt la
plateforme .NET.
Dans le prochain chapitre, nous aborderons des notions avances du langage C# tel que des
collections, la gestion des exceptions, ainsi que le concept dobjets et de classes.

CSharp Base PDF

Transféré par

Droits d'auteur :

Formats disponibles

CSharp Base PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

CSharp Base PDF

Transféré par

Droits d'auteur :

Formats disponibles

Notions fondamentales du

1 Tout ce quil faut savoir pour bien commencer ................................................... 3

2 Les bases du C# ................................................................................................................. 7

Dotnet France Association

1 Tout ce quil faut savoir pour bien commencer

1.1 Quest ce quun langage de programmation ?

1.1.2 Ncessit dun langage intermdiaire

Le compilateur est une sorte de traducteur langage de programmation binaire.

Dotnet France Association

1.2 Introduction la programmation oriente objet

1.2.2 Les avantages de la programmation oriente objet

1.3 Prsentation du Framework .Net

Dotnet France Association

1.3.2 Le Common Language Specification et le Common Language Runtime.

Dotnet France Association

1.4 Quest ce que le C#

Dotnet France Association

2.1 Environnement de dveloppement

2.1.1 Installation de Visual studio 2008

2.1.2 Cration dun projet C#

Dotnet France Association

Dotnet France Association

A prsent, direction ltape suivante pour comprendre un peu tout .

2.2 Les bases de la programmation C#

2.2.1.1 La structure de base

Voyons alors larchitecture gnrique :

namespace <espace de noms facultatif>

Nous allons maintenant excuter notre premier programme.

2.2.1.2 Afficher un message dans la console

Dotnet France Association

Excutez ce code dans Visual Studio (F5 pour excuter).

Il ne se passe rien ? La console apparait et disparat instantanment ? Ne vous inquitez pas

2.2.1.3 Attendre une entre utilisateur

Ajouter-la en fin de code comme ceci puis excutez :

Ici, la chane de caractre rcupre par System.Console.ReadLine(); nest stocke

Voil ! Nous avons prsent tout le temps de contempler notre message.

Bienvenue sur Dotnet-France !!!

2.2.1.4 La directive using

Dotnet France Association

Cela nous permet dcrie Console.WriteLine au lieu de

2.2.2.2 Les types de variable

Mot cl Le Type de notre variable Place rserve

Dotnet France Association

2.2.2.3 Les constantes

2.2.2.4 Dclaration de variable

char exempleChar = 'w'; //caractre alphanumrique

string exempleString = "une chane de caractres!";

short exempleShort = -345;

int exempleEntier = 40000;

long exempleLong = 402340540607;

float exempleFloat = 1.72f;

double exempleDouble = 8.76543987652354235525e12d;

decimal exempleDecimal = 1.2456723425734738590342849249e-4m;

//dclaration dune constante

//Ici on fait afficher nos valeur la console.

Dotnet France Association

Ce qui nous donne laffichage suivant :

Dotnet France Association

2.2.3.1 Oprateurs arithmtiques

a = 3; //quivaut a = a3,donc ici a = 6.