+ QUIZ - fnac-static.com€¦ · 29,90 € ISBN : 978-2-409-02280-7 Ce livre s’adresse aux développeurs souhaitant maîtriser le développe- ment d’applications .NET avec le

ISBN

: 97

8-2-

409-

0228

0-7

29,9

0 €

Ce livre s’adresse aux développeurs souhaitant maîtriser le développe-ment d’applications .NET avec le langage C# dans sa version 8.

Après un tour d’horizon de la plateforme .NET et une description des outils fournis par l’environnement Visual Studio 2019, le lecteur décou-vrira progressivement les éléments clés du langage C# et la program-mation orientée objet, jusqu’à pouvoir appliquer ce concept au déve-loppement d’applications Windows avec WPF. Une initiation aux techniques de débogage avec Visual Studio lui permettra de parfaire sa maîtrise de l’outil.

Le développement d’applications client-serveur est ensuite traité par le thème de l’accès aux données avec ADO.NET. Une description com-plète de LINQ au travers d’exemples concrets montre comment ses fonctionnalités simplifient la manipulation des données. Son utilisation est notamment présentée dans le cadre de l’accès au contenu d’une base de données SQL Server avec Entity Framework Core. Un chapitre est ensuite consacré à la manipulation de données au format XML, permettant l’échange de données entre applications d’une manière simple et standardisée. La fin du cycle de développement est traitée à travers le déploiement d’une application avec les technologies Windows Installer, ClickOnce et MSIX.

Afin d’aider le lecteur dans son apprentissage, un aide-mémoire est fourni ; il résume l’utilité des mots-clés C# traités dans le livre.

Les exemples présentés dans ces pages sont disponibles en télécharge-ment sur le site www.editions-eni.fr.

Sébastien PUTIER

Consultant et Formateur depuis plu-sieurs années, Sébastien PUTIER apporte son expertise dans la mise en œuvre de solutions Windows, Web et mobiles avec la plateforme .NET depuis ses premières ver-sions. Il est certifié techniquement (MCPD - MCSD) et pédagogique-ment (MCT) par Microsoft. À travers les pages de ce livre, il transmet toute son expérience sur le langage C# pour que le lecteur acquière les fondamentaux et soit capable de tirer le meilleur parti possible des fonctionnalités offertes par la plate-forme .NET.

C# 8 et Visual Studio 2019Les fondamentaux du langage

C# 8

et V

isua

l Stu

dio

2019

Le

s fo

ndam

enta

ux d

u la

ngag

e

Pour plus d’informations :

C# 8et Visual Studio 2019

Les fondamentaux du langage

Téléchargementwww.editions-eni.fr.fr

sur www.editions-eni.fr : b Le code source

des exemples traités dans le livre.

Sébastien PUTIER

En téléchargement

le code source

+ QUIZ

Version en ligne

OFFERTE !pendant 1 an

1Table des matières

Avant-propos

Chapitre 1La plateforme .NET

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2. Historique de la plateforme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

3. Évolution de la plateforme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253.1 .NET Standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253.2 .NET Compiler Platform : Roslyn . . . . . . . . . . . . . . . . . . . . . . . . 263.3 .NET dans le monde open source . . . . . . . . . . . . . . . . . . . . . . . . 27

Les éléments à télécharger sont disponibles à l'adresse suivante :http://www.editions-eni.fr

Saisissez la référence ENI de l'ouvrage RI19CSHA dans la zone de recherche et validez. Cliquez sur le titre du livre puis sur le bouton de téléchargement.

4. Le Common Language Runtime (CLR). . . . . . . . . . . . . . . . . . . . . . . . 28

5. La Base Class Library (BCL) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

6. Le Dynamic Language Runtime (DLR) . . . . . . . . . . . . . . . . . . . . . . . . 32

7. Une première application avec C# . . . . . . . . . . . . . . . . . . . . . . . . . . . 337.1 Création. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337.2 Compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377.3 Analyse de l'assembly . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

7.3.1 Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417.3.2 Exploration avec ILDASM . . . . . . . . . . . . . . . . . . . . . . . . . 42

lcroise

Tampon

