C# 7 et Visual Studio 2017 · 29,90 € ISBN : 978-2-409-01045-3 Ce livre s’adresse aux développeurs souhaitant maîtriser le développe- ment d’applications .NET avec le langage

ISBN

: 97

8-2-

409-

0104

5-3

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 7.

Après un tour d’horizon de la plateforme .NET et une description des outils fournis par l’environnement Visual Studio 2017, le lecteur découvrira progressivement les éléments clés du langage C# et la programmation orientée objet, jusqu’à pouvoir appliquer ce concept au développement d’applications Windows avec WPF. Une initiation aux techniques de débogage avec Visual Studio lui permettra de par-faire 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. Un chapitre est ensuite consacré à la manipulation de données au format XML, permet-tant 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 puis ClickOnce.

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. À tra-vers les pages de ce livre, il trans-met toute son expérience sur le langage C# pour que le lecteur acquiert les fondamentaux et soit capable de tirer le meilleur parti possible des fonctionnalités offertes par la plateforme .NET.

C# 7 et Visual Studio 2017Les fondamentaux du langage

C# 7

et V

isua

l Stu

dio

2017

Le

s fo

ndam

enta

ux d

u la

ngag

e

Pour plus d’informations :

Les chapitres du livre

Avant-propos • La plateforme .NET • Visual Studio 2017 • L’organisation d’une application • Les bases du langage • La programmation orientée objet avec C# • Le débogage et la gestion des erreurs • Le développe-ment d’applications Windows • L’accès aux données • LINQ • XML • Le déploiement • Aide-mémoire

C# 7et Visual Studio 2017

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

1Table des matières

Avant-propos

Chapitre 1La plateforme .NET

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

2. Historique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

3. Le Common Language Runtime (CLR). . . . . . . . . . . . . . . . . . . . . . . . 23

4. La Base Class Library (BCL) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

5. Le Dynamic Language Runtime (DLR) . . . . . . . . . . . . . . . . . . . . . . . . 27

6. Évolution de la plateforme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

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 RI17CSHA dans la zone de recherche et validez. Cliquez sur le titre du livre puis sur le bouton de téléchargement.

6.1 .NET Core . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286.2 .NET Compiler Platform : Roslyn . . . . . . . . . . . . . . . . . . . . . . . . 296.3 .NET dans le monde open source . . . . . . . . . . . . . . . . . . . . . . . . 30

7. Une première application avec Visual C# . . . . . . . . . . . . . . . . . . . . . 317.1 Création. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317.2 Compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337.3 Analyse de l'assembly . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

7.3.1 Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357.3.2 Exploration avec ILDASM . . . . . . . . . . . . . . . . . . . . . . . . 36

lcroiseTampon

2


C# 7 et Visual Studio 2017

Chapitre 2Visual Studio 2017

1. Installation et premier lancement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411.1 Prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411.2 Éditions de Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

1.2.1 Visual Studio Community . . . . . . . . . . . . . . . . . . . . . . . . 421.2.2 Éditions commerciales. . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

1.3 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441.4 Premier lancement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

2. Description des outils. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542.1 Barres d'outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592.2 Explorateur de solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 602.3 Explorateur d'objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 612.4 Explorateur de serveurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 622.5 Fenêtre de propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 662.6 Fenêtre d'édition de code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

2.6.1 Navigation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 692.6.2 Suivi des modifications . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

2.6.3 Mise en surbrillance des références . . . . . . . . . . . . . . . . . 702.6.4 Refactorisation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 712.6.5 IntelliSense. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 732.6.6 Snippets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

Chapitre 3L'organisation d'une application

1. Les solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 751.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 751.2 Création d'une solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 761.3 Organisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 771.4 Actions disponibles sur une solution . . . . . . . . . . . . . . . . . . . . . 78

1.4.1 Ajout et suppression d'un projet . . . . . . . . . . . . . . . . . . . 781.4.2 Création d'un dossier de solution . . . . . . . . . . . . . . . . . . . 79


1.4.3 Chargement et déchargement d'un projet . . . . . . . . . . . . 801.4.4 Création d'un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 801.4.5 Génération de la solution . . . . . . . . . . . . . . . . . . . . . . . . . 81

1.5 Configuration de la solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . 811.5.1 Configuration des projets de démarrage . . . . . . . . . . . . . 821.5.2 Dépendances du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . 841.5.3 Paramètres d'analyse du code . . . . . . . . . . . . . . . . . . . . . . 851.5.4 Fichiers sources pour le débogage . . . . . . . . . . . . . . . . . . . 861.5.5 Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

2. Les projets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 882.1 Création d'un projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 882.2 Propriétés d'un projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

2.2.1 Application. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 962.2.2 Build . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 992.2.3 Événements de build . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1022.2.4 Déboguer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1042.2.5 Ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1052.2.6 Paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

Chapitre 4Les bases du langage

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

2. Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1092.1 Nommage des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1102.2 Type des variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

2.2.1 Types valeurs et types références . . . . . . . . . . . . . . . . . . 1112.2.2 Types intégrés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

2.3 Déclaration des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1162.4 Portée des variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1172.5 Modificateurs d'accès . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1182.6 Le mot-clé var et l'inférence de type . . . . . . . . . . . . . . . . . . . . . 118

4



3. Les constantes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

4. Les opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1204.1 Les opérateurs d’accès. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

4.1.1 Accès simple : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1214.1.2 Accès indexé : [ ] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1214.1.3 Accès avec nullité conditionnelle : ?. . . . . . . . . . . . . . . . 121

4.2 Les opérateurs arithmétiques. . . . . . . . . . . . . . . . . . . . . . . . . . . 1224.3 Les opérateurs de comparaison . . . . . . . . . . . . . . . . . . . . . . . . . 1224.4 Les opérateurs conditionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . 123

4.4.1 Opérateur ternaire : ? ... : . . . . . . . . . . . . . . . . . . . . . . . . 1234.4.2 Opérateur de fusion de valeur nulle : ??. . . . . . . . . . . . . 124

4.5 Les opérateurs logiques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1244.5.1 Négation : ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1244.5.2 ET logique : & . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1254.5.3 OU logique : | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1254.5.4 OU exclusif : ^ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1254.5.5 ET conditionnel : && . . . . . . . . . . . . . . . . . . . . . . . . . . . 1264.5.6 OU conditionnel : ||. . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

4.6 Les opérateurs binaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1274.6.1 ET binaire : &. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1274.6.2 OU binaire : | . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1274.6.3 OU exclusif : ^ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1284.6.4 Négation : ~ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1284.6.5 Décalage vers la droite : >> . . . . . . . . . . . . . . . . . . . . . . 1284.6.6 Décalage vers la gauche :


5.2.3 do ... while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1365.2.4 foreach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1365.2.5 Contrôler l'exécution d'une boucle . . . . . . . . . . . . . . . . . 137

5.3 Autres structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1385.3.1 using . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1385.3.2 goto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139

6. Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1396.1 Écriture d'une fonction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1406.2 Paramètres de fonction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1416.3 Procédures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1466.4 Surcharges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1476.5 Fonctions locales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148

7. Les tuples. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

8. Les attributs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152

Chapitre 5La programmation orientée objet avec C#

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

2. Les classes et les structures. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1582.1 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

