Charte de déontologie d’Inclusiv Academy
C#
INCLUSIV ACADEMY
Inclusiv Academy
INCLUSIV ACADEMY |
1
Support de cours
C#
[C#]
1. Introduction
Le langage C# (C Sharp) est un langage objet créé spécialement pour le framework Microsoft .NET.
Le Framework .NET est un environnement d'exécution ainsi qu'une bibliothèque de classes (plus de
2000 classes). L'environnement d’exécution de .NET est une machine virtuelle comparable à celle de
Java.
Les classes .NET peuvent être utilisées par tous les langages prenant en charge l'architecture .NET.
2. Base du langage C#
2.1. Les types de données
C# utilise les types de données suivants :
- les nombres entiers : int, long
- les nombres réels : float, double
- les caractères et chaînes de caractères : char, string
- les booléens : bool
- les objets : Object
2.2. Déclaration de données
Déclaration de constante
const type nom=valeur; //définit constante nom=valeur
const float myPI=3.141592F
Déclaration des variables
Une variable est identifiée par un nom et se rapporte à un type de données. C# fait la différence
entre majuscules et minuscules. Ainsi les variables FIN et fin sont différentes.
Les variables peuvent être initialisées lors de leur déclaration. La syntaxe de déclaration d'une ou
plusieurs variables est :
- Identificateur_de_type variable1[=valeur1], variable2=[valeur2],...;
- où Identificateur_de_type est un type prédéfini ou bien un type défini par le programmeur.
On peut également ne pas préciser le type exact d'une variable en utilisant le mot clé var en lieu et place
de Identificateur_de_type :
- var variable1=valeur1, variable2=valeur2, ...;
Le mot clé var ne veut pas dire que les variables n'ont pas un type précis. La variable variablei a le type
de la donnée valeuri qui lui est affectée. L'initialisation est ici obligatoire afin que le compilateur puisse
en déduire le type de la variable.
2
Support de cours
2.3. Conversion
Nombre Chaine : Nombre.ToString() ;
Chaine int : int.Parse(Chaine) ;
Chaine float : float.Parse(Chaine) ;
Chaine double : double.Parse(Chaine) ;
Chaine long : long.Parse(Chaine) ;
2.4. Les tableaux de données
Un tableau C# est un objet permettant de rassembler sous un même identificateur des données de même
type. Sa déclaration est la suivante :
- Type[] tableau=new Type[n]
- n est le nombre de données que peut contenir le tableau.
- La syntaxe Tableau[i] désigne la donnée n° i où i appartient à l'intervalle [0, n-1].
Un tableau peut être initialisé en même temps que déclarer :
- int[] entiers=new int[] {0,10,20,30};
- Ou int[] entiers={0,10,20,30};
Les tableaux ont une propriété Length qui détermine le nombre d'éléments du tableau.
Un tableau à deux dimensions pourra être déclaré comme suit :
- Type[,] tableau=new Type[n,m];
- où n est le nombre de lignes, m le nombre de colonnes. La syntaxe Tableau[i,j] désigne
l'élément j de la ligne i du tableau.
Le tableau à deux dimensions peut lui aussi être initialisé en même temps qu'il est déclaré :
- double [,] réels=new double[,] { {0.5, 1.7}, {8.4, -6}};
- Ou double[,] réels={ {0.5, 1.7}, {8.4, -6}};
- Le nombre d'éléments dans chacune des dimensions peut être obtenue par la méthode
GetLength(i) où i=0 représente la dimension correspondant au 1er indice, i=1 la dimension
correspondant au 2ième indice, …
- Le nombre total de dimensions est obtenu avec la propriété Rank, le nombre total d'éléments
avec la propriété Length.
Un tableau de tableaux est déclaré comme suit :
- Type[][] tableau=new Type[n][];
- La déclaration ci-dessus crée un tableau de n lignes.
- Chaque élément tableau[i] est une référence de tableau à une dimension.
- Ces références tableau[i] ne sont pas initialisées lors de la déclaration ci-dessus. Elles ont pour
valeur la référence null.
3
Support de cours
Exemple regroupant les trois types de tableaux
4
Support de cours
2.5. Instruction élémentaire de C#
2.5.1. Ecriture sur écran
Il existe différentes instructions d'écriture à l'écran :
- Console.Out.WriteLine(expression);
- Console.WriteLine(expression);
- Console.Error.WriteLine (expression);
Où expression est tout type de donnée qui puisse être converti en chaîne de caractères pour être affiché
à l'écran.
Tous les objets de C# ou .NET ont une méthode ToString() qui est utilisée pour faire cette conversion.
La classe System.Console donne accès aux opérations d'écriture écran (Write, WriteLine).
La classe Console a deux propriétés Out et Error qui sont des flux d'écriture de type TextWriter :
- Console.WriteLine() est équivalent à Console.Out.WriteLine() et écrit sur le flux Out associé
habituellement à l'écran.
- Console.Error.WriteLine() écrit sur le flux Error, habituellement associé lui aussi à l'écran.
2.5.2. Lecture de données tapées au clavier
Le flux de données provenant du clavier est désigné par l'objet Console.In de type TextReader. Ce type
d'objets permet de lire une ligne de texte avec la méthode ReadLine :
- string ligne=Console.In.ReadLine();
La classe Console offre une méthode ReadLine associée par défaut au flux In. On peut donc écrire :
- string ligne=Console.ReadLine();
2.5.3. Exemple
5
Support de cours
2.6. Affectation de la valeur d'une expression à une variable
On s'intéresse ici à l'opération variable=expression ;
L'expression peut être de type : arithmétique, relationnelle, booléenne, caractères.
Les opérateurs des expressions arithmétiques sont les suivants :
+ addition
- soustraction
* multiplication
/ division : le résultat est le quotient exact si l'un au moins des opérandes est réel. Si les deux
opérandes sont entiers le résultat est le quotient entier. Ainsi 5/2 -> 2 et 5.0/2 ->2.5.
% division : le résultat est le reste quelque soit la nature des opérandes, le quotient étant lui
entier. C'est donc l'opération modulo.
6
Support de cours
La priorité des opérateurs lors de l'évaluation d'une expression arithmétique est la suivante (du plus
prioritaire au moins prioritaire) :
[fonctions], [ ( )],[ *, /, %], [+, -]
Les opérateurs d'un même bloc [ ] ont même priorité.
Les Expressions relationnelles sont les suivants : <, <=, ==, !=, >, >=
priorités des opérateurs
1. >, >=, <, <=
2. ==, !=
Les opérateurs booléens utilisables sont AND (&&) OR (||) NOT (!). Le résultat d'une expression
booléenne est un booléen.
Les changements de type
Il est possible, dans une expression, de changer momentanément le codage d'une valeur. On appelle cela
changer le type d'une donnée ou en anglais type casting. La syntaxe du changement du type d'une valeur
dans une expression est la suivante :
(type) valeur
2.6. Les instructions de contrôle du déroulement du programme
2.6.1. Structure de choix simple
Syntaxe :
if (condition) {actions_condition_vraie;} else {actions_condition_fausse;}
7
Support de cours
2.6.2. Structure de cas
La syntaxe est la suivante :
2.6.3. Structure de Répétition
Structure for
La syntaxe est la suivante :
for (i=idebut;i<=ifin ;i=i+ipas){action;}
8
Support de cours
Structure foreach
La syntaxe est la suivante :
foreach (Type variable in collection){instructions;}
Structure tantque (while)
La syntaxe est la suivante :
while(condition){actions;}
Structure répéter jusqu'à (do while)
La syntaxe est la suivante :
do{instructions;} while(condition);
9
Support de cours
2.7. Les énumérations
Une énumération est un type de données dont le domaine de valeurs est un ensemble de constantes
entières
2.8. Passage de paramètres à une fonction
10
Support de cours
Passage par valeur
Passage par référence
11
Support de cours
Passage par référence avec le mot clé out
12
Support de cours
3. Classes et Structures
3.1. Généralité
Nous abordons maintenant la programmation objet. Un objet est une entité qui contient des données qui
définissent son état (on les appelle des champs, attributs, ...) et des fonctions (on les appelle des
méthodes). Un objet est créé selon un modèle qu'on appelle une classe :
3.2. Création d’un nouveau projet
13
Support de cours
14
Support de cours
3.3. Création de la classe Personne
15
Support de cours
On va ensuite ajouter les attributs et les méthodes de la classe Personne.
16
Support de cours
On obtient le résultat suivant en lançant l’application
Les membres ou champs d'une classe peuvent être des données (attributs), des méthodes (fonctions), des
propriétés. Les propriétés sont des méthodes particulières servant à connaître ou fixer la valeur
d'attributs de l'objet. Ces champs peuvent être accompagnés de l'un des trois mots clés suivants :
Privé Un champ privé (private) n'est accessible que par les seules méthodes internes de la
classe
Public Un champ public (public) est accessible par toute méthode définie ou non au sein de la
classe
Protégé Un champ protégé (protected) n'est accessible que par les seules méthodes internes de
la classe ou d'un objet dérivé (voir ultérieurement le concept d'héritage).
En général, les données d'une classe sont déclarées privées alors que ses méthodes et propriétés sont
déclarées publiques. Cela signifie que l'utilisateur d'un objet (le programmeur)
N’aura pas accès directement aux données privées de l'objet
Pourra faire appel aux méthodes publiques de l'objet et notamment à celles qui donneront accès
à ses données privées.
17
Support de cours
3.4. Constructeur d’une Classe Personne
Un constructeur est une méthode qui porte le nom de la classe et qui est appelée lors de la
création de l'objet. On s'en sert généralement pour l'initialiser. C'est une méthode qui peut accepter des
arguments mais qui ne rend aucun résultat. Son prototype ou sa définition ne sont précédés d'aucun
type.
On obtient le résultat suivant en lançant l’application
18
Support de cours
3.5. Méthodes de lecture et d'écriture des attributs privés
Pour pouvoir lire ou écrire des attributs, on utilise les accesseurs et les modifieurs.
Dans classe principale, on a le script suivant pour pouvoir modifier ou accéder aux attributs de la
classe :
19
Support de cours
Il existe une autre façon d'avoir accès aux attributs d'une classe, c'est de créer des propriétés. Celles-ci
nous permettent de manipuler des attributs privés comme s'ils étaient publics.
3.6. La notion d’héritage
Le but de l'héritage est de "personnaliser" une classe existante pour qu'elle satisfasse à nos
besoins. Supposons qu'on veuille créer une classe Enseignant : un enseignant est une personne
particulière. Il a des attributs qu'une autre personne n'aura pas : la matière qu'il enseigne par exemple.
Mais il a aussi les attributs de toute personne : prénom, nom et âge. Un enseignant fait donc pleinement
partie de la classe Personne mais a des attributs supplémentaires.
Plutôt que d'écrire une classe Enseignant à partir de rien, on préfèrerait reprendre l'acquis de la
classe Personne qu'on adapterait au caractère particulier des
enseignants. C'est le concept d'héritage qui nous permet cela.
Pour exprimer que la classe Enseignant hérite des propriétés de la classe Personne, on écrira
public class Enseignant : Personne
20
Support de cours
Pour instancier la classe Enseignant, on a le code suivant :
4. Classes .NET d'usage courant
4.1. Les tableaux (la classe Array)
La classe Array possède diverses méthodes pour trier un tableau, rechercher un élément dans un
tableau, redimensionner un tableau, ...
21
Support de cours
4.2. La classe générique List<T>
La classe System.Collections.Generic.List<T> permet d'implémenter des collections d'objets de
type T dont la taille varie au cours de l'exécution du programme. Un objet de type List<T> se manipule
presque comme un tableau. Ainsi l'élément i d'une liste l est-il noté l[i]
Il existe également un type de liste non générique : ArrayList capable de stocker des références
sur des objets quelconques. ArrayList est fonctionnellement équivalente à List<Object>
Il faut qu'un objet soit d'abord créé avant d'ajouter sa référence à la liste ArrayList. Bien qu'un
ArrayList stocke des références d'objet, il est possible d'y stocker des nombres. Cela se fait par un
mécanisme appelé Boxing : le nombre est encapsulé dans un objet O de type Object et c'est la référence
0 qui est stocké dans la liste. C'est un mécanisme transparent pour le développeur.
On peut ainsi écrire :
ArrayList liste= new ArrayList() ;
liste.add(4) ;
Le nombre 4 a été encapsulé dans un objet O et la référence 0 est mémorisée dans la liste. Pour le
récupérer, on pourra écrire :
int i= (int)liste[0] ;
Méthodes
22
Support de cours
4.3. Les fichiers de texte
4.3.1. La classe StreamReader
23
Support de cours
4.3.2. La classe StreamWriter
24
Support de cours
25
Support de cours
26
Support de cours
5. Interface graphique
5.1. Découverte de l’interface graphique
Nous allons créer un nouveau projet « Application Windows Forms » qui va permettre de créer
une application avec une interface graphique.
27
Support de cours
On obtient une application Windows form
Pour visualiser l’ensemble du projet, il y a l’explorateur de solution qui se trouve en haut à droite.
La boite à outils permet de choisir les contrôles visuels pour l’application.
Pour pouvoir modifier les contrôles visuels, il y a le volet des propriétés qui se trouve en bas à droite.
Pour visualiser le code, il faut se positionner dans l’explorateur de position, puis faire un clic droit sur
form1.cs et afficher le code (ou F7)
28
Support de cours
29
Support de cours
Exemple d’utilisation d’un bouton et un texbox
30
Support de cours
On veut que le TextBox affiche « salut » quand on appuie sur le bouton « Mon bouton ».
On fait une double clique sur le bouton pour pouvoir faire un évènement clique.
En lançant l’application, on obtient :
31
Support de cours
5.2. Les évènements
Il existe plusieurs sortes d’évènements que nous pouvons consulter dans la propriété de l’objet via
l’icône sous forme d’éclair
Sur cette image, nous pouvons constater la liste des évènements qui peuvent être utilisés par
« button1 », ici c’est l’évènement « Click »
5.3. Les contrôles spécifiques
5.3.1. Checkbox et radio bouton
La propriété qui régit l’état d’un checkbox et d’un bouton radio est: Checked
Cette propriété est définie par true ou false. True pour dire que le checkbox ou le radio bouton est
coché.
32
Support de cours
Créons le projet suivant :
Evènement du bouton « Calculer »
33
Support de cours
En lançant l’application, on obtient le résultat suivant
Evènement du bouton « Afficher »
34
Support de cours
En lançant l’application, on obtient le résultat suivant
Evènement du bouton « Changer »
35
Support de cours
En lançant l’application, on obtient le résultat suivant
5.3.2. Les ComboBox
Créon un nouveau projet avec un ComboBox et ajoutons des items à sélectionner que nous afficherons
dans un TextBox
36
Support de cours
On ajoute des items dans le comboBox
La propriété utilisée pour récupérer la valeur sélectionnée est SelectedItem.
Faire un double clique sur le combobox pour pouvoir créer son évènement «SelectedIndexChanged »
37
Support de cours
6. Les bases de données
Nous allons créer un nouveau projet et y ajouter notre base de données
38
Support de cours
Ajouter une nouvelle source de donnée. Cliquer sur le lien pour ajouter, puis l’assistant de configuration
s’affiche et on choisit base de données
Choisir ensuite le modèle de base données.
39
Support de cours
Choisir la connexion de données et enregistrer la chaine de connexion
40
Support de cours
Choisir l’objet de base de données
Puis afficher les propriétés de la connexion de donnés dans l’explorateur de serveur
41
Support de cours
On va pouvoir ajouter une table et mettre à jours la BD
INDENTITY(1,1): valeur de départ 1, incrémentation 1
42
Support de cours
Après la mise à jour de la base de données, la table « cdan2 » est ajoutée
43
Support de cours
Ajoutons des données dans la table « cdan2 »
On crée une connexion et on l’ouvre dans l’évènement du bouton Ajoute et exécute une requête
44
Support de cours
En lançant l’application, on obtient le résultat suivant :
On affiche ensuite les données de la table pour visualiser les informations que nous avons ajouté
45
Support de cours
On va maintenant récupérer les données d’une base de données en utilisant le DataGridView.
Créons une nouvelle fenêtre.
On y ajoute ensuite notre DataGridView, et on ajoute la source de données du projet
46
Support de cours
Choisir ensuite une source de données et un modèle de base de données
Puis choisir la connexion de données
47
Support de cours
Pour terminer, choisir l’objet de base de données
En affichant Form2 on obtient:(On affiche Form2 à partir de notre bouton Ajouter)
48
Support de cours
7. Interface graphique avec WPF
7.1. XAML (Extensible Application Markup Language)
XAML décrit une arborescence d’objet graphique. Une page, une Window, un UserControl sont
conçu graphiquement par glisser-déposer de composant dans un fichier .xaml. Le code est associé pour
réagir aux évènements dans un fichier .cs.
XAML permet d’instancier des objets graphiques, mais aussi n’importe quelle catégorie d’objet
.net.
Propriété .net :
Syntaxe permettant de décrire pleinement une propriété objet :
Les sont souvent décrit en XAML, mais peuvent aussi être instanciés en .net :
Il faut aussi bien nommer les composants, ce qui va permettre de les utiliser dans la page après
l’appel de InitializeComponent dans l’évènement Loaded.
On peut aussi associer des évènements avec XAML :
49
Support de cours
On peut aussi créer des évènements via le concepteur graphique :
7.2. Première application WPF
50
Support de cours
Nous allons maintenant faire un petit exemple avec des boutons pour mieux comprendre WPF :
51
Support de cours
On peut par la suite personnaliser le design de nos boutons ou de notre Grid dans propriétés:
On peut consulter le XAML du bouton1 avec les modifications de design que nous avons effectué :
On va ensuite ajouter des évènements dans nos boutons en faisant une double clique ou en choisissant
d’aller dans propriétés :
52
Support de cours
On obtient alors comme résultat en lançant l’application :
7.3. Les familles de composants
De nombreux contrôles existent, on peut les regrouper en familles : ContentControls,
HeaderedControls, ItemsControls, Panels, …
Exemple d’objet qui ont des propriétés ContentControls, qui leurs permettent d’avoir des enfants :
53
Support de cours
L’objet bouton par exemple a une propriété content qui peut contenir :
Du texte
Un autre composant graphique
Les HeaderedControls héritent des ContentControls et ont un Header en plus :
Nous allons créer un nouveau projet pour mieux comprendre ces contrôles, et nous allons ajouter
manuellement un bouton, et une image et un texte dans ce même bouton :
54
Support de cours
Nous allons ensuite créer un nouveau XAML que nous allons appeler via l’évènement click du bouton
55
Support de cours
Nous allons maintenant ajouter l’évènement de notre bouton pour appeler cette nouvelle fenêtre :
56
Support de cours
Comme résultat, on obtient :
57
Support de cours
8. Exemple d’application wpf avec une base de données PostGres
Créer les fenêtres suivantes
58
Support de cours
Voici l’évènement pour ajouter une personne et afficher une seconde fenêtre
La seconde fenêtre contient la liste des personnes dans la base de données, un formulaire permettant la
modification et la suppression d’une personne.
Chargement du DataGrid
59
Support de cours
XAML du DataGrid pour lier la Classe Personne avec le DataGrid
60
Support de cours
Pour afficher l’élément sélectionné du DataGrid sur le formulaire
61
Support de cours
Pour modifier une Personne dans la base
62
Support de cours
Pour supprimer une Personne de la base
63
6