2
C# 8 et Visual Studio 2019

Chapitre 2Visual Studio 2019

1. Installation et premier lancement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471.1 Prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471.2 Éditions de Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

1.2.1 Visual Studio Community. . . . . . . . . . . . . . . . . . . . . . . . . 481.2.2 Éditions commerciales . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

1.3 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501.4 Premier lancement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

2. Description des outils. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642.1 Barres d'outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 682.2 Explorateur de solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 702.3 Explorateur d'objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 712.4 Explorateur de serveurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 722.5 Fenêtre de propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 762.6 Fenêtre d'édition de code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

2.6.1 Navigation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 792.6.2 Suivi des modifications . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
2.6.3 Mise en surbrillance des références . . . . . . . . . . . . . . . . . . 802.6.4 Refactorisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 812.6.5 IntelliSense . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 832.6.6 Snippets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
Chapitre 3L'organisation d'une application

1. Les solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 851.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 851.2 Création d'une solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 861.3 Organisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 871.4 Actions disponibles sur une solution . . . . . . . . . . . . . . . . . . . . . 88

1.4.1 Ajout et suppression d'un projet . . . . . . . . . . . . . . . . . . . . 881.4.2 Création d'un dossier de solution . . . . . . . . . . . . . . . . . . . 89


1.4.3 Chargement et déchargement d'un projet . . . . . . . . . . . . 901.4.4 Création d'un fichier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 911.4.5 Génération de la solution . . . . . . . . . . . . . . . . . . . . . . . . . . 91

1.5 Configuration de la solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . 921.5.1 Configuration des projets de démarrage . . . . . . . . . . . . . . 921.5.2 Dépendances du projet. . . . . . . . . . . . . . . . . . . . . . . . . . . . 941.5.3 Paramètres d'analyse du code. . . . . . . . . . . . . . . . . . . . . . . 951.5.4 Fichiers sources pour le débogage . . . . . . . . . . . . . . . . . . . 951.5.5 Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

2. Les projets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 972.1 Création d'un projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 972.2 Propriétés d'un projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

2.2.1 Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1032.2.2 Build . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1052.2.3 Événements de build . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1092.2.4 Package . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1102.2.5 Déboguer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1112.2.6 Ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
2.2.7 Paramètres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Chapitre 4Les bases du langage

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

2. Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1172.1 Nommage des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1182.2 Type des variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119

2.2.1 Types valeurs et types références . . . . . . . . . . . . . . . . . . 1192.2.2 Types intégrés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

2.3 Déclaration des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1242.4 Portée des variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1252.5 Modificateurs d'accès . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1262.6 Le mot-clé var et l'inférence de type . . . . . . . . . . . . . . . . . . . . . 126

4

3. Les constantes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

4. Les opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1284.1 Les opérateurs d’accès. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

4.1.1 Accès simple : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1294.1.2 Accès indexé : [ ] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1294.1.3 Accès avec nullité conditionnelle : ? . . . . . . . . . . . . . . . . 130

4.2 Les opérateurs arithmétiques. . . . . . . . . . . . . . . . . . . . . . . . . . . 1314.3 Les opérateurs de comparaison . . . . . . . . . . . . . . . . . . . . . . . . . 1314.4 Les opérateurs conditionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

4.4.1 Opérateur ternaire : ? ... : . . . . . . . . . . . . . . . . . . . . . . . . 1324.4.2 Opérateur de fusion de valeur nulle : ?? . . . . . . . . . . . . . 133

4.5 Les opérateurs logiques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1334.5.1 Négation : ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1334.5.2 ET logique : &. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1344.5.3 OU logique : | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1344.5.4 OU exclusif : ^ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1344.5.5 ET conditionnel : &&. . . . . . . . . . . . . . . . . . . . . . . . . . . . 1354.5.6 OU conditionnel : || . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135

4.6 Les opérateurs binaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1364.6.1 ET binaire : & . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1364.6.2 OU binaire : | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1364.6.3 OU exclusif : ^ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1374.6.4 Négation : ~ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1374.6.5 Décalage vers la droite : >> . . . . . . . . . . . . . . . . . . . . . . 1374.6.6 Décalage vers la gauche : << . . . . . . . . . . . . . . . . . . . . . 138

