|
Introduction
Les Caractéristiques du C# par rapport au C++
Librairies
Mots réservés du langage C#
Type de données du langage C#
Les tableaux
Les instructions du langage C#
Les opréations d'entrées/sorties
Les conditions en C#
les boucles
les fonctions
Introduction
Sous la demande de Microsoft, Anders Hejlsberg a mis au point un système pour
rendre le développement d'application Windows et Web beaucoup plus aisé. Une
nouvelle architecture est née suivit d'un langage qui devient aussitôt la référence
et le principal langage pour Microsoft: c'est le C charp ou encore C#.
Le c# est dérivé du c++, on y retrouve aussi plusieurs caractéristiques des
langages relativement récent à savoir par exemple le java.Il participe aussi
pleinement à la création des pages Web dynamiques côté serveur et des services
Web. Puisque le c# s'inscrit dans la lignée c c++, nous allons en premier présenter
les caractéristiques de c# par rapport au c++ et en second étudier les instructions
de base de C#.
Les Caractéristiques du C# par rapport au C++
- orientation objet prononcé tout doit être incorporé dans les classes.
- code unicode nouvelle solution pour faire face à la lourdeur de l'interfaçage
avec la lourdeur des modules unicodes.
- libération automatique des objets
- disparition des pointeurs
- remplacement des pointeurs par des références.
- disparition du passage d'argument par adresse au profit du passage par référence.
- nouvelles manipulations des tableaux.
- passage de tableaux en arguments
- nouvelles manières d'écrire les boucles.
- disparition de l'héritage multiple mais possibilité d'implémenter plusieurs
interfaces dans une classe.
Librairie
//Nous allons commencer par un petit programme nous permmetant d'afficher un message.
using System;
class Prog
{
static void Main()
{
Console.WriteLine("coucou");
}
}
/* A première vue, on remarque qu'il n'y a aucune directive #include, eh
oui, tout est inclu dans la librairie System.La première ligne(using System)
signale que l'on fera appel à des fonctions de l'architecture.NET regroupées dans
un espace de noms(namespace) appelé System(attention à la casse). Parmi ces fonctions
on a la classe 'Console' qui permet de dialoguer avec l'utilisateur en mode console.
Différentes fonctions encore appelées méthodes peuvent être appliquées à la classe
Console.Dans cet exemple on a par exemple la méthode WriteLine.On aurait pu omettre
la directive using, dans ce cas on aurait écrit:
*/
class Prog
{
static void Main()
{
System.Console.WriteLine("coucou");
}
}
Utilisation d'un alias dans la clause using
using Cout = System.Console;
class Prog
{
static void Main()
{
Cout.WriteLine("coucou");
}
}
/* Ici Cout est choisi librement et n'a aucun rapport avec cout du c++
, Cout est l'alias choisi. */
Mot réservés du langage c#
| abstract |
as |
|
|
| base |
bool |
break |
byte |
| case |
catch |
char |
checked |
| class |
const |
continue |
|
| decimal |
default |
delegate |
do |
| double |
|
|
|
| else |
enum |
event |
explicit |
| extern |
|
|
|
| false |
finally |
fixed |
float |
| for |
foreach |
|
|
| goto |
|
|
|
| if |
implicit |
in |
int |
| interface |
internal |
is |
|
| lock |
long |
|
|
| namespace |
new |
null |
|
| object |
operator |
out |
override |
| params |
private |
protected |
public |
| readonly |
ref |
return |
|
| sbyte |
sealed |
short |
sizeof |
| stackalloc |
static |
string |
struct |
| switch |
|
|
|
| this |
throw |
true |
try |
| typeof |
|
|
|
| uint |
ulong |
unchecked |
unsafe |
| ushort |
using |
|
|
| vitual |
void |
|
|
| while |
|
|
|
Type de données du langage c#
| entier |
booléen |
réel |
char |
|
byte
valeur comprise entre 0 et 255
codée sur 8 bits
|
bool |
float
entre 1.4*10^-45 et 3.4*10^38
codée sur 32 bits
|
char
codée sur 16 bits
|
|
sbyte
valeur comprise entre -128 et 127
codée sur 8 bits
|
|
double
entre 4.9*10^-324 et 1.8*10^308
codée sur 64 bits
|
|
|
byte
valeur comprise entre 0 et 255
codée sur 8 bits
|
|
decimal
codée sur 128 bits
|
|
|
short
valeur comprise entre -32768 et 32767
codée sur 16 bits
|
|
|
|
|
ushort
valeur comprise entre 0 et 65535
codée sur 16 bits
|
|
|
|
|
int
valeur comprise entre -2^31 et 2^31 - 1
codée sur 32 bits
|
|
|
|
|
uint
valeur comprise entre 0 et 2^32 - 1
codée sur 32 bits
|
|
|
|
|
long
valeur comprise entre -9.2*10^18 et 9.2*10^18
codée sur 64 bits
|
|
|
|
LES TABLEAUX
Par rapport au C/C++, il y a eu d'heureux changements, nettement plus simple
et plus fiable qu'en C/C++.
Les tableaux à une dimension
se déclare comme suit:
int[] tata = new int[3]; //on a déclaré et alloué un tableau de trois entiers
On peut aussi déclarer et initialiser en même temps:
t = new int[] {12, 8, 17};
spécifier la taille du tableau n'est pas nécessaire ici, car elle découle automatiquement
du nombre de valeurs initiales.
Il est possible de déclarer et de réserver un tableau à condition de l'initialiser(new
ne doit plus être écrit bien qu'il soit effectué):
int[] tata = {1, 2, 3};
float[] titi = {3.5f, 1.4f, 15.5f};
string[] fifi ={"niki", "superman", "terror"};
Les tableaux à plusieurs dimensions
int [,] tata = new int[6, 9];
tata est un tableau de 6 lignes et 9 colonnes, on aura donc 54 cellules
qui accueilleront un entier.
On peut aussi le déclaré et initialiser de la manière suivante:
int [,] tata = {{0, 1, 2}, {3, 4, 5}};
Les tableaux déchiquetés
Il est possible de créer un tableau de 2 lignes dont chaque ligne contiendrait
un nombre différent d'entiers:on parle alors de tableau déchiqueté(jagged
array):
int[][] titi; //déclaration du tableau
titi = new int[2][]; //on alloue 2 lignes
titi[0] = new int[3]; //trois entiers en première ligne.
//initialisation de la première ligne
titi[0][0] = 1;
titi[0][1] = 2;
titi[0][2] = 3;
//quatre entiers en seconde ligne(déclaration + initialisation)
titi[1] = new int[]{12, 14, 16, 18};
Ici pour accèder la troisième cellule de la première ligne c'est: titi[0][2]
LES INSTRUCTIONS DU LANGAGE C#
Bloc d'instructions
Plusieurs instructions peuvent être entourées d'accolades.Elles forment un bloc
d'instructions.Les variables déclarées dans ce bloc cesseront d'éxister à la
sortie du bloc.
N.B: toute instruction doit se trouver dans une fonction et toute fonction doit
faire partie d'une classe.
Toute variable doit être initialisée
Le compilateur C# signale une erreur de syntaxe si l'on utilise une variable
non initialisée ou si une variable pouvait ne pas être initialisée(par exemple
parce que l'assignation a été effectuée dans une branche seulement d'une alternative).
Pas d'instructions séparées par une virgule en C#
On ne peut pas écrire:
i = 1, j = 4; //ça marche en C/C++ mais erreur de syntaxe en C#
Toutes instructions doit être terminées par un point-virgule.
Conversons automatiques et castings
Les castings permettent de forcer des conversions qui ne sont pas automatiquement
réalisées par le compilateur. Parce que C# refuse les conversions qui n'ont
pas de sens comme par exemple, passer d'une représentation sous forme d'une
chaine de caractère à une représentation sous forme d'entier ou de réel,Il est
impératif d'utiliser les méthodes des classes Double, long, Single ou Integer.
LES OPERATIONS D'ENTREE/SORTIE
Lecture de données saisies au clavier
La lecture des données se fait par la fonction ReadLine(attention à la casse)une
fonction statique de la classe Console.Illustrons cette fonction:
using System;
string t = Console.ReadLine();
int i = Int32.Parse(t);
Attention! les données entrées doivent être de type entier.
autre exemple:
string t = Console.ReadLine();
float v = float.Parse(t);
Lecture fiable d'un entier
int i;
...
try
{
string titi = Console.ReadLine();
i = Int32.Parse(titi);
Console.WriteLine("données saisies: + i);
}
catch (Exception e)
{
Console.WriteLine("Erreur sur le nombre");
}
Affichages des données
| instructions; |
affichage |
| using System; |
|
|
Console.WriteLine("sa");
Console.WriteLine("lut");
|
sa
lut |
|
Console.Write("sa");
Console.WriteLine("lut");
|
salut |
|
int i=4;
Console.WriteLine(i);
|
4 |
|
int i=4;
Console.WriteLine("valeur i:" + i);
|
valeur i: 4 |
|
int i=4; int j=5;
Console.WriteLine("i = "+ i + "et j = "+ j);
|
i = 4 et j = 5 |
|
int i=12; int j=3;
Console.WriteLine("i = {0} et j = {1}", i, j);
|
i = 12 et j = 3 |
|
int i=12; int j=3;
Console.WriteLine(i + j);
|
15 |
|
int i=12; int j=3;
Console.WriteLine("somme =" + i + j);
|
123 |
|
int i=12; int j=3;
Console.WriteLine("somme =" + (i + j));
|
15 |
|
int i=12; int j=3;
Console.WriteLine("somme = {0}", i + j);
|
15 |
|
int i=12; int j=3;
Console.WriteLine("produit = " + i*j);
|
36 |
|
int i=12; int j=3;
Console.WriteLine(i + j + "somme = ");
|
15 somme = |
LES CONDITIONS EN C#
L'instruction if
Rien de nouveau par rapport au C/C++. Tout se déroule suivant la logique de
n'importe quel langage moderne. Pour ne pas présenter les choses connues, nous
allons juste noter quelques petites différences.
| instructions légales en C/C++ |
écriture en C#: |
| if (i) |
if (i != 0) |
| if (!i) |
if (i == 0) |
|
if (i = j)
en c/c++, j est copié dans i, puis teste si i est différent de 0
|
i = j;
if (i != 0)
ou bien
if ((i=j) !=0)
|
LES BOUCLES
L'instruction foreach
L'instruction foreach permet de parcourir un tableau ainsi qu'une collection
string[] toto = new int[] {60, 18, 45, 5};
foreach (int i in toto) Console.WriteLine(i);
Dans le cas d'un tableau de chaîne de caractères:
string[] tab = {"niki", "terminator", "rambo"};
foreach (string s in tab) Console.Writeline(s);
Se lit: pour chaque cellule s du tableau tab, il faut exécuter l'instruction
Console.WriteLine.
On peut aussi spécifier plusieurs instructions, il faudra alors penser à les
entourer d'accolades comme pour les autres boucles.
L'instruction for
les différentes formes
| for (int i=0; i<10; i++)... |
pareil qu'en c/c++ |
| for (int i=0, j=10; i++, j--) |
jusque là pas de problème |
|
int i=0; int j=10;
for (;i<5; i++, j--)...
|
les variables i et j sont déclarées en dehors de la
boucle et ne sont donc plus limitées à la boucle
|
| for (;;i++, j--)... |
l'initialisation et la condition sont absentes, donc
la condition est toujours vraie; utiliser l'instruction break pour sortir
de la boucle
|
| for (;;) {...; i++; i--} |
|
| for (; true;) {...; i++; i--} |
pareil que le précédent |
Exemple de boucle for:
int[] tata = {56, 7, 31};
for (int i=0; i< tata.Length; i++) Console.WriteLine(tata[i]);
Les instructions goto, switch, break et continue
Pareil quand C/C++, mais nous devons faire attention car C# modifie
le passage d'un case à l'autre(sauf dans le cas où case ne comporte aucune instruction)
et accepte les chaînes de caractères dans le sélecteur. Si une clause case comporte
au moins une instruction, le passage au casesuivant n'est possible qu'en exécutant
goto case.Illustrons par un exemple:
ici var est de type entier
switch (var)
{
case 0 : une ou plusieurs instructions;
break;
case 1 :
case 2 : une ou plusieurs instructions;
break;
case 3 : une ou plusieurs instructions;
goto case 4;
case 4 : une ou plusieurs instructions;
break;
default : une ou plusieurs instructions;
}
LES FONCTIONS
Pas rapport au C/C++:
- toutes les fonctions sont dépendantes d'une classe.
- différence en ce qui concerne le passage d'argument par référence.
- pas de différence en ce qui concerne le passage d'argument par valeur.
- plus de passage d'argument par adresse.
- pas de prototype ni de fichier à inclure.
- facilité d'acceptation de tableau.
- peut renvoyer un tableau.
Exemple de passage d'un tableau en argument:
class Prog {
static void Main()
{
int[] tab = {12, 13, 14, 15);
f(tab);
foreach (int i in tab) Console.WriteLine(i);
}
static void f(int [] titi)
{
for (int i=0; i < titi.Length; i++) titi[i]++ ;
}
}
Exemple de passage d'arguments par valeur
using System;
class Prog
{
static void Main()
{
int a=6, b;
f(a); //appel de la fonction f avec le contenu de a en argument
b = g(a, 3); //b prend la valeur 18
}
static void f(int i)
{
Console.WriteLine(i); //affiche 6
}
static int g(int a1, int a2)
{
return a1*a2;
}
}
Passage d'argument par référence
class Prog
{
static void Main()
{
int a=6;
f(ref a); //passer a de Main en argument
Console.WriteLine("{0}", a); //affiche 13
static void f(ref int a1)
{
a1 = 13; //modifie a de Main
}
}
|
|
 |
 Pour afficher ou poster un commentaire, cliquez sur ce lien : Forum-Microsoft
|
|
Présentation de C# 