2.1.1 Déclaration. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1592.1.2 Constructeur et destructeur . . . . . . . . . . . . . . . . . . . . . . 1612.1.3 Classes partielles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

2.2 Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1662.3 Création de méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167

2.3.1 Création . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1672.3.2 Méthodes partielles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1692.3.3 Méthodes d'extension . . . . . . . . . . . . . . . . . . . . . . . . . . . 1702.3.4 Méthodes opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172

6



2.4 Création de propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1732.4.1 Lecture et écriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1742.4.2 Lecture seule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1752.4.3 Écriture seule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1752.4.4 Propriétés automatiques . . . . . . . . . . . . . . . . . . . . . . . . . 1762.4.5 Initialisation de propriétés automatiques . . . . . . . . . . . 1772.4.6 Propriétés automatiques en lecture seule. . . . . . . . . . . . 1772.4.7 Propriétés indexées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178

2.5 Membres statiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1792.6 Utilisation des classes et structures. . . . . . . . . . . . . . . . . . . . . . 180

2.6.1 Instanciation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1802.6.2 Initialisation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1812.6.3 Types anonymes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181

3. Les espaces de noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1843.1 Nomenclature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1853.2 using . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186

4. L'héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1874.1 Mise en œuvre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188

4.2 Les mots-clés this et base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1894.3 Redéfinition et masquage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191

4.3.1 Redéfinition de méthode. . . . . . . . . . . . . . . . . . . . . . . . . 1914.3.2 Masquage de méthode. . . . . . . . . . . . . . . . . . . . . . . . . . . 1924.3.3 Différences entre redéfinition et masquage . . . . . . . . . . 192

4.4 Imposer ou interdire l'héritage . . . . . . . . . . . . . . . . . . . . . . . . . 1954.5 Le transtypage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

5. Les interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1995.1 Création . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1995.2 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200

5.2.1 Implémentation implicite . . . . . . . . . . . . . . . . . . . . . . . . 2015.2.2 Implémentation explicite . . . . . . . . . . . . . . . . . . . . . . . . 203

6. Les énumérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205


7. Les délégués . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2057.1 Création. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2067.2 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2067.3 Expressions lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207

8. Les événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2088.1 Déclaration et déclenchement . . . . . . . . . . . . . . . . . . . . . . . . . . 2088.2 Gestion des événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210

9. Les génériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2129.1 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212

9.1.1 Définition d'une classe générique . . . . . . . . . . . . . . . . . . 2139.1.2 Utilisation d'une classe générique. . . . . . . . . . . . . . . . . . 213

9.2 Interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2149.2.1 Définition d'une interface générique . . . . . . . . . . . . . . . 2149.2.2 Utilisation d'une interface générique . . . . . . . . . . . . . . . 215

9.3 Contraintes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2169.4 Méthodes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219

9.4.1 Définition d'une méthode générique . . . . . . . . . . . . . . . 2199.4.2 Utilisation d'une méthode générique . . . . . . . . . . . . . . . 221

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

10. Les collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22310.1 Types existants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223

10.1.1 Array. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22310.1.2 ArrayList et List . . . . . . . . . . . . . . . . . . . . . . . . . . . 22410.1.3 Hashtable et Dictionary . . . . . . . . . . 22810.1.4 Stack et Stack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23010.1.5 Queue et Queue . . . . . . . . . . . . . . . . . . . . . . . . . . . 231

10.2 Choisir un type de collection . . . . . . . . . . . . . . . . . . . . . . . . . . . 232

11. La programmation dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232

12. La programmation asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23512.1 Les objets Task . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23512.2 Écrire du code asynchrone avec async et await . . . . . . . . . . . . 238

8



Chapitre 6Le débogage et la gestion des erreurs

1. Les différents types d'erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2411.1 Erreurs de compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2411.2 Erreurs d'exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243

2. Utilisation des exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2442.1 Création et déclenchement d'exceptions . . . . . . . . . . . . . . . . . 244

2.1.1 La classe Exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2442.1.2 Le mot-clé throw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2452.1.3 Exceptions spécialisées . . . . . . . . . . . . . . . . . . . . . . . . . . 245

2.2 Gérer les exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2462.2.1 La structure try ... catch . . . . . . . . . . . . . . . . . . . . . . . . . 2462.2.2 Les filtres d’exception . . . . . . . . . . . . . . . . . . . . . . . . . . . 2492.2.3 Le bloc finally. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250

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

3.1.1 Démarrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253

3.1.2 Arrêt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2543.1.3 Pause. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2543.1.4 Reprise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255

3.2 Points d'arrêt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2553.3 Visualiser le contenu des variables . . . . . . . . . . . . . . . . . . . . . . 262

3.3.1 DataTips . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2623.3.2 Fenêtres Espion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2633.3.3 Fenêtre Espion express . . . . . . . . . . . . . . . . . . . . . . . . . . 2643.3.4 Fenêtre Automatique . . . . . . . . . . . . . . . . . . . . . . . . . . . 2653.3.5 Fenêtre Variables locales . . . . . . . . . . . . . . . . . . . . . . . . . 265

3.4 Compilation conditionnelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265


Chapitre 7Le développement d'applications Windows

1. Présentation de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2691.1 Structure d'une application WPF. . . . . . . . . . . . . . . . . . . . . . . . 2701.2 XAML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271

1.2.1 Templates. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2721.2.2 Espaces de noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273

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

2. Utilisation des contrôles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2782.1 Ajout de contrôles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2792.2 Positionnement et dimensionnement des contrôles . . . . . . . . 2822.3 Ajout d'un gestionnaire d'événements à un contrôle . . . . . . . . 285

3. Les principaux contrôles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2873.1 Contrôles de fenêtrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288

3.1.1 Window . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2883.1.2 NavigationWindow. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290

3.2 Contrôles de disposition. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292

3.2.1 Grid. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2923.2.2 StackPanel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2963.2.3 DockPanel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2963.2.4 WrapPanel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2983.2.5 Canvas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300

3.3 Contrôles d'affichage de données . . . . . . . . . . . . . . . . . . . . . . . 3003.3.1 TextBlock . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3013.3.2 Label . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3023.3.3 Image . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3033.3.4 ScrollViewer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3043.3.5 ItemsControl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3043.3.6 StatusBar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3083.3.7 ToolTip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308

10



3.4 Contrôles d'édition de texte. . . . . . . . . . . . . . . . . . . . . . . . . . . . 3093.4.1 TextBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3093.4.2 RichTextBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3103.4.3 PasswordBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312

3.5 Contrôles de sélection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3123.5.1 RadioButton. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3123.5.2 CheckBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3133.5.3 ComboBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3133.5.4 ListBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3143.5.5 ListView . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3163.5.6 TreeView . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3183.5.7 Slider. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3233.5.8 Calendar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3233.5.9 DatePicker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324

3.6 Contrôles d'action. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3253.6.1 Button . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3253.6.2 Menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3253.6.3 ContextMenu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328

3.6.4 ToolBar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329

4. Interactions clavier et souris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3304.1 Événements clavier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3304.2 Événements souris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3334.3 Glisser-déposer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334

5. Aller plus loin avec WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3385.1 Introduction à l'utilisation de Blend . . . . . . . . . . . . . . . . . . . . . 338

5.1.1 L'interface. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3395.1.2 Ajout et modification de contrôles visuels . . . . . . . . . . 349

5.2 Introduction à MVVM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3525.2.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3525.2.2 Les interfaces INotifyPropertyChanged

et INotifyCollectionChanged . . . . . . . . . . . . . . . . . . . . . 3535.2.3 Commandes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3545.2.4 Mise en œuvre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354

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

1. Principes d'une base de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3711.1 Terminologie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3711.2 Le langage SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372

1.2.1 Recherche d'enregistrements . . . . . . . . . . . . . . . . . . . . . 3731.2.2 Ajout d'enregistrements . . . . . . . . . . . . . . . . . . . . . . . . . 3751.2.3 Mise à jour d'informations . . . . . . . . . . . . . . . . . . . . . . . 3751.2.4 Suppression d'informations . . . . . . . . . . . . . . . . . . . . . . 376

2. ADO.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3762.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3762.2 Les fournisseurs de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377

2.2.1 SQL Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3782.2.2 Oracle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3782.2.3 OLE DB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3792.2.4 ODBC. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379

3. Utiliser ADO.NET en mode connecté. . . . . . . . . . . . . . . . . . . . . . . . 380

3.1 Connexion à une base de données. . . . . . . . . . . . . . . . . . . . . . . 380

3.1.1 Chaînes de connexion . . . . . . . . . . . . . . . . . . . . . . . . . . . 3803.1.2 Pools de connexions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3833.1.3 Gestion de la connexion . . . . . . . . . . . . . . . . . . . . . . . . . 385

3.2 Création et exécution de commandes . . . . . . . . . . . . . . . . . . . . 3873.2.1 Définition et création d'une commande . . . . . . . . . . . . 3873.2.2 Sélection de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3883.2.3 Actions sur les données . . . . . . . . . . . . . . . . . . . . . . . . . . 3893.2.4 Paramétrage d'une commande . . . . . . . . . . . . . . . . . . . . 3903.2.5 Exécution de procédures stockées. . . . . . . . . . . . . . . . . . 393

4. Utiliser ADO.NET en mode déconnecté. . . . . . . . . . . . . . . . . . . . . . 3954.1 DataSet et DataTable. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395

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

à partir d'une base de données . . . . . . . . . . . . . . . . . . . . 396

12



4.1.3 Remplissage d'un DataSet sans base de données. . . . . . 3994.2 Manipulation des données hors connexion . . . . . . . . . . . . . . . 402

4.2.1 Lecture des données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4034.2.2 Création de contraintes. . . . . . . . . . . . . . . . . . . . . . . . . . 4034.2.3 Relations entre DataTables. . . . . . . . . . . . . . . . . . . . . . . 4074.2.4 État et versions d'une DataRow . . . . . . . . . . . . . . . . . . . 4094.2.5 Modification de données. . . . . . . . . . . . . . . . . . . . . . . . . 4104.2.6 Suppression de données . . . . . . . . . . . . . . . . . . . . . . . . . 4124.2.7 Valider ou annuler des modifications. . . . . . . . . . . . . . . 4124.2.8 Filtrage et tri à l'aide d'une DataView . . . . . . . . . . . . . . 4134.2.9 Recherche de données . . . . . . . . . . . . . . . . . . . . . . . . . . . 416

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

de mise à jour automatiquement . . . . . . . . . . . . . . . . . . 4194.3.2 Commandes de mise à jour personnalisées . . . . . . . . . . 4214.3.3 Gestion des accès concurrentiels . . . . . . . . . . . . . . . . . . 422

5. Utiliser les transactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424

Chapitre 9LINQ

1. Présentation de LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427

2. Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4282.1 Une première requête LINQ . . . . . . . . . . . . . . . . . . . . . . . . . . . 4312.2 Les opérateurs de requête . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434

2.2.1 Projection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4342.2.2 Filtrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4362.2.3 Triage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4382.2.4 Partitionnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4392.2.5 Jointure et regroupement . . . . . . . . . . . . . . . . . . . . . . . . 4402.2.6 Agrégation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443

3
3. Entity Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4453.1 Le mappage objet-relationnel. . . . . . . . . . . . . . . . . . . . . . . . . . . 445

3.1.1 Database First . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4463.1.2 Model First . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4463.1.3 Code First . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447

3.2 Utilisation du concepteur objet/relationnel . . . . . . . . . . . . . . . 4473.3 Utilisation de LINQ avec Entity Framework . . . . . . . . . . . . . . 466

3.3.1 Récupération de données . . . . . . . . . . . . . . . . . . . . . . . . 4673.3.2 Mise à jour de données . . . . . . . . . . . . . . . . . . . . . . . . . . 4703.3.3 Gestion des conflits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472

Chapitre 10XML

1. Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475

2. Structure d'un fichier XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4762.1 Constituants d'un document XML . . . . . . . . . . . . . . . . . . . . . . 4762.2 Document bien formé et document valide . . . . . . . . . . . . . . . . 480

3. Manipuler un document XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4813.1 Utilisation de DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4823.2 Utilisation de XPath . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4873.3 Utilisation de LINQ to XML . . . . . . . . . . . . . . . . . . . . . . . . . . . 490

Chapitre 11Le déploiement

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495

2. Windows Installer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4962.1 Création d'un projet d'installation . . . . . . . . . . . . . . . . . . . . . . 497

2.1.1 Opérations sur le système de fichiers . . . . . . . . . . . . . . . 4992.1.2 Opérations sur le registre de la machine cible . . . . . . . . 5032.1.3 Configuration de l’installation par l’utilisateur. . . . . . . 5042.1.4 Exécution d’actions personnalisées . . . . . . . . . . . . . . . . 506

14



2.1.5 Conditions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507

3. ClickOnce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5093.1 La technologie ClickOnce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 509

3.1.1 Principes de fonctionnement . . . . . . . . . . . . . . . . . . . . . 5103.1.2 Méthodes de déploiement disponibles . . . . . . . . . . . . . . 5113.1.3 Les mises à jour d'applications avec ClickOnce. . . . . . . 513

3.2 La publication ClickOnce. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514

Aide-mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 525

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545

09
1
Chapitre 4

Les bases du langage

Les bases du langage1. Introduction

Comme 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 variables

Les 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.

lcroiseTampon

110Les 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

dit

ions

EN

I -

All r

ights

rese

rved

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ïãbl3

De 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.

11
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

Le framework .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

dit

ions

EN

I -

All r

ights

rese

rved

Type Alias C# Plage de valeurs couverteTaille 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

13
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 couverteTaille 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

dit

ions

EN

I -

All r

ights

rese

rved

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

RI17CSHA_T.pdfCopyright - Editions ENI - Octobre 2017ISBN : 978-2-409-01045-3Avant-proposAvant-proposC# 7 et Visual Studio 2017IntroductionIntroductionDepuis l'introduction de C# avec la première version de la plateforme .NET, le langage a connu de nombreuses évolutions pour aboutir à sa septième version. Les multiples fonctionnalités qu'il permet d'utiliser, ainsi que sa syntaxe élégante, f...La place de C# dans le monde du développement a grandi au fil du temps pour arriver à la situation actuelle : C# est un langage "qui compte". Il permet de cibler de nombreuses plateformes matérielles et logicielles (notamment grâce au projet Mono...Cet ouvrage est destiné à tous les développeurs désireux d'appréhender le développement d'applications à l'aide de C# et Visual Studio 2017. Vous commencerez par découvrir la plateforme .NETVisual Studio 2017structuration des solutions et projets

Une fois cette première étape passée, vous découvrirez les éléments fondamentaux de C#programmation orientée objetproblématiques de débogage et de gestion d'erreurs

Une fois ces notions acquises, vous serez en mesure de prendre en main la conception d'applications fenêtrées utilisant la technologie WPFADO.NETLINQ

Le format XML

Enfin, un chapitre traite une part importante du cycle de vie d'une application : le déploiementInstallShieldClickOnce

Afin de vous aider dans votre apprentissage et votre perfectionnement, le dernier chapitre de l'ouvrage est un aide-mémoireréférence rapide et accessibleLes éléments à télécharger sont disponibles à l'adresse suivante : http://www.editions-eni.fr Saisissez la référence ENI de l'ouvrage RI17CSHA dans la zone de recherche et validez. Cliquez sur le titre du livre puis sur le bouton de télécha...Avant-propos

Chapitre 1La plateforme .NET

Chapitre 2Visual Studio 2017

Chapitre 3L'organisation d'une application

Chapitre 4Les bases du langage

Chapitre 5La programmation orientée objet avec C#

Chapitre 6Le débogage et la gestion des erreurs

Chapitre 7Le développement d'applications Windows

Chapitre 8L’accès aux données

Chapitre 9LINQ

Chapitre 10XML

Chapitre 11Le déploiement

La plateforme .NETLa plateforme .NETC# 7 et Visual Studio 20171. Introduction1. IntroductionMicrosoft fournit au travers de la plateforme .NET un ensemble d'outils et de technologies permettant le développement d'applications ciblant des plateformes variées : – Applications Windows (applications fenêtrées, applications console, services Windows)– Applications Windows (applications fenêtrées, applications console, services Windows)– Applications Windows (applications fenêtrées, applications console, services Windows)

– Applications et services web– Applications et services web

– Applications pour smartphones– Applications pour smartphones

– Applications orientées tablettes– Applications orientées tablettes

– Applications pour systèmes embarqués– Applications pour systèmes embarqués

Ces différents types d'applications peuvent être développés grâce à une brique commune : le framework .NET

Les éléments formant le cœur du framework .NET sont le Common Language RuntimeCLRDynamic Language RuntimeDLRBase Class Librarybibliothèque de classes de base

Le Common Language Runtime est un environnement qui permet l'exécution du code .NET et assure la gestion de la mémoire. Le code pris en charge par le CLR est couramment appelé code managé. Le Dynamic Language Runtime est une addition au Common Language Runtime développée en C# qui fournit des capacités d'exécution de code dynamique. Grâce à lui, des langages dynamiques, tels que PHP ou Python, peuvent être supportés par le fram...La Base Class Library est un ensemble de classes qui exposent des fonctionnalités courantes et qui peuvent être utilisées pour tout type d'application. Elle est constituée de plusieurs briques indépendantes ajoutées progressivement au fil des v...

2. Historique2. HistoriqueDepuis ses débuts, Windows expose ses fonctionnalités aux développeurs au travers d'interfaces de programmation (en anglais API pour Application Programming Interface

– API Windows (Win16, Win32 et Win64) : ces API constituent le cœur de Windows et sont utilisées directement par le système. Elles sont destinées à être utilisables au plus bas niveau, avec le langage C. Win16 était livré à partir de Windows – API Windows (Win16, Win32 et Win64) : ces API constituent le cœur de Windows et sont utilisées directement par le système. Elles sont destinées à être utilisables au plus bas niveau, avec le langage C. Win16 était livré à partir de Windows – API Windows (Win16, Win32 et Win64) : ces API constituent le cœur de Windows et sont utilisées directement par le système. Elles sont destinées à être utilisables au plus bas niveau, avec le langage C. Win16 était livré à partir de Windows – API Windows (Win16, Win32 et Win64)

– MFC (– MFC (– MFCMicrosoft Foundation Classes

– COM (– COM (– COMComponent Object ModelATLActive Template Library

La plateforme .NET est apparue au début des années 2000 en réponse au problème de la complexification de ces API. Elle les unifie et les modernise, tout en permettant leur utilisation par n'importe quel langage possédant une implémentation comp...L'unification des API et des modèles de développement a aussi touché le monde du Web. Microsoft fournissait en effet le moteur de script (côté serveur) ASPActive Server PageASP.NET

Depuis sa sortie initiale, la plateforme .NET a connu treize versions différentes, dont sept apportant des modifications ou des fonctionnalités majeures. Ces évolutions sont résumées ci-dessous (de manière non exhaustive).Version 1.0Version 1.0

Date de sortie : février 2002IDE associé : Visual Studio .NET 2002Fonctionnalités associées : – Développement Windows avec les WinForms– Développement Windows avec les WinForms– Développement Windows avec les WinForms

– Développement web avec ASP.NET– Développement web avec ASP.NET

Version 1.1Version 1.1

Date de sortie : avril 2003IDE associé : Visual Studio .NET 2003Fonctionnalités associées : – Nombreux changements dans l'API– Nombreux changements dans l'API– Nombreux changements dans l'API

– Ajout des fournisseurs de données Oracle et ODBC dans la brique ADO.NET (auparavant disponible sous la forme d'un add-on)– Ajout des fournisseurs de données Oracle et ODBC dans la brique ADO.NET (auparavant disponible sous la forme d'un add-on)

– Ajout de contrôles visuels pour le développement ASP.NET (auparavant disponible sous la forme d'un add-on)– Ajout de contrôles visuels pour le développement ASP.NET (auparavant disponible sous la forme d'un add-on)

– Support du protocole IPv6– Support du protocole IPv6

– Première version du .NET Compact Framework à destination des périphériques mobiles– Première version du .NET Compact Framework à destination des périphériques mobiles


Date de sortie : janvier 2006IDE associé : Visual Studio 2005Fonctionnalités associées : – Support des systèmes d'exploitation 64 bits– Support des systèmes d'exploitation 64 bits– Support des systèmes d'exploitation 64 bits

– Support des classes partielles, permettant la séparation entre le code généré et le code écrit par le développeur– Support des classes partielles, permettant la séparation entre le code généré et le code écrit par le développeur

– Support des méthodes anonymes– Support des méthodes anonymes

– Introduction des types génériques, qui permettent l'écriture de code adaptable à différents types de données– Introduction des types génériques, qui permettent l'écriture de code adaptable à différents types de données


Date de sortie : novembre 2006IDE associé : Visual Studio 2005Fonctionnalités associées : Quatre nouvelles briques majeures :– WPF (– WPF (– WPF (Windows Presentation Foundation

– WCF (– WCF (Windows Communication Foundation

– WF (– WF (Windows Workflow Foundation

– Windows CardSpace pour la gestion d'identité par authentification unique (désormais obsolète)– Windows CardSpace pour la gestion d'identité par authentification unique (désormais obsolète)


Date de sortie : novembre 2007IDE associé : Visual Studio 2008Fonctionnalités associées : – Inférence de type– Inférence de type– Inférence de type

– LINQ pour le requêtage de données– LINQ pour le requêtage de données


Date de sortie : avril 2010IDE associé : Visual Studio 2010Fonctionnalités associées : – Introduction du DLR (– Introduction du DLR (– Introduction du DLR (Dynamic Language Runtime

– Ajout des Parallel Extensions pour la gestion du multithreading et de la parallélisation de l'exécution du code– Ajout des Parallel Extensions pour la gestion du multithreading et de la parallélisation de l'exécution du code

– Amélioration des performances du Garbage Collector– Amélioration des performances du Garbage Collector


Date de sortie : août 2012IDE associé : Visual Studio 2012Fonctionnalités associées : – Support des applications dédiées à Windows 8– Support des applications dédiées à Windows 8– Support des applications dédiées à Windows 8

– Extension de C# et VB.NET pour inclure l'asynchronisme directement dans les langages– Extension de C# et VB.NET pour inclure l'asynchronisme directement dans les langages

– Nouvelle API pour la communication HTTP– Nouvelle API pour la communication HTTP

– Amélioration des performances web avec la minification et l'asynchronisme– Amélioration des performances web avec la minification et l'asynchronisme

Version 4.5.1Version 4.5.1

Date de sortie : octobre 2013IDE associé : Visual Studio 2013Fonctionnalités associées : – Support des applications dédiées à Windows 8.1– Support des applications dédiées à Windows 8.1– Support des applications dédiées à Windows 8.1


Date de sortie : mai 2014IDE associé : Visual Studio 2013Fonctionnalités associées : – Nouvelles API pour ASP.NET– Nouvelles API pour ASP.NET– Nouvelles API pour ASP.NET


Date de sortie : juillet 2015IDE associé : Visual Studio 2015Fonctionnalités associées : – Unification des API web dans le framework MVC 6– Unification des API web dans le framework MVC 6– Unification des API web dans le framework MVC 6

– .NET Core– .NET Core

– Compilation des applications Windows Store en code natif avec .NET Native – Compilation des applications Windows Store en code natif avec .NET Native

– Nouveau compilateur "Just-in-time" plus performant : RyuJIT– Nouveau compilateur "Just-in-time" plus performant : RyuJIT

– Mise à jour de Windows Forms et WPF pour le support des écrans à très grande densité de pixels (High DPI)– Mise à jour de Windows Forms et WPF pour le support des écrans à très grande densité de pixels (High DPI)

– Support de nouveaux algorithmes cryptographiques– Support de nouveaux algorithmes cryptographiques


Date de sortie : novembre 2015IDE associé : Visual Studio 2015Fonctionnalités associées : – Améliorations dans WPF (correction orthographique intégrée, performance des fonctionnalités tactiles…)– Améliorations dans WPF (correction orthographique intégrée, performance des fonctionnalités tactiles…)– Améliorations dans WPF (correction orthographique intégrée, performance des fonctionnalités tactiles…)

– Amélioration des performances et de la stabilité– Amélioration des performances et de la stabilité


Date de sortie : mars 2016IDE associé : Visual Studio 2015Fonctionnalités associées : – Amélioration de la cryptographie– Amélioration de la cryptographie– Amélioration de la cryptographie

– Amélioration du support des écrans à très grande densité de pixels– Amélioration du support des écrans à très grande densité de pixels


Date de sortie : mai 2017IDE associé : Visual Studio 2017Fonctionnalités associées : – Amélioration de la cryptographie– Amélioration de la cryptographie– Amélioration de la cryptographie

– Amélioration du protocole de sécurité TLS– Amélioration du protocole de sécurité TLS

– Nouvelles API WPF dédiées à l’impression– Nouvelles API WPF dédiées à l’impression

– Amélioration du support des écrans à très grande densité de pixels– Amélioration du support des écrans à très grande densité de pixels

3. Le Common Language Runtime (CLR)3. Le Common Language Runtime (CLR)L'exécution des applications Windows traditionnelles est prise en charge par le système d'exploitation. Ces programmes sont générés par un compilateur qui transforme des instructions écrites dans un langage comme C ou C++ en un fichier binaire ...Une solution à cette problématique est de générer un exécutable dont le code est générique, indépendant de l'environnement d'exécution. Dans ce contexte, son exécution ne peut pas être confiée directement au système d'exploitation puisqu...machine virtuelle

C'est exactement ce principe qui est utilisé par la plateforme .NET. L'étape de compilation d'une application écrite avec Visual C# ou Visual Basic .NET produit un fichier exécutable dont le contenu est essentiellement écrit dans un langage gén...Microsoft Intermediate LanguageMSILCommon Language RuntimeCLR

L'utilisation de cette technique nécessite l'installation de la machine virtuelle sur les différents postes de travail devant exécuter l'application. Microsoft fournit une implémentation de cette machine virtuelle pour tous les systèmes Windows ...En plus de cette opération de traduction, le Common Language Runtime fournit un certain nombre de services relatifs à l'exécution du code géré. L'ensemble des fonctionnalités du CLR est schématisé ci-dessous.

Class LoaderClass Loader

Il gère la création et le chargement en mémoire des instances de classes.MSIL To Native CompilerMSIL To Native Compiler

Ce service convertit le code intermédiaire en code natif.Code ManagerCode Manager

Il gère l'exécution du code.Garbage CollectorGarbage Collector

Il fournit une gestion automatique de la mémoire en surveillant les objets de l'application et en libérant la mémoire des instances de classes inutilisées et inaccessibles.Security EngineSecurity Engine

Il assure la sécurité du système en vérifiant les permissions d'exécution au niveau du code, du dossier de l'application et de la machine.Debug EngineDebug Engine

Il permet le débogage de l'application.Type CheckerType Checker

Il vérifie la compatibilité des différents types utilisés dans l'application afin de fournir une sécurité au niveau du typage.Exception ManagerException Manager

Il fournit la gestion individuelle des exceptions pouvant être levées par l'application. Thread SupportThread Support

Il fournit une encapsulation managée des threads, permettant ainsi le développement d'applications multithread tout en bénéficiant de tous les services fournis par le CLR.COM MarshalerCOM Marshaler

Il permet la communication entre une application .NET et un composant COM, notamment en effectuant des conversions de types de données automatiques en cas de besoin.Base Class Library SupportBase Class Library Support

Il fournit l'accès à l'ensemble des classes de la Base Class Library.

4. La Base Class Library (BCL)4. La Base Class Library (BCL)Le framework .NET inclut un ensemble de types de données permettant d'obtenir rapidement une solution à un grand nombre de problématiques pouvant être rencontrées au cours du développement d'une application.Ces types de données sont organisés sous la forme d'une hiérarchie. Chaque niveau de cette hiérarchie est défini par un espace de nomsnamespaceSystem.Xml

La BCL contient plusieurs milliers de types, et il est fort probable qu'une grande partie d'entre eux ne soit jamais utilisée dans vos développements. Certains d'entre eux sont en effet très spécifiques et utilisables dans très peu de contextes....Microsoft.BuildSystem.CodeDom

Parmi les espaces de noms les plus utilisés, on peut notamment trouver :SystemSystem

C'est l'espace de noms racine pour les fonctionnalités fournies par le système d'exploitation. Il contient notamment la définition des types primitifs alphanumériques et numériques.System.DataSystem.Data

Il contient l'ensemble des types permettant l'accès aux bases de données.System.IOSystem.IO

Cet espace de noms contient les types permettant l'accès à des flux de données ou à des fichiers.

5. Le Dynamic Language Runtime (DLR)5. Le Dynamic Language Runtime (DLR)Le Dynamic Language Runtime est une surcouche du Common Language Runtime, apparue avec la version 4.0 de la plateforme .NET, qui fournit des services facilitant l'implémentation et l'utilisation des langages dynamiques dans l'environnement .NET. Depuis l'arrivée du DLR, il est possible de définir des variables .NET dont le type est dynamique, c’est-à-dire qu'il n'est pas fixé au moment de l'écriture du code. L'utilisation de cette fonctionnalité peut se révéler extrêmement pratiqu...L'existence du Dynamic Language Runtime permet par conséquent de fournir une implémentation de langages dynamiquesIronPythonIronRuby

Il est également possible grâce au DLR de créer des applications .NET qui peuvent être des hôtes de scripts, c’est-à-dire qu'il est possible d'écrire du code compatible .NET, avec IronPython par exemple, et de l'exécuter à l'intérieur d'u...Les types .NET dédiés à l'écriture de code dynamique sont localisés dans l'espace de noms System.Dynamic

6. Évolution de la plateforme6. Évolution de la plateformeAu fil de ses différentes versions, l'environnement .NET s'est enrichi de nombreuses fonctionnalités, dont certaines étaient/sont résolument novatrices. Les applications basées sur la plateforme peuvent être exécutées par des ordinateurs de b...À ce stade de maturation, de nouvelles problématiques se posent, autant au niveau des équipes de développement de Microsoft qu'au niveau de la communauté de développeurs qui utilisent cette technologie. On trouve notamment parmi ces préoccupat...En réaction à ces problématiques, les équipes de développement du framework .NET ont défini et mis en place la brique .NET Core. Ils ont également retroussé leurs manches et écrit un tout nouveau compilateur pour C# et VB.NET : Roslyn.6.1 .NET Core6.1 .NET CoreLe framework .NET a été conçu comme un bloc unique, toujours déployé dans son ensemble. Son cœur contient l'utilisation d'API spécifiques à certains types d'applications et, par conséquent, les environnements qui ne supportent pas ces API do...La solution apportée à cela par Microsoft s'appelle .NET Core. Derrière ce nom se cache une branche issue du framework .NET dont l'objectif est d'offrir une plus grande modularité en brisant l'architecture monolithique de sa bibliothèque de clas...Le mode de distribution a également été revu, puisque chaque portion de .NET Core est publiée au travers d'un package NuGet. Ceci permet une évolution plus rapide de chaque brique. Chaque équipe de développement peut ainsi utiliser une version...Certains packages sont à ce jour disponibles pour toutes les plateformes, comme la brique Entity Framework, mais le mode de fonctionnement basé entièrement sur .NET Core n'est pour le moment disponible que pour ASP.NET Core, les applications Windo...En plus de la portabilité entre types d'applications, Microsoft a également pris en compte la portabilité entre systèmes d'exploitation. Le Core CLR est un portage compatible Linux et Mac OS X du CLR intégré dans le framework .NET. Les applicat...

6.2 .NET Compiler Platform : Roslyn6.2 .NET Compiler Platform : RoslynRoslyn est le nom de code de la plateforme de compilation fournie par Microsoft avec le SDK du framework .NET depuis sa version 4.6. Ce système remplace le compilateur C# de .NET 4.5, dont le fonctionnement suivait le modèle traditionnel des compil...Avec Roslyn, Microsoft a voulu sortir de ce système de type "boîte noire" en transformant le compilateur en fournisseur de données. L'API fournie avec Roslyn permet en effet de récupérer et manipuler le résultat du traitement effectué par chaq...– Analyse syntaxique– Analyse syntaxique– Analyse syntaxique

– Analyse sémantique– Analyse sémantique

– Écriture de code MSIL– Écriture de code MSIL

La disponibilité de ces données ouvre la porte à des scénarios avancés parmi lesquels on peut compter l'intégration de C# dans une application en tant que langage de script compilé dynamiquement ou l'extension d'un environnement de développem...

6.3 .NET dans le monde open source6.3 .NET dans le monde open sourceMicrosoft travaille depuis quelques années avec le monde open source, notamment pour l'intégration de solutions basées sur des systèmes Linux dans Azure. Plus récemment, les technologies Redis ou Docker ont été déployées sur cette plateforme...L'écosystème .NET est également de la partie : Microsoft a annoncé la création de la .NET Foundation lors de la conférence BUILD 2014. Cette structure est dédiée au développement de projets open source basés sur la plateforme .NET. On trouv...Certains projets centraux pour Microsoft ont également été placés sous la gestion de cette fondation : .NET Core et Roslyn en font partie, tout comme Entity Framework ou ASP.NET Core. Leur développement est ainsi contrôlé par Microsoft mais la...

7. Une première application avec Visual C#7. Une première application avec Visual C#Pour découvrir Visual C#, nous étudierons ici l'écriture d'une application très simple ainsi que le processus de compilation du code. Cette première phase sera suivie d'une étape d'analyse de l'exécutable généré.7.1 Création7.1 CréationUne application Visual C# est construite à partir de fichiers de code source. Ces fichiers sont généralement édités à l'aide d'un environnement de développement comme Visual Studio ou, si vous êtes adepte des outils open source, MonoDevelop o...Ces fichiers de code source n'étant finalement que des fichiers texte, il est parfaitement possible de les éditer à l'aide de l'application Bloc-Notes de Windows ou de tout autre programme permettant l'ouverture et la modification de fichiers text...Le premier exemple que nous verrons dans cet ouvrage sera une application affichant le traditionnel "Hello World !" dans la fenêtre de ligne de commande. Pour écrire le code source correspondant, il est nécessaire de créer un fichier texte avec l...using System; class Program { static void Main() { Console.WriteLine("Hello world !"); } }Ce fichier doit être enregistré avec un nom suffixé par l'extension .cs. Cette extension n'est pas obligatoire pour la compilation du programme, mais elle correspond aux conventions utilisées pour le développement d'applications avec C#.Détaillons à présent le contenu de ce code source :using System;using System;

Cette ligne indique que le code utilise un ou plusieurs types localisés dans l'espace de noms SystemSystem.Console.WriteLine("Hello world !");

class Programclass Program

Cette ligne est la définition de la classe Program

static void Main()static void Main()

Cette ligne définit la fonction principale de notre application. On appelle aussi cette fonction point d'entrée de l'applicationMainintvoid

Console.WriteLine("Hello world !");Console.WriteLine("Hello world !");

Le type ConsoleWriteLineConsole

7.2 Compilation7.2 CompilationLe kit de développement logiciel pour le framework .NET (ou SDK .NET) inclut un certain nombre d'outils permettant notamment la compilation des applications écrites avec Visual C#. Le compilateur correspondant au framework .NET 4.7 est un exécutab...L'installation de Visual Studio crée heureusement un raccourci fort utile dans le menu DémarrerDeveloper Command Prompt for VS 2017

L'exécution de l'instruction csc /?

/out:/out:

Spécifie le nom du fichier de sortie. Par défaut, son nom correspond au nom du premier fichier fourni./target:exe ou/target:exe /t:exe

Définit que le fichier de sortie est une application console./target:winexe ou/target:winexe /t:winexe

Définit que le fichier de sortie est une application fenêtrée pour Windows./target:library ou/target:library/t:library

Définit que le fichier de sortie est une bibliothèque de classes au format DLL./reference:/reference:

Cette option indique une liste de fichiers à référencer pour la bonne compilation du code. Les noms de fichiers doivent être séparés par des virgules.La compilation de l’application peut être effectuée en plaçant l'invite de commandes dans le répertoire contenant notre fichier source puis en exécutant la commande csc HelloWorld.cs

7.3 Analyse de l'assembly7.3 Analyse de l'assemblyUne fois le fichier exécutable généré, il est possible de l'explorer afin de visualiser son contenu. Au préalable, une explication de la structure d'un assembly (c'est le nom donné aux fichiers .dll ou .exe construits par et pour la plateforme ...7.3.1 Structure7.3.1 StructureLes assemblies .NET ont une capacité de réflexion. Cela signifie qu'ils sont capables de découvrir le contenu d'un assembly .NET. Cette aptitude s'applique aussi à eux-mêmes : ils sont capables de lire leur propre contenu. Cette fonctionnalité ...Un assembly est une unité logique de code contenant deux éléments essentiels : les métadonnéescode MSIL

7.3.2 Exploration avec ILDASM7.3.2 Exploration avec ILDASMUn assembly étant autodescriptif, il est possible avec certains outils de lire ses métadonnées pour obtenir la description du code qu'il contient, puis de lire le code MSIL de l'assembly pour retrouver le contenu de chaque classe, fonction, propri...désassemblage

Parmi les outils installés par le kit de développement du framework .NET, on trouve un logiciel fenêtré nommé ILDASM (pour Intermediate Language Disassembler

Cet outil est lancé à partir de la commande ildasmFichier - Ouvrir

Le contenu de l'assembly est représenté sous la forme d'une arborescence. On trouve dans cette arborescence les deux éléments essentiels décrits plus tôt.La section MANIFEST

Le premier bloc indique que la version 4.0.0.0 de l'assembly mscorlib

La seconde partie de l'arborescence correspond au code MSIL du programme. Elle affiche les différents types définis dans le code ainsi que leur contenu. Un double clic sur chacun de ces éléments ouvre une fenêtre contenant le code associé.

Le code MSIL associé à la fonction Main

L'instruction IL_0001IL_0006System.Console.WriteLinemscorlib

Visual Studio 2017Visual Studio 2017C# 7 et Visual Studio 20171. Installation et premier lancement1. Installation et premier lancementLa première étape dans l'utilisation de Visual Studio est son installation sur la machine destinée au développement.1.1 Prérequis1.1 PrérequisVisual Studio est un environnement de développement qui peut se révéler extrêmement puissant, mais pour tirer pleinement parti de ses fonctionnalités, il est nécessaire que la machine sur laquelle il est installé dispose d’une configuration ...Microsoft indique les valeurs suivantes pour cette configuration :Système d'exploitationSystème d'exploitationSystème d'exploitation

Windows 7 SP1 Windows 7 SP1Windows 8.1 (avec Update 2919355)Windows Server 2012 R2 (avec Update 2919355)Windows 10 (version 1507 et +)Windows Server 2016

ProcesseurProcesseurProcesseur

Processeur de 1,8 GHzProcesseur de 1,8 GHz

Mémoire viveMémoire viveMémoire vive

2 Go de RAM (2,5 Go en cas d'exécution sur un ordinateur virtuel)2 Go de RAM (2,5 Go en cas d'exécution sur un ordinateur virtuel)

Espace disque disponibleEspace disque disponibleEspace disque disponible

De 1 à 40 Go, en fonction des fonctionnalités installéesDe 1 à 40 Go, en fonction des fonctionnalités installées

VidéoVidéoVidéo

Carte vidéo supportant une résolution d'affichage de 1 280 x 768Carte vidéo supportant une résolution d'affichage de 1 280 x 768

1.2 Éditions de Visual Studio1.2 Éditions de Visual StudioVisual Studio 2017 est disponible en plusieurs éditions adaptées à différents contextes. Microsoft les propose en téléchargement à l'adresse suivante : https://www.visualstudio.com/fr/downloads/

Les éditions Professional et Enterprise ne sont disponibles qu'à des fins d'évaluation, pour une durée de 90 jours. Passé ce délai, il vous faudra vous procurer une licence d'utilisation auprès de Microsoft.1.2.1 Visual Studio Community1.2.1 Visual Studio CommunityCette déclinaison du produit permet le développement d'applications web, Windows Store et Windows "classiques". Elle offre également le support du développement d’applications cross-plateformes avec Xamarin.L’édition Community est fournie par Microsoft gratuitement sous certaines conditions. Les équipes travaillant sur des projets open source ou des recherches universitaires peuvent notamment accéder à cet outil gratuitement. Plus généralement, toute personne peut utiliser cet outil sans frais à des fins d'enseignement ou de formation.Visual Studio 2017 Community peut également être utilisé à des fins commerciales, par des développeurs indépendants ou de petites équipes professionnelles (au maximum 5 utilisateurs, moins de 250 salariés dans l'entreprise et moins de un mill...C’est cette version de Visual Studio qui est utilisée tout au long de cet ouvrage. Vous pouvez donc l’utiliser pour compiler et exécuter l’ensemble des exemples de code présents dans cet ouvrage.C’est cette version de Visual Studio qui est utilisée tout au long de cet ouvrage.

1.2.2 Éditions commerciales1.2.2 Éditions commercialesVisual Studio 2017 est décliné en trois versions commerciales différentes adaptées à des problématiques variées.Visual Studio Test ProfessionalCette version est destinée aux professionnels du test d'applications. Elle ne permet pas d'effectuer de développement et, par conséquent, ne peut être utilisée dans le cadre de cet ouvrage.Visual Studio ProfessionalCette déclinaison du produit offre globalement les mêmes fonctionnalités que l’édition Community, mais est adaptée à un usage en entreprise (plus de 5 utilisateurs ou plus de 250 salariés, ou un CA annuel supérieur à un million de dollars)...Visual Studio EnterpriseCette dernière déclinaison de Visual Studio intègre les fonctionnalités de l’édition Professional et embarque des fonctionnalités avancées telles que l'automatisation de tests d'interface, la recherche de code dupliqué ou l’analyse de l...

1.3 Installation1.3 InstallationEn plus du respect des prérequis listés au début de chapitre, l’installation de Visual Studio requiert bien évidemment un support d’installation, disponible sur le site http://www.visualstudio.com

On peut remarquer que Microsoft ne fournit pas d’image disque (.iso) pour cette version de Visual Studio, ce qui peut s’avérer particulièrement gênant dans le cadre d’une installation hors ligne ou lorsque plusieurs installations doivent êt...Dans les deux cas, il est tout d’abord indispensable de récupérer le programme d’amorçage de Visual Studio à l’adresse https://www.visualstudio.com/fr/ downloads/

L’installation hors ligne est légèrement plus complexe puisqu’elle nécessite quelques manipulations préalables. Le principe général utilisé pour la constitution d’une image d’installation est très simple : le programme d’amorçage t...Le processus de téléchargement est déclenché par l’exécution du programme d’amorçage avec une ligne de commande. Pour récupérer les paquets qui permettent d’installer toutes les fonctionnalités de Visual Studio, la commande est la suiv...vs_community.exe --layout --lang fr-FRToutefois, si vous souhaitez limiter le téléchargement aux seules fonctionnalités qui vous sont nécessaires, vous pouvez spécifier quels composants inclure à l’aide des paramètres --add--includeRecommended--includeOptionalworkloads

vs_community.exe --layout --add Microsoft.VisualStudio.Workload.ManagedDesktop --includeRecommended --includeOptional --lang fr-FRCette configuration convient parfaitement à l’exécution des exemples inclus dans cet ouvrage.Cette configuration convient parfaitement à l’exécution des exemples inclus dans cet ouvrage.

La liste complète des charges de travail et composants de Visual Studio Community est disponible à l’adresse suivante : https://docs.microsoft.com/fr-fr/ visualstudio/install/workload-component-id-vs-community

La documentation complète relative à l’utilisation du programme d’amorçage en ligne de commande est quant à elle disponible à l’adresse : https://docs.microsoft.com/fr-fr/visualstudio/install/use-command-line- parameters-to-install-visual-studio

À l’issue du processus de téléchargement, dont la durée d’exécution est fonction des composants souhaités et du débit de la connexion Internet utilisée, le dossier de destination contient un grand nombre de dossiers ainsi qu’un exécuta...À ce stade, vous disposez d’un programme d’amorçage seul ou d’une image d’installation correspondant à vos besoins. L’installation de l’environnement de développement peut commencer.Une fois le programme d’amorçage (vs_community.exe) ou le programme d’installation (vs_setup.exe) exécuté, l’écran suivant est affiché.

Cette interface graphique a pour principal objectif de permettre la sélection des fonctionnalités qui doivent être installées. Comme évoqué un peu plus haut, les composants sont regroupés dans des ensembles, les charges de travail, qui représ...– Développement pour la plateforme Windows universelle– Développement pour la plateforme Windows universelle– Développement pour la plateforme Windows universelle

– Développement .NET Desktop– Développement .NET Desktop

– Développement Desktop en C++– Développement Desktop en C++

– Développement web et ASP.NET– Développement web et ASP.NET

– Développement Azure– Développement Azure

– Développement Python– Développement Python

– Développement Node.js– Développement Node.js

– Stockage et traitement des données– Stockage et traitement des données

– Applications de science et analyse des données– Applications de science et analyse des données

– Développement Office/Sharepoint– Développement Office/Sharepoint

– Développement mobile en .NET– Développement mobile en .NET

– Développement de jeux avec Unity– Développement de jeux avec Unity

– Développement mobile en JavaScript– Développement mobile en JavaScript

– Développement mobile en C++– Développement mobile en C++

– Développement de jeux en C++– Développement de jeux en C++

– Développement d’extensions Visual Studio– Développement d’extensions Visual Studio

– Développement Linux en C++– Développement Linux en C++

– Développement multiplateforme .NET Core– Développement multiplateforme .NET Core

Chacune de ces charges de travail peut être adaptée aux besoins spécifiques du développeur : pour chaque catégorie, la partie droite de l’interface montre les composants facultatifs associés et autorise leur sélection/désélection. Il est p...Cet écran propose également de modifier le répertoire d'installation du produit et indique que la validation de l’installation vaut acceptation du contrat de licence. La dernière indication importante affichée sur cet écran est l’estimation...À ce stade, il ne reste qu'à effectuer un clic sur le bouton Installer

Une fois le processus d'installation démarré, l'interface bascule sur un nouvel écran qui indique son avancement.

À l'issue de l'installation, l'écran suivant vous informe que l'opération a fonctionné et peut proposer un redémarrage de la machine (qu'il faut bien entendu accepter).

1.4 Premier lancement1.4 Premier lancementUn raccourci permettant de lancer Visual Studio a été automatiquement placé dans le menu Démarrer

Le premier lancement est l'occasion pour le logiciel de vous proposer de personnaliser votre environnement de développement. La première étape de cette personnalisation est la connexion à un compte Microsoft afin d'importer et de sauvegarder vos ...

Cliquer sur le bouton Se connecterhttp://www.outlook.comhttp://www.hotmail.com

Une fois la connexion établie, Visual Studio peut demander quelques informations supplémentaires afin de personnaliser un peu plus son interface, et il vous propose également la création d'un compte Visual Studio OnlineTeam Foundation Server

Une fois cette étape franchie, Visual Studio propose la sélection d'un thème pour l'environnement : BleuClairSombre

Sur le même écran, une liste déroulante présente une liste de paramètres de développement prédéfinis. Les exemples et explications de cet ouvrage ont été réalisés avec les paramètres Visual C#

Enfin, après avoir cliqué sur le bouton Démarrer Visual Studio

Cette page permet d'accéder rapidement aux derniers projets ouverts ainsi que de créer ou d'ouvrir un projet. Elle affiche également certaines informations concernant les produits de développement de Microsoft.Un indicateur placé en haut à droite permet de savoir quel est le compte Microsoft connecté à Visual Studio.

2. Description des outils2. Description des outilsVisual Studio est constitué de trois types d'éléments répartis dans sa zone d'affichage :– Le haut de la fenêtre principale est constitué d'une barre de menus et de plusieurs barres d'outils.– Le haut de la fenêtre principale est constitué d'une barre de menus et de plusieurs barres d'outils.– Le haut de la fenêtre principale est constitué d'une barre de menus et de plusieurs barres d'outils.

– Le centre de la fenêtre principale contient la zone de travail dans laquelle peuvent être affichés, entre autres, un ou plusieurs concepteurs visuels ainsi que des fenêtres d'édition de code.– Le centre de la fenêtre principale contient la zone de travail dans laquelle peuvent être affichés, entre autres, un ou plusieurs concepteurs visuels ainsi que des fenêtres d'édition de code.

– Différentes fenêtres secondaires représentent les différents outils à la disposition du développeur. – Différentes fenêtres secondaires représentent les différents outils à la disposition du développeur.

L'environnement de travail peut être géré et adapté par l'utilisation de trois techniques :– L'ancrage de fenêtres– L'ancrage de fenêtres– L'ancrage de fenêtres

– Le masquage automatique de fenêtres– Le masquage automatique de fenêtres

– L'utilisation d'onglets– L'utilisation d'onglets

L'ancrage d'une fenêtre correspond au fait de l'accrocher à l'un des côtés de la fenêtre principale. Il est aussi possible de rendre une fenêtre flottante, c’est- à-dire qu'elle est positionnée de manière absolue, sans relation avec les au...Lors du déplacement d'une fenêtre par glisser-déposer, Visual Studio affiche plusieurs guides. Lorsque l'emplacement de la fenêtre correspond à un ancrage, une prévisualisation de l'espace occupé est affichée à l'aide d'un fond de couleur bl...

Déposer une fenêtre sur un des guides ancre la fenêtre à la position souhaitée. Si celle-ci est relâchée en dehors d'un guide, la fenêtre devient flottante.Le masquage automatique de fenêtre ne p

Documents

C# 7 et Visual Studio 2017 · 29,90 € ISBN : 978-2-409-01045-3 Ce livre s’adresse aux développeurs souhaitant maîtriser le développe- ment d’applications .NET avec le langage