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);