5. Les structures de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1385.1 Les structures conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . 138

5.1.1 if ... else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1385.1.2 switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1405.1.3 Le pattern matching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

5.2 Les structures d'itération . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1465.2.1 for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1465.2.2 while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147


5.2.3 do ... while. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1475.2.4 foreach. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1475.2.5 Contrôler l'exécution d'une boucle . . . . . . . . . . . . . . . . . 148

5.3 Autres structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1495.3.1 using . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1495.3.2 goto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

6. Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1516.1 Écriture d'une fonction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1516.2 Paramètres de fonction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1536.3 Procédures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1586.4 Surcharges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1586.5 Fonctions locales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160

7. Les tuples. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

8. Les attributs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164

Chapitre 5La programmation orientée objet avec C#

1. Les principes de la programmation orientée objet . . . . . . . . . . . . . . 165

2. Les classes et les structures. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1682.1 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168

2.1.1 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1692.1.2 Constructeur et destructeur . . . . . . . . . . . . . . . . . . . . . . 1712.1.3 Classes partielles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175

2.2 Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1762.3 Création de méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177

2.3.1 Création. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1772.3.2 Méthodes partielles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1792.3.3 Méthodes d'extension . . . . . . . . . . . . . . . . . . . . . . . . . . . 1802.3.4 Méthodes opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182

2.4 Création de propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1842.4.1 Lecture et écriture. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184

6

2.4.2 Lecture seule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1852.4.3 Écriture seule. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1862.4.4 Propriétés automatiques . . . . . . . . . . . . . . . . . . . . . . . . . 1862.4.5 Initialisation de propriétés automatiques . . . . . . . . . . . . 1872.4.6 Propriétés automatiques en lecture seule . . . . . . . . . . . . 1882.4.7 Propriétés indexées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188

2.5 Membres statiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1892.6 Utilisation des classes et structures. . . . . . . . . . . . . . . . . . . . . . 190

2.6.1 Instanciation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1902.6.2 Initialisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1912.6.3 Types anonymes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192

3. Les espaces de noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1953.1 Nomenclature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1953.2 using . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

4. L'héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1984.1 Mise en œuvre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1984.2 Les mots-clés this et base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1994.3 Redéfinition et masquage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200

4.3.1 Redéfinition de méthode . . . . . . . . . . . . . . . . . . . . . . . . . 2014.3.2 Masquage de méthode . . . . . . . . . . . . . . . . . . . . . . . . . . . 2024.3.3 Différences entre redéfinition et masquage . . . . . . . . . . 202

4.4 Imposer ou interdire l'héritage. . . . . . . . . . . . . . . . . . . . . . . . . . 2054.5 Le transtypage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206

5. Les interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2085.1 Création . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2095.2 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211

5.2.1 Implémentation implicite . . . . . . . . . . . . . . . . . . . . . . . . 2125.2.2 Implémentation explicite. . . . . . . . . . . . . . . . . . . . . . . . . 214

6. Les énumérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216

7. Les délégués. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2167.1 Création . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2177.2 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217


7.3 Expressions lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218

8. Les événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2198.1 Déclaration et déclenchement . . . . . . . . . . . . . . . . . . . . . . . . . . 2198.2 Gestion des événements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221

9. Les génériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2229.1 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223

9.1.1 Définition d'une classe générique . . . . . . . . . . . . . . . . . . 2239.1.2 Utilisation d'une classe générique . . . . . . . . . . . . . . . . . . 224

9.2 Interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2249.2.1 Définition d'une interface générique . . . . . . . . . . . . . . . . 2259.2.2 Utilisation d'une interface générique . . . . . . . . . . . . . . . 226

9.3 Contraintes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2279.4 Méthodes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232

9.4.1 Définition d'une méthode générique. . . . . . . . . . . . . . . . 2329.4.2 Utilisation d'une méthode générique . . . . . . . . . . . . . . . 234

9.5 Événements et délégués . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234

10. Les collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
10.1 Types existants. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
10.1.1Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23710.1.2ArrayList et List<T> . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23710.1.3Hashtable et Dictionary<TKey, TValue>. . . . . . . . . . . 24110.1.4Stack et Stack<T> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24410.1.5Queue et Queue<T>. . . . . . . . . . . . . . . . . . . . . . . . . . . . 244

10.2 Choisir un type de collection . . . . . . . . . . . . . . . . . . . . . . . . . . . 245

11. La programmation dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245

12. La programmation asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24812.1 Les objets Task . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24812.2 Écrire du code asynchrone avec async et await . . . . . . . . . . . . 251

8

Chapitre 6Le débogage et la gestion des erreurs

1. Les différents types d'erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2531.1 Erreurs de compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2531.2 Erreurs d'exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255

2. Utilisation des exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2562.1 Création et déclenchement d'exceptions . . . . . . . . . . . . . . . . . 256

2.1.1 La classe Exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2562.1.2 Le mot-clé throw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2572.1.3 Exceptions spécialisées . . . . . . . . . . . . . . . . . . . . . . . . . . . 257

2.2 Gérer les exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2582.2.1 La structure try ... catch . . . . . . . . . . . . . . . . . . . . . . . . . . 2582.2.2 Les filtres d’exception. . . . . . . . . . . . . . . . . . . . . . . . . . . . 2612.2.3 Le bloc finally . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262

3. Les outils fournis par Visual Studio. . . . . . . . . . . . . . . . . . . . . . . . . . 2643.1 Contrôle de l'exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264

3.1.1 Démarrage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
3.1.2 Arrêt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2663.1.3 Pause . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2663.1.4 Reprise. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
3.2 Points d'arrêt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2673.3 Visualiser le contenu des variables . . . . . . . . . . . . . . . . . . . . . . 274

3.3.1 DataTips . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2743.3.2 Fenêtres Espion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2753.3.3 Fenêtre Espion express . . . . . . . . . . . . . . . . . . . . . . . . . . . 2763.3.4 Fenêtre Automatique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2773.3.5 Fenêtre Variables locales . . . . . . . . . . . . . . . . . . . . . . . . . 277

3.4 Compilation conditionnelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277

4. L’erreur à un milliard de dollars : les références nulles . . . . . . . . . . . 2804.1 NullReferenceException. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2814.2 Une solution : l'utilisation de types références non-nuls. . . . . 283


Chapitre 7Le développement d'applications Windows

1. Présentation de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2891.1 Structure d'une application WPF. . . . . . . . . . . . . . . . . . . . . . . . 2901.2 XAML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291

1.2.1 Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2921.2.2 Espaces de noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293

1.3 Contexte de données et binding . . . . . . . . . . . . . . . . . . . . . . . . 294

2. Utilisation des contrôles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2982.1 Ajout de contrôles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2992.2 Positionnement et dimensionnement des contrôles . . . . . . . . 3022.3 Ajout d'un gestionnaire d'événements à un contrôle . . . . . . . . 305

3. Les principaux contrôles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3073.1 Contrôles de fenêtrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308

3.1.1 Window. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3083.1.2 NavigationWindow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311

3.2 Contrôles de disposition. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
3.2.1 Grid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3133.2.2 StackPanel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3163.2.3 DockPanel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3173.2.4 WrapPanel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3193.2.5 Canvas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320
3.3 Contrôles d'affichage de données . . . . . . . . . . . . . . . . . . . . . . . 3213.3.1 TextBlock . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3213.3.2 Label . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3223.3.3 Image . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3243.3.4 ScrollViewer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3253.3.5 ItemsControl. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3253.3.6 StatusBar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3293.3.7 ToolTip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329

10

3.4 Contrôles d'édition de texte. . . . . . . . . . . . . . . . . . . . . . . . . . . . 3303.4.1 TextBox. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3303.4.2 RichTextBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3313.4.3 PasswordBox. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333

3.5 Contrôles de sélection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3343.5.1 RadioButton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3343.5.2 CheckBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3343.5.3 ComboBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3353.5.4 ListBox. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3363.5.5 ListView . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3373.5.6 TreeView. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3403.5.7 Slider . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3453.5.8 Calendar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3453.5.9 DatePicker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346

3.6 Contrôles d'action. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3463.6.1 Button . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3473.6.2 Menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3473.6.3 ContextMenu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
3.6.4 ToolBar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
4. Interactions clavier et souris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3524.1 Événements clavier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3524.2 Événements souris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3554.3 Glisser-déposer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357

5. Aller plus loin avec WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3605.1 Introduction à l'utilisation de Blend . . . . . . . . . . . . . . . . . . . . . 360

5.1.1 L'interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3615.1.2 Ajout et modification de contrôles visuels . . . . . . . . . . . 368

5.2 Introduction à MVVM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3715.2.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3715.2.2 Les interfaces INotifyPropertyChanged

et INotifyCollectionChanged . . . . . . . . . . . . . . . . . . . . . 3725.2.3 Commandes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3735.2.4 Mise en œuvre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373

1
Chapitre 8L’accès aux données

1. Principes d'une base de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3891.1 Terminologie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3891.2 Le langage SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390

1.2.1 Recherche d'enregistrements . . . . . . . . . . . . . . . . . . . . . . 3911.2.2 Ajout d'enregistrements . . . . . . . . . . . . . . . . . . . . . . . . . . 3931.2.3 Mise à jour d'informations. . . . . . . . . . . . . . . . . . . . . . . . 3931.2.4 Suppression d'informations . . . . . . . . . . . . . . . . . . . . . . . 394

2. ADO.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3942.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3942.2 Les fournisseurs de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395

2.2.1 SQL Server. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3962.2.2 OLE DB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3962.2.3 ODBC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397

3. Utiliser ADO.NET en mode connecté. . . . . . . . . . . . . . . . . . . . . . . . 3973.1 Connexion à une base de données. . . . . . . . . . . . . . . . . . . . . . . 398

3.1.1 Chaînes de connexion . . . . . . . . . . . . . . . . . . . . . . . . . . . 3983.1.2 Pools de connexions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4013.1.3 Gestion de la connexion. . . . . . . . . . . . . . . . . . . . . . . . . . 403

3.2 Création et exécution de commandes . . . . . . . . . . . . . . . . . . . . 4053.2.1 Définition et création d'une commande . . . . . . . . . . . . . 4063.2.2 Sélection de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4063.2.3 Actions sur les données . . . . . . . . . . . . . . . . . . . . . . . . . . 4083.2.4 Paramétrage d'une commande . . . . . . . . . . . . . . . . . . . . . 4083.2.5 Exécution de procédures stockées . . . . . . . . . . . . . . . . . . 411

4. Utiliser ADO.NET en mode déconnecté. . . . . . . . . . . . . . . . . . . . . . 4134.1 DataSet et DataTable. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413

4.1.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4134.1.2 Remplissage d'un DataSet

à partir d'une base de données . . . . . . . . . . . . . . . . . . . . . 4144.1.3 Remplissage d'un DataSet sans base de données . . . . . . 417

12

4.2 Manipulation des données hors connexion . . . . . . . . . . . . . . . 4204.2.1 Lecture des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4214.2.2 Création de contraintes . . . . . . . . . . . . . . . . . . . . . . . . . . 4214.2.3 Relations entre DataTables . . . . . . . . . . . . . . . . . . . . . . . 4254.2.4 État et versions d'une DataRow . . . . . . . . . . . . . . . . . . . 4274.2.5 Modification de données . . . . . . . . . . . . . . . . . . . . . . . . . 4284.2.6 Suppression de données . . . . . . . . . . . . . . . . . . . . . . . . . . 4304.2.7 Valider ou annuler des modifications . . . . . . . . . . . . . . . 4304.2.8 Filtrage et tri à l'aide d'une DataView. . . . . . . . . . . . . . . 4314.2.9 Recherche de données . . . . . . . . . . . . . . . . . . . . . . . . . . . 434

4.3 Valider les modifications au niveau de la base de données . . . 4364.3.1 Générer des commandes

de mise à jour automatiquement . . . . . . . . . . . . . . . . . . 4374.3.2 Commandes de mise à jour personnalisées. . . . . . . . . . . 4394.3.3 Gestion des accès concurrentiels . . . . . . . . . . . . . . . . . . . 440

5. Utiliser les transactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442

Chapitre 9LINQ

1. Présentation de LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445

2. Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4462.1 Une première requête LINQ . . . . . . . . . . . . . . . . . . . . . . . . . . . 4492.2 Les opérateurs de requête . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452

2.2.1 Projection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4522.2.2 Filtrage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4542.2.3 Triage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4562.2.4 Partitionnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4572.2.5 Jointure et regroupement. . . . . . . . . . . . . . . . . . . . . . . . . 4582.2.6 Agrégation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461

3. Entity Framework Core . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4633.1 Les principes du mappage objet-relationnel . . . . . . . . . . . . . . . 463

3.1.1 Les principes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463

3
3.2 Mise en place. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4653.2.1 Génération du code à partir d’une base de données . . . . 4673.2.2 Création d‘une base de données avec du code . . . . . . . . 481

3.3 Utilisation de LINQ avec Entity Framework Core. . . . . . . . . . 4833.3.1 Récupération de données . . . . . . . . . . . . . . . . . . . . . . . . . 4843.3.2 Mise à jour de données. . . . . . . . . . . . . . . . . . . . . . . . . . . 4863.3.3 Gestion des conflits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488

Chapitre 10XML

1. Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493

2. Structure d'un fichier XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4942.1 Constituants d'un document XML . . . . . . . . . . . . . . . . . . . . . . 4942.2 Document bien formé et document valide . . . . . . . . . . . . . . . . 498

3. Manipuler un document XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4993.1 Utilisation de DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5003.2 Utilisation de XPath . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505
3.3 Utilisation de LINQ to XML . . . . . . . . . . . . . . . . . . . . . . . . . . . 508
Chapitre 11Le déploiement

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513

2. Windows Installer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5142.1 Création d'un projet d'installation . . . . . . . . . . . . . . . . . . . . . . 515

2.1.1 Opérations sur le système de fichiers . . . . . . . . . . . . . . . 5172.1.2 Opérations sur le registre de la machine cible . . . . . . . . 5212.1.3 Configuration de l’installation par l’utilisateur . . . . . . . 5222.1.4 Exécution d’actions personnalisées . . . . . . . . . . . . . . . . . 5242.1.5 Conditions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 525

3. Fichiers binaires (.exe, .dll) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527

14

4. ClickOnce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5334.1 La technologie ClickOnce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533

4.1.1 Principes de fonctionnement . . . . . . . . . . . . . . . . . . . . . . 5344.1.2 Méthodes de déploiement disponibles . . . . . . . . . . . . . . 5354.1.3 Les mises à jour d'applications avec ClickOnce . . . . . . . 536

4.2 La publication ClickOnce. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538

5. MSIX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547

Chapitre 12Aide-mémoire

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583

17
1
Chapitre 4Les bases du langage

Les bases du langage1. IntroductionComme tous les langages de programmation, C# impose certaines règles audéveloppeur. Ces règles se manifestent au travers de la syntaxe du langagemais elles couvrent le large spectre fonctionnel proposé par C#. Avantd'explorer en profondeur les fonctionnalités du langage au chapitre suivant,
nous étudierons donc les notions essentielles et fondamentales de C# : lacréation de données utilisables par une application et le traitement de cesdonnées.
2. Les variablesLes données utilisables dans un programme C# sont représentées par des va-riables. Une variable est un espace mémoire réservé auquel on assigne arbitrai-rement un nom et dont le contenu est une valeur dont le type est fixé. Onpeut manipuler ce contenu dans le code en utilisant le nom de la variable.

lcroise

Tampon

118Les fondamentaux du langage


2.1 Nommage des variables

La spécification du langage C# établit quelques règles à prendre en comptelorsque l'on nomme une variable :

– Le nom d'une variable ne peut comporter que des chiffres, des caractères del'alphabet latin accentués ou non, le caractère ç ou les caractères spéciaux _et μ.

– Le nom d'une variable ne peut en aucun cas commencer par un chiffre. Ilpeut en revanche en comporter un ou plusieurs à toute autre position.

– Le langage est sensible à la casse, c’est-à-dire qu'il fait la distinction entremajuscules et minuscules : les variables unevariable et uneVariablesont donc différentes.

– La longueur d’un nom de variable est virtuellement illimitée : le compilateurne remonte pas d’erreur lorsqu’il est composé de 30 000 caractères ! Il n'estévidemment pas recommandé d'avoir des noms de variables aussi longs, lemaximum en pratique étant plus souvent de l'ordre de la trentaine de carac-tères.

– Le nom d'une variable ne peut pas être un mot-clé du langage. Il est toutefois

© E

diti

ons

ENI -

All

righ

ts r

eser

ved

possible de préfixer un mot-clé par un caractère autorisé ou par lecaractère @ pour utiliser un nom de variable similaire.

Les noms de variables suivants sont acceptés par le compilateur C# :

– maVariable– maVariableNumero1– @void (void est un mot-clé de C#)

– µn3_VàRïãbl3De manière générale, il est préférable d'utiliser des noms de variables explicites,c’est-à-dire permettant de savoir à quoi correspond la valeur stockée dans lavariable, comme nomClient, montantAchat ou ageDuCapitaine.

19
1Les bases du langageChapitre 4
2.2 Type des variables

Une des caractéristiques de C# est la notion de typage statique : chaquevariable correspond à un type de données et ne peut en changer. De plus, cetype doit être déterminable au moment de la compilation.

2.2.1 Types valeurs et types références

Les différents types utilisables en C# peuvent être décomposés en deuxfamilles : les types valeurs et les types références. Cette notion peut êtredéconcertante au premier abord, puisqu'une variable représente justementune donnée et donc une valeur. Ce concept est en fait lié à la manière dont eststockée l'information en mémoire.

Lorsque l'on utilise une variable de type valeur, on accède directement à la zonemémoire stockant la donnée. Au moment de la création d'une variable de typevaleur, une zone mémoire de la taille correspondant au type est allouée.Chaque octet de cette zone est automatiquement initialisé avec la valeurbinaire 00000000. Notre variable aura donc une suite de 0 pour valeur binaire.

Dans le cas d'une variable de type référence, le comportement est différent. La
zone mémoire allouée à notre variable contient une adresse mémoire à laquelleest stockée la donnée. On passe donc par un intermédiaire pour accéder ànotre donnée. L'adresse mémoire est initialisée avec la valeur spéciale null,qui ne pointe sur rien, tandis que la zone mémoire contenant les données n'estpas initialisée. Elle sera initialisée lorsque la variable sera instanciée. Dans lemême temps, l'adresse mémoire stockée dans notre variable sera mise à jour.
Une variable de type référence pourra donc ne contenir aucune donnée, tandisqu'une variable de type valeur aura forcément une valeur correspondant à unesuite de 0 binaires.

Cette différence de fonctionnement a une conséquence importante : la copiede variable se fait par valeur ou par référence, ce qui signifie qu'une variable detype valeur sera effectivement copiée, tandis que pour un type référence, c'estl'adresse que contient la variable qui sera copiée, et il sera donc possible d'agirsur la donnée réelle indifféremment à partir de chacune des variables pointantsur ladite donnée.



2.2.2 Types intégrés

La plateforme .NET embarque plusieurs milliers de types différents utilisablespar les développeurs. Parmi ces types, nous en avons une quinzaine que l'onpeut considérer comme fondamentaux : ce sont les types intégrés (aussinommés types primitifs). Ce sont les types de base à partir desquels sontconstruits les autres types de la BCL ainsi que ceux que le développeur créedans son propre code. Ils permettent de définir des variables contenant desdonnées très simples.

Ces types ont comme particularité d'avoir chacun un alias intégré à C#.

Types numériques

Ces types permettent de définir des variables numériques entières ou déci-males. Ils couvrent des plages de valeurs différentes et ont chacun une préci-sion spécifique. Certains types seront donc plus adaptés pour les calculsentiers, d'autres pour les calculs dans lesquels la précision décimale est trèsimportante, comme les calculs financiers.

Les différents types numériques sont énumérés ci-dessous avec leurs alias ainsique les plages de valeurs qu'ils couvrent.

© E

diti

ons

ENI -

All

righ

ts r

eser

ved

Type Alias C# Plage de valeurs couverte

Taille en mémoire

System.Byte byte 0 à 255 1 octet

System.SByte sbyte -128 à 127 1 octet

System.Int16 short -32768 à 32767 2 octets

System.UInt16 ushort 0 à 65535 2 octets

System.Int32 int -2147483648 à 2147483647 4 octets

System.UInt32 uint 0 à 4294967295 4 octets

System.Int64 long -9223372036854775808 à 9223372036854775807

8 octets

System.UInt64 ulong 0 à 18446744073709551615 8 octets

System.Single float ±1,5e-45 à ±3,4e38 4 octets

21
1Les bases du langageChapitre 4
Les types numériques primitifs sont tous des types valeurs. Une variable detype numérique et non initialisée par le développeur aura pour valeur pardéfaut 0.

Remarque.NET 4 a apporté le type System.Numerics.BigInteger afin de manipulerdes entiers d'une taille arbitraire. Ce type est aussi un type valeur, mais il ne faitpas partie des types intégrés.

Les valeurs numériques utilisées au sein du code peuvent être définies à l’aidede trois bases numériques :

– Décimale (base 10) : c’est la base numérique utilisée par défaut.Exemple : 280514

System.Double double ±5,0e-324 à ±1,7e308 8 octets

System.Decimal decimal ±1,0e-28 à ±7,9e28 16 octets

Type Alias C# Plage de valeurs couverte

Taille en mémoire

– Héxadécimale (base 16) : elle est très utilisée dans le monde du Web, pourla définition de couleurs, et plus généralement pour encoder des valeurs nu-mériques dans un format plus condensé. Une valeur héxadécimale estécrite en la préfixant par 0x.Exemple : 0x0447C2

– Binaire (base 2) : cette base est celle qui permet de s’approcher au plus prèsde la manière dont la machine interprète le code compilé. L’utilisation dubinaire en C# peut par conséquent se révéler précieuse dans le cadre d’opti-misations (décalages de bits au lieu de multiplications par 2, stockage demultiples données au sein d’une même variable, etc.). Les valeursbinaires sont préfixées par 0b.Exemple : 0b01000100011111000010



La lecture de valeurs numériques peut s’avérer difficile dans certains cas, no-tamment lorsqu’elles sont représentées sous forme binaire. L’équipe en chargedes évolutions de C# a intégré, dans la septième version du langage, la possi-bilité d’ajouter des séparateurs dans les valeurs numériques afin d’améliorer lalisibilité globale. Le caractère utilisé pour cela est _ :

– 280_514

– 0x04_47_C2

– 0b0100_0100_0111_1100_0010

Types textuels

Il existe dans la BCL deux types permettant de manipuler des caractèresUnicode et des chaînes de caractères Unicode : System.Char etSystem.String. Ces types ont respectivement pour alias char et string.

Le type char est un type valeur encapsulant les mécanismes nécessaires autraitement d'un caractère Unicode. Par conséquent, une variable de type charest stockée en mémoire sur deux octets.

Les valeurs de type char doivent être encadrées par les caractères ' ' : 'a'.

© E

diti

ons

ENI -

All

righ

ts r

eser

ved

Certains caractères ayant une signification particulière pour le langagedoivent être utilisés avec le caractère d'échappement \ afin d'être correctementinterprétés. D'autres caractères n'ayant pas de représentation graphiquedoivent être aussi déclarés avec des séquences spécifiques. Le tableau suivantrésume les séquences qui peuvent être utilisées.

Séquence d'échappement Caractère associé

\' Simple quote '

\'' Double quote "

\\ Backslash \

\a Alerte sonore

\b Retour arrière

\f Saut de page

\n Saut de ligne

Documents

+ QUIZ - fnac-static.com€¦ · 29,90 € ISBN : 978-2-409-02280-7 Ce livre s’adresse aux développeurs souhaitant maîtriser le développe- ment d’applications .NET avec le