Support de cours pour apprendre le C# .Net

Support de cours pour apprendre le C# .Net

...

Architecture .NET

Principes généraux

L’architecture .NET

• .NET est une couche Windows (collection de DLL) librement distribuable.
• Cette couche contient des classes et un environnement d’exécution (run time).
• Pour un programme qui s’exécute sous contrôle de cet environnement, on parle de mode géré ou managé (managed code).

La CLR (1)

• Les services fournis par le run time font partie de la CLR (Common Language Run time) et assurent :

– chargement et exécution contrôlé des programme

– isolation des programmes entre eux

– vérification de type lors des appels de fonctions

– conversion de code intermédiaire en code natif à l’exécution (JIT : Just In Time Compiler)

La CLR (2)

– accès aux infos sur le code (méta données)

– gestion de la mémoire

– sécurité

– compatibilité avec les DLL et modules COM

...

Compatibilité des langages .NET

• Une classe .NET peut être utilisé de la même manière dans tous langages .NET
• Une classe peut être écrite dans un langage X
• Une classe peut être dérivé de celle-ci dans un langage Y
• Cette classe dérivée peut être utilisé sans un langage Z
• la manière de créer et utiliser les objets est identique

C# par rapport à C++

– orientation objet plus importante

– code Unicode

– libération automatique d’objet (garbage collection)

– sur les tableaux ou les objets les pointeurs sont remplacés par des références

– passage par référence (et non adresse) des arguments

– ...

Éléments syntaxiques types de données tableaux opérateurs instructions

Premiers pas

Class Prog

{

static void Main()

{

/* code du programme principal */

}

}

Éléments syntaxiques

• Majuscules <> minuscules (case sensitif)
• Les instructions se terminent par ;
• les espaces de noms dont déclarés par using
• // ou /// indique que le reste de la ligne est un commentaire
• /* indique un début de commentaire
• */ indique une fin de commentaire
• un identificateur doit commencer par une lettre ou _

Types entiers (1)

• byte : entier non signé codé sur 8 bits, 0 à 255. Classe System.Byte
• sbyte : entier signé codé sur 8 bits, -128 à 127. Classe System.SByte
• short : entier signé codé sur 16 bits,  -32 000 à 32 000. Classe System.Int16
• ushort : entier non signé codé sur 16 bits, 0 à  65 000. Classe System.UInt16

Non conforme à la CLR = peut ne pas être compatible en cas d ’appel d ’un autre langage .NET

Types entiers (2)

• int : entier signé codé sur 32 bits,  -2 milliards à 2 milliards. Classe System.Int32
• uint : entier non signé codé sur 32 bits, de 0 à  4 milliards. Classe System.UInt32
• long : entier signé codé sur 64 bits,  -9.2 x 1018 à 9.2 x 1018. Classe System.Int64
• ulong : entier non signé codé sur 64 bits, de 0 à  18 x 1018. Classe System.UInt64

Non conforme à la CLR = peut ne pas être compatible en cas d ’appel d ’un autre langage .NET

Types réels

• float : réel codé sur 32 bits, si > 0 de 1.4 x 10-45 à 3.4 x 1038. Classe System.Single
• double : réel codé sur 64 bits, si > 0 de 4.9 x 10-324 à 1.8 x 10308. Classe System.Double
• decimal : réel codé sur 128 bits, exactitude si < 8 x 1028. Classe System.Decimal
• Attention à la précision : si dans une boucle on additionne dix mille fois 0.001 codé en float, on obtient 10 000.0004

Autres types

• bool : booléen, True ou False. Classe

System.Boolean.

• char : caractère codé sur 16 bits Unicode (=ASCI + caractères accentués + autre langues). Classe System.Char.
• string : chaîne de caractères codé sur 16 bits et d ’agrandit automatiquement. Classe

System.String

Déclarations et affectations

int i;

i = 5;

string s = "Bonjour";

double d = 1.23;

float f = 1.2f;

char c1 = 'A';

char c2 = '\n'; // Nouvelle ligne

char c3 = '\0' ; // caractère NULL

Type enum

enum Sexe {masculin, féminin}

….

Sexe s1 ;// s1 est une variable de type Sexe

s1 = Sexe.masculin;

if (s1 == Sexe.masculin) Console.Write("M");

// affiche M

s1++;

if ((int)s1 == 1) Console.Write("F"); // affiche F

• La déclaration enum doit être hors d'une fonction dans la classe ou hors de la classe

Tableau à une dimension

int[] t; // référencé pas encore alloué

int[] t1, t2; // référencés pas encore alloués

t1 = new int [3]; // allocation

int[] t3 =new int[3]; //référencé et alloué

t2 = new int [] {5,3,1}; //allocation et initialisation

Console.Write(t2[0]); // affiche 5

Console.Write(t2.Length); // affiche 3

Array.Sort(t2); // tri le tableau

t2.CopyTo(t1,0); //copie t2 dans t1 depuis t2[0]

t3 = t2; // t3 et t2 référence le même tableau

t2[2] = 9; Console.Write(t3[2]); // affiche 9

Tableau à n dimensions

int[,] tn, tn1; // référencés pas encore alloués

tn1= new int [2,3]; // allocation

int [,] tn2 =new int[2,3]; //référencé et alloué

tn = new int [,] {{5,3,1}, {2,4,6}}; // initialisation

Console.Write(tn[1,0]); // affiche 2: col n°0, ligne n°1

Console.Write(tn.GetLength(0)); // affiche 2

tn1 = (int[,])tn.Clone(); //copie tn dans tn1

1 x++ x-- new …

2 un seul opérande + - ! ++x --x

3 multiplication – division * / %

4 addition – soustraction + -

5 décalage de bits << >>

6 relations < > >= <= is

7 égalité – inégalité = = ! =

8 ET binaire &

9 XOR binaire ^

10 OU binaire |

11 condition ET &&

12 condition OU ^^

13 condition ? :

14 assignations = *= /= += -= …..

Priorité des opérateurs

Opération entrée-sortie console

int i, j;

Console. WriteLine("Somme"); // affiche Somme

Console. Write ("Som"); // affiche Som

Console. WriteLine("me"); // complète Somme

i=1; j=2; Console.WriteLine("Somme = " + (i+j));

// affiche Somme = 3

i=1; j=2; Console.WriteLine("Somme = " + i+j);

// affiche Somme = 12

string s = Console.ReadLine();

i = Int32.Parse(s); Console.WriteLine(i+j);

Opérateurs (1)

• Opérateurs arithmétiques : +, -, *, /
• si une des opérandes est réelle, / est une division réelle, sinon c'est une division entière (quotient arrondi inf, % donne le reste. Exemple : 9/-4 donne -2 et 9%-4 donne 1
• Post-incrémentation

( i=j++) équivaut à i=j; j=i+1;

• Pré-incrémentation

( i=++j) équivaut à j=j+1; i=j;

Opérateurs (2)

• Not booléen: c=true; b = !c;
• Opérations binaires (bit à bit ) sur entiers non signés : & (and), | (or) , ^ (xor) et ~ (inversion de tous les bits)
• Décalage d'un bit à gauche << (i.e *2)
• Décalage d'un bit à droite >> (i.e /2)

Instruction if

• if (i==0) une instruction;
• if (i==0) une instruction else une instruction;
• if (i==0)

{

une instruction ou plusieurs instructions;

}

else

{

une instruction ou plusieurs instructions;

}

Éléments de conditions

• Conditions avec un booléen :

if (b) équivaut à if (b == true)

if (!b) équivaut à if (b == false)

• Instructions ?

a = b!=0 ? 1 : 2; équivaut à

if (b!=0) a=1 else a =2;

• Opérateurs logiques

if (i==1 && j!=2 || k ==0)

signifie "si i vaut 1 et j différent de 2 ou k vaut 0"

Boucles

• Tant que : while (i<5)

{instructions;}

• Jusqu'à do

{instructions;}

while (i<5);

• Pour

for (int i=1;i<5;i++)

{instructions;}

for (int i=1, j = 10 ;i<5||j>10;i++,j--)

{instructions;}

Autres instructions

• Passage à l'itération suivante : continue;
• Sortie de boucle : break;
• Énumération

switch(variable)

{case valeur1: instructions; break;

case valeur2 : instructions; break;

default : instructions; break;}

Gestion d'erreur

int i , j =0 ;

try

{ i = 5/j;}

catch (Exception Err)

{MessageBox.Show(Err.Message);}

finally

{MessageBox.Show("Dans tous les cas");}

• Remarque : l'instruction finally est facultative.

Les fonctions

• Pas de passage d'arguments par adresse
• Passage d'arguments par référence seulement pour les tableaux et objets
• Passage d'arguments par valeur ou référence pour les autres types
• void signale une fonction qui ne retourne pas de valeurs

Passage d'arguments

• Par valeurs

– Appel : int a = 3; f(a);

– Description : static void f(int i) {instructions;}

• Par référence

– Appel : int a = 3; f(ref a);

– Description : static void f(ref int i)

{instructions;}

• De tableau (toujours par réf, ref implicite)

– Appel : int[] ta = {1,2,3}; f(ta);

– Description : static void f(int [] ti) {instructions;}

Passage d'arguments variables

• En nombre f(1,2); f(1,5,1,6); f();

static void f(params int[] p)

{foreach (int a in p) Console.Write (a + " ");}

• En nombre et en type: f(1,2); f(1,5,"z"); f(3.45);

static void f(params object[] p)

{foreach (object a in p) {

if (a is int) Console.WriteLine ( "Entier : "+a);

if (a is double) Console.WriteLine ( "Réel : "+a);

if (a is string) Console.WriteLine ( "Chaine : "+a);}}

Applications Windows

Notions de base

Code généré par C#

• Références aux namespaces utilisés pour une application Windows
• Un namespace portant le nom du projet
• A l'intérieur de celui-ci, une classe portant le nom de la fenêtre principale
• A l'intérieur de celle-ci, un fonction Main qui exécute la méthode Run de l'objet

Application.

Régions

• Les parties du code peuvent être délimitées dans des "régions" en les bornant par les délimiteurs #region et #endregion

#region Test

int i = 1;

#endregion

• Un bouton de réduction en forme de "-" apparaît alors pour masquer cette partie du code

Quelques méthodes de base

• Affichage de Form2 (non modale)

Form2 f = new Form2() ; Form2.Show();

• Affichage de Form2 (modale)

Form2 f = new Form2() ; Form2.ShowDialog();

• Modification propriété d'un contrôle de Form2

Form2 f = new Form2() ; Form2.ShowDialog();

• Affichage d'un boîte de dialogue

MessageBox.Show("Faire le choix", "Entête...",

MessageBoxButtons.YesNo);