C#与.NET 3.0 version améliorée
Partie 1 nnn Présentation de C# et de la plateforme .NET
nCHAPITRE 1 La philosophie de .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Comprendre l'état des choses antérieur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
La solution .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Présentation des éléments de base de la plateforme .NET (le CLR, le CTS,
et CLS). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Langages de programmation .NET supplémentaires. . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Un aperçu des assemblys .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Comprendre le système de types commun . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Comprendre la spécification du langage commun . . . . . . . . . . . . . . . . . . . . . . 20
Comprendre le Common Language Runtime. . . . . . . . . . . . . . . . . . . . . . . . . . 22
La distinction Assemblage/Espace de noms/Type. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Exploration d'un assemblage à l'aide de ildasm.exe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Explorer un assemblage à l'aide du réflecteur de Lutz Roeder. . . . . . . . . . . . . . . . . . . . . . 31
Déploiement du runtime .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
La nature indépendante de la plate-forme de .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
nCHAPITRE 2 Création d'applications C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Le rôle du SDK .NET Framework 3.5. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Création d'applications C# à l'aide de csc.exe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Création d'applications .NET à l'aide de TextPad. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Création d'applications .NET à l'aide de Notepad++. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Création d'applications .NET à l'aide de SharpDevelop. . . . . . . . . . . . . . . . . . . . . . . . . . . 48
Création d'applications .NET à l'aide de Visual C# 2008 Express . . . . . . . . . . . . . . . . . . 50
Création d'applications .NET à l'aide de Visual Studio 2008 . . . . . . . . . . . . . . . . . . . . . . 52
Un catalogue partiel d'outils de développement .NET supplémentaires. . . . . . . . . . . . . . . . . . . . 64
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
iv
Partie 2 nnn Constructions de programmation Core C#
nCHAPITRE 3 Constructions de programmation de base C#, partie I . . . . . . . . . . . . . . . . . . . . . . . . . 69
L'anatomie d'un programme C# simple. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Un aparté intéressant : quelques membres supplémentaires du
Classe Système.Environnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
La classe System.Console. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Types de données système et notation abrégée C#. . . . . . . . . . . . . . . . . . . . . . . . . . . 80
Comprendre le type System.String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Réduction et élargissement des conversions de types de données. . . . . . . . . . . . . . . . . . . . . . . . . . 95
Constructions d'itération C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Constructions décisionnelles et opérateurs relationnels/égalité. . . . . . . . . . . . . . . . . 102
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
nCHAPITRE 4 Constructions de programmation de base C#, partie II . . . . . . . . . . . . . . . . . . . . . . . . 107
Méthodes et modificateurs de paramètres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
Comprendre la surcharge des membres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Manipulation de tableaux en C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Comprendre le type Enum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Comprendre le type de structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
Comprendre les types valeur et les types référence . . . . . . . . . . . . . . . . . . . . . . . . 129
Types de valeur et de référence : derniers détails. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Comprendre les types nullables C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
nCHAPITRE 5 Définition des types de classes encapsulées. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
Présentation du type de classe C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
Comprendre les constructeurs de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
Le rôle de ce mot-clé. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Comprendre le mot clé statique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
Définir les piliers de la POO. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
Modificateurs d'accès C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
Le premier pilier : les services d'encapsulation de C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
Comprendre les données constantes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
Comprendre les champs en lecture seule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
Comprendre les types partiels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
Documenter le code source C# via XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
Visualiser les fruits de notre travail. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
nCHAPITRE 6 Comprendre l'héritage et le polymorphisme . . . . . . . . . . . . . . . . . . 185
Les mécanismes de base de l'héritage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
Révision des diagrammes de classes Visual Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
Le deuxième pilier : les détails de l'héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
Programmation pour le confinement/délégation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
nTABLE DES MATIÈRES v
vi nTABLE DES MATIÈRES
Le troisième pilier : le support polymorphe de C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
Comprendre les règles de conversion de classe de base/classe dérivée. . . . . . . . . . . . . . . . . . . 210
La classe parent principale : System.Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
nCHAPITRE 7 Comprendre la gestion structurée des exceptions. . . . . . . . . . . . . . . . . . . 219
Ode aux erreurs, bugs et exceptions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
Le rôle de la gestion des exceptions .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
L'exemple le plus simple possible. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
Configuration de l'état d'une exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
Exceptions au niveau du système (System.SystemException) . . . . . . . . . . . . . . . . . . . . . 230
Exceptions au niveau de l'application (System.ApplicationException) . . . . . . . . . . . . . . . 231
Traitement de plusieurs exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
Le bloc final. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
Qui lance quoi ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
Le résultat d'exceptions non gérées. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
Débogage des exceptions non gérées à l'aide de Visual Studio . . . . . . . . . . . . . . . . . . . . 242
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
nCHAPITRE 8 Comprendre la durée de vie des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
Classes, objets et références . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
Les bases de la durée de vie des objets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
Le rôle des racines d'application. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
Comprendre les générations d'objets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
Le type System.GC. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
Construction d'objets finalisables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
Construire des objets jetables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
Création de types finalisables et jetables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
Partie 3 nnn Constructions de programmation C# avancées
nCHAPITRE 9 Utilisation des interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
Comprendre les types d'interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
Définition d'interfaces personnalisées. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
Implémentation d'une interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
Appel de membres d'interface au niveau de l'objet. . . . . . . . . . . . . . . . . . . . . . . . . 276
Interfaces comme paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
Interfaces comme valeurs de retour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
Tableaux de types d'interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
Implémentation d'interfaces à l'aide de Visual Studio 2008 . . . . . . . . . . . . . . . . . . . . . . . 282
Résolution des conflits de noms via l'implémentation d'une interface explicite. . . . . . . . . . . . . 283
Conception de hiérarchies d'interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286
Création de types énumérables (IEnumerable et IEnumerator) . . . . . . . . . . . . . . . 289
Création d'objets clonables (ICloneable) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
Création d'objets comparables (IComparable). . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
Comprendre les interfaces de rappel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308
nCHAPITRE 10 Collections et génériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
Les interfaces de l'espace de noms System.Collections . . . . . . . . . . . . . . . . . . . . . 309
Les types de classe de System.Collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
System.Collections.Espace de noms spécialisé. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
La relation Boxing, Unboxing et System.Object. . . . . . . . . . . . . . . . . . . 316
La question de la sécurité des types et des collections fortement typées. . . . . . . . . . . . . . . . . . 319
L'espace de noms System.Collections.Generic . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
Création de méthodes génériques personnalisées. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
Création de structures et de classes génériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
Création d'une collection générique personnalisée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332
Création de classes de base génériques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
Création d'interfaces génériques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
nCHAPITRE 11 Délégués, événements et Lambdas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
Comprendre le type de délégué .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
Définir un délégué en C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
Classes de base System.MulticastDelegate et System.Delegate. . . . . . . . . 344
L'exemple de délégué le plus simple possible. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345
Modernisation du type de voiture avec des délégués. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348
Un exemple de délégué plus élaboré. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
Comprendre la covariance des délégués. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
Création de délégués génériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
Comprendre les événements C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
Le délégué générique EventHandler. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369
Comprendre les méthodes anonymes C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370
Comprendre les conversions de groupes de méthodes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
L'opérateur Lambda C# 2008. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
nCHAPITRE 12 Indexeurs, opérateurs et pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
Comprendre les méthodes d'indexation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
Comprendre la surcharge des opérateurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
Comprendre les conversions de types personnalisés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397
Travailler avec des types de pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404
Directives du préprocesseur C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414
nCHAPITRE 13 Fonctionnalités du langage C# 2008 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
Comprendre les variables locales implicitement typées. . . . . . . . . . . . . . . . . . . . . . . . . . 415
Comprendre les propriétés automatiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
Comprendre les méthodes d'extension. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424
nTABLE DES MATIÈRES vii
Comprendre les méthodes partielles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
Comprendre la syntaxe de l'initialiseur d'objet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436
Comprendre les types anonymes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445
nCHAPITRE 14 Une introduction à LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
Comprendre le rôle de LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
Un premier aperçu des expressions de requête LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450
LINQ et collections génériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456
LINQ et collections non génériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457
La représentation interne des opérateurs de requête LINQ. . . . . . . . . . . . . . . . . . . . . 459
Enquête sur les opérateurs de requête C# LINQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463
Requêtes LINQ : une île à elle seule ?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 469
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472
PARTIE 4 nnn Programmation avec des assemblys .NET
nCHAPITRE 15 Présentation des assemblys .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475
Définition d'espaces de noms personnalisés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475
Le rôle des assemblys .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480
Comprendre le format d'un assembly .NET. . . . . . . . . . . . . . . . . . . . . . . . . . 482
Création et consommation d'un assemblage à fichier unique . . . . . . . . . . . . . . . . . . . . . . . . . 486
Création et consommation d'un assemblage multifichier. . . . . . . . . . . . . . . . . . . . . . . . . . . 496
Comprendre les assemblées privées. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499
Comprendre les assemblys partagés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504
Consommation d'un assemblage partagé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510
Configuration des assemblys partagés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512
Enquête sur la composition interne du GAC . . . . . . . . . . . . . . . . . . . . . . . . 516
Présentation des assemblys de stratégie d'éditeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518
Comprendre l'élément . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519
L'espace de noms System.Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521
Le fichier de configuration de la machine. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522
nCHAPITRE 16 Réflexion de type, liaison tardive et basée sur les attributs
Programmation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523
La nécessité des métadonnées de type. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523
Comprendre la réflexion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527
Création d'une visionneuse de métadonnées personnalisée. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 530
Chargement dynamique des assemblages. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 536
Réflexion sur les assemblées partagées. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538
Comprendre la liaison tardive. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 539
viii nTABLE DES MATIÈRES
Comprendre la programmation attribuée. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542
Création d'attributs personnalisés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546
Attributs au niveau de l'assemblage (et au niveau du module). . . . . . . . . . . . . . . . . . . . . . . . . . 549
Réflexion sur les attributs à l'aide de la liaison anticipée. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550
Réflexion sur les attributs utilisant la liaison tardive. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 551
Mise en perspective de la réflexion, de la liaison tardive et des attributs personnalisés . . . . . . 553
Création d'une application extensible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 559
nCHAPITRE 17 Processus, domaines d'application et contextes d'objets . . . . . . . . . . . . . . . . . . . 561
Révision des processus Win32 traditionnels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 561
Interagir avec les processus sous la plate-forme .NET. . . . . . . . . . . . . . . . . . . . . . 563
Comprendre les domaines d'application .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 571
Comprendre les limites du contexte des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 577
Résumer les processus, les domaines d'application et le contexte. . . . . . . . . . . . . . . . . . . . . . 581
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 582
nCHAPITRE 18 Création d'applications multithread. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583
La relation processus/domaine d'application/contexte/thread. . . . . . . . . . . . . . . . . . . . 583
Un bref examen du délégué .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585
La nature asynchrone des délégués. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 587
Appel d'une méthode de manière asynchrone. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588
L'espace de noms System.Threading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593
La classe System.Threading.Thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594
Création par programme de threads secondaires. . . . . . . . . . . . . . . . . . . . . . . . . . 597
La question de la concurrence. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 602
Programmation avec rappels de minuterie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609
Comprendre le ThreadPool CLR. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 610
Le rôle du composant BackgroundWorker. . . . . . . . . . . . . . . . . . . . . . . . . . 612
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 616
nCHAPITRE 19 Comprendre CIL et le rôle des assemblys dynamiques . . . . . . . . 617
Réflexion sur la nature de la programmation CIL . . . . . . . . . . . . . . . . . . . . . . . . . . . 617
Examen des directives, attributs et codes d'opération CIL. . . . . . . . . . . . . . . . . . . . . . . 618
Pushing et Popping : la nature basée sur la pile de CIL. . . . . . . . . . . . . . . . . . . . 620
Comprendre l’ingénierie aller-retour. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621
Comprendre les directives et les attributs CIL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 629
Bibliothèque de classes de base .NET, mappages de types de données C# et CIL . . . . . . . . . . . . . . . . 635
Définition des membres de type dans CIL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636
Examen des opcodes CIL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638
Construire un assembly .NET avec CIL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 643
Comprendre les assemblages dynamiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 648
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657
nTABLE DES MATIÈRES ix
Partie 5 nnn Présentation des bibliothèques de classes de base .NET
nCHAPITRE 20 E/S de fichiers et stockage isolé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661
Explorer l'espace de noms System.IO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661
Les types Répertoire(Info) et Fichier(Info). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 662
Utilisation du type DirectoryInfo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 663
Travailler avec le type de répertoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 667
Utilisation du type de classe DriveInfo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 668
Travailler avec la classe FileInfo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669
Travailler avec le type de fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 673
La classe de flux abstrait. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 675
Travailler avec StreamWriters et StreamReaders . . . . . . . . . . . . . . . . . . . . . . . . 677
Travailler avec StringWriters et StringReaders . . . . . . . . . . . . . . . . . . . . . . . . . . 680
Travailler avec BinaryWriters et BinaryReaders . . . . . . . . . . . . . . . . . . . . . . . . . . 682
« Regarder » les fichiers par programme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 683
Exécution d'E/S de fichiers asynchrones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 685
Comprendre le rôle du stockage isolé. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 687
Une introduction à la sécurité de l'accès au code. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 688
Un aperçu du stockage isolé. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 698
Obtention d'un magasin à l'aide de InsulatedStorageFile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 702
Stockage isolé en action : déploiement ClickOnce. . . . . . . . . . . . . . . . . . . . . . . . 707
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 710
nCHAPITRE 21 Présentation de la sérialisation d'objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711
Comprendre la sérialisation des objets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711
Configuration des objets pour la sérialisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 713
Choisir un formateur de sérialisation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 715
Sérialisation d'objets à l'aide de BinaryFormatter . . . . . . . . . . . . . . . . . . . . . . . . . . . 717
Sérialisation d'objets à l'aide de SoapFormatter . . . . . . . . . . . . . . . . . . . . . . . . . . . . 719
Sérialisation d'objets à l'aide de XmlSerializer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 720
Sérialisation de collections d'objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 723
Personnalisation du processus de sérialisation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 724
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 729
nCHAPITRE 22 ADO.NET Partie I : La couche connectée. . . . . . . . . . . . . . . . . . . . . . . . . . . . 731
Une définition de haut niveau d'ADO.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 731
Comprendre les fournisseurs de données ADO.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 733
Espaces de noms ADO.NET supplémentaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 736
Les types d’espace de noms System.Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 737
Abstraction des fournisseurs de données à l'aide d'interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 741
Création de la base de données AutoLot. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 744
Le modèle de fabrique de fournisseur de données ADO.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 749
Comprendre la couche connectée d'ADO.NET. . . . . . . . . . . . . . . . . . . . . . . . . 755
Travailler avec des lecteurs de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 760
Création d'une bibliothèque d'accès aux données réutilisable. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 763
x nTABLE DES MATIÈRES
Création d'un frontal basé sur l'interface utilisateur de la console . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 770
Accès aux données asynchrones à l'aide de SqlCommand . . . . . . . . . . . . . . . . . . . . . . . . . 775
Comprendre les transactions de base de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 777
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 781
nCHAPITRE 23 ADO.NET Partie II : La couche déconnectée . . . . . . . . . . . . . . . . . . . . . . . . 783
Comprendre la couche déconnectée d'ADO.NET. . . . . . . . . . . . . . . . . . . . . . 783
Comprendre le rôle du DataSet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 784
Travailler avec DataColumns. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 787
Travailler avec DataRows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 789
Travailler avec des DataTables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 793
Liaison d’objets DataTable aux interfaces utilisateur. . . . . . . . . . . . . . . . . . . . . . . . . . . . 798
Remplissage d'objets DataSet/DataTable à l'aide d'adaptateurs de données. . . . . . . . . . . . . . . . . . . 808
Revisiter AutoLotDAL.dll. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 811
Navigation dans les objets DataSet multitables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 814
Les outils d'accès aux données de Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . . . . . . . . 820
Découplage du code généré automatiquement de la couche d'interface utilisateur. . . . . . . . . . . . . . . . . . . . . . . 831
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 835
nCHAPITRE 24 Programmation avec les API LINQ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 837
Le rôle de LINQ to ADO.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 837
Programmation avec LINQ to DataSet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 838
Programmation avec LINQ to SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 843
Génération de classes d'entités à l'aide de SqlMetal.exe . . . . . . . . . . . . . . . . . . . . . . . . . . . 848
Création de classes d'entités à l'aide de Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . . . . . 854
Manipulation de documents XML à l'aide de LINQ to XML. . . . . . . . . . . . . . . . . . . . . . . . 857
Navigation dans un document en mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 862
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 865
nCHAPITRE 25 Présentation de Windows Communication Foundation. . . . . . . . . . . . . . . 867
Un pot-pourri d'API d'informatique distribuée. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 867
Le rôle de la WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 873
Enquête sur les assemblys WCF de base. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 876
Les modèles de projet Visual Studio WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 877
La composition de base d'une application WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . 879
L'ABC de WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 880
Création d'un service WCF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 885
Hébergement du service WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 888
Création de l'application client WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 896
Utilisation du modèle de projet de bibliothèque de services WCF. . . . . . . . . . . . . . . . . . . . . . . . . 900
Hébergement du service WCF en tant que service Windows. . . . . . . . . . . . . . . . . . . . . . . . . 903
Appel d'un service de manière asynchrone. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 908
Conception de contrats de données WCF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 910
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 915
nTABLE DES MATIÈRES xi
nCHAPITRE 26 Présentation de Windows Workflow Foundation . . . . . . . . . . . . . . . . . . . . . 917
Définir un processus métier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 917
Les éléments constitutifs de WF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 918
Assemblages, espaces de noms et projets WF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 924
Création d'une application simple compatible avec le workflow. . . . . . . . . . . . . . . . . . . . . . . . . 926
Examen du code d'hébergement du moteur WF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 930
Appel de services Web dans les flux de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 934
Création d'une bibliothèque de codes WF réutilisable. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 945
Un bref mot concernant les activités personnalisées. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 951
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 952
Partie 6 nnn Interfaces utilisateur de bureau
nCHAPITRE 27 Programmation avec Windows Forms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 955
Les espaces de noms Windows Forms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 955
Création d'une application Windows Forms simple (sans IDE). . . . . . . . . . . . . . . . . . 956
Le modèle de projet Visual Studio Windows Forms. . . . . . . . . . . . . . . . . . . . . . 961
L'anatomie d'une forme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 968
Répondre à l'activité de la souris. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 975
Répondre à l'activité du clavier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 977
Conception de boîtes de dialogue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 978
Rendu de données graphiques à l'aide de GDI+. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 985
Création d'une application Windows Forms complète. . . . . . . . . . . . . . . . . . . . . . . . 990
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 997
nCHAPITRE 28 Présentation de Windows Presentation Foundation et de XAML . . . . . . . 999
La motivation derrière WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 999
Les différentes saveurs des applications WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1002
Enquête sur les assemblées WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1004
Création d'une application WPF (sans XAML). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1011
Détails supplémentaires sur le type de demande. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1015
Détails supplémentaires sur le type de fenêtre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1017
Création d'une application WPF (centrée sur XAML). . . . . . . . . . . . . . . . . . . . . . . . . . . . 1021
Transformer le balisage en un assembly .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . 1025
Séparation des préoccupations à l'aide de fichiers Code-Behind. . . . . . . . . . . . . . . . . . . . . . . 1029
La syntaxe de XAML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1031
Création d'applications WPF à l'aide de Visual Studio 2008. . . . . . . . . . . . . . . . . . . . . 1044
Traitement du XAML au moment de l'exécution : SimpleXamlPad.exe . . . . . . . . . . . . . . . . . . . . . . 1048
Le rôle de Microsoft Expression Blend. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1052
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1053
xii nTABLE DES MATIÈRES
nCHAPITRE 29 Programmation avec les contrôles WPF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1055
Une enquête sur la bibliothèque de contrôles WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1055
Déclaration des contrôles en XAML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1058
Comprendre le rôle des propriétés de dépendance . . . . . . . . . . . . . . . . . . . . . . 1060
Comprendre les événements routés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1064
Travailler avec des types de boutons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1068
Travailler avec des CheckBoxes et des RadioButtons . . . . . . . . . . . . . . . . . . . . . . . . . . . 1072
Travailler avec les types ListBox et ComboBox . . . . . . . . . . . . . . . . . . . . . . . . 1075
Travailler avec des zones de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1081
Contrôler la mise en page du contenu à l'aide de panneaux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1083
Construire le cadre d'une fenêtre à l'aide de panneaux imbriqués. . . . . . . . . . . . . . . . . . . . . . . 1093
Comprendre les commandes de contrôle WPF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1099
Comprendre le modèle de liaison de données WPF . . . . . . . . . . . . . . . . . . . . . . . . . . . 1102
Conversion de données à l'aide de IValueConverter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1106
Liaison à des objets personnalisés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1108
Liaison d'éléments d'interface utilisateur à des documents XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1112
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1116
nCHAPITRE 30 Rendu graphique, ressources et thèmes 2D WPF . . . . . . . . . 1117
La philosophie des services de rendu graphique WPF. . . . . . . . . . . . . . . . . . . . 1117
Explorer les types dérivés de formes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1124
Travailler avec les pinceaux WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1127
Travailler avec les stylos WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11h30
Explorer les types dérivés de dessins. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11h30
Le rôle des transformations de l'interface utilisateur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1135
Comprendre les services d'animation de WPF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1136
Comprendre le système de ressources WPF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1145
Définition et application de styles pour les contrôles WPF . . . . . . . . . . . . . . . . . . . . . . . . . 1147
Modification de l'interface utilisateur d'un contrôle à l'aide de modèles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1156
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1160
Partie 7 nnn Création d'applications Web avec ASP.NET
nCHAPITRE 31 Création de pages Web ASP.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1163
Le rôle de HTTP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1163
Comprendre les applications Web et les serveurs Web . . . . . . . . . . . . . . . . . . . . . . 1164
Le rôle du HTML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1167
Le rôle des scripts côté client. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1172
Soumission des données du formulaire (GET et POST) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1174
Création d'une page ASP classique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1175
Problèmes avec l'ASP classique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1177
Les espaces de noms ASP.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1178
Le modèle de code de page Web ASP.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1179
Détails d'une structure de répertoire de site Web ASP.NET. . . . . . . . . . . . . . . . . . . . . . 1190
Le cycle de compilation de pages ASP.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1192
nTABLE DES MATIÈRES xiii
La chaîne d'héritage du type de page. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1194
Interagir avec la requête HTTP entrante. . . . . . . . . . . . . . . . . . . . . . . . . . . 1195
Interagir avec la réponse HTTP sortante. . . . . . . . . . . . . . . . . . . . . . . . . . 1198
Le cycle de vie d'une page Web ASP.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1200
Le rôle du fichier Web.config. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1203
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1206
nCHAPITRE 32 Contrôles Web, thèmes et pages maîtres ASP.NET . . . . . . . . . . . . 1207
Comprendre la nature des contrôles Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1207
Le type System.Web.UI.Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1209
Type System.Web.UI.WebControls.WebControl. . . . . . . . . . . . . . . . . . . . . . 1213
Principales catégories de contrôles Web ASP.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1213
Création d'un site Web ASP.NET riche en fonctionnalités. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1215
Le rôle des contrôles de validation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1231
Travailler avec des thèmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1237
Contrôles de positionnement à l'aide de tableaux HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1243
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1244
nCHAPITRE 33 Techniques de gestion d'état ASP.NET . . . . . . . . . . . . . . . . . . . . . . . 1245
La question de l'État. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1245
Techniques de gestion d'état ASP.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1247
Comprendre le rôle de l'état d'affichage ASP.NET. . . . . . . . . . . . . . . . . . . . . . . . . 1248
Le rôle du fichier Global.asax. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1251
Comprendre la distinction application/session. . . . . . . . . . . . . . . . . . . . . . 1254
Travailler avec le cache d'application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1259
Gestion des données de session . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1263
Comprendre les cookies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1267
Le rôle de l'élément . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1269
Comprendre l'API de profil ASP.NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1272
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1279
Partie 8 nnn Annexes
nANNEXE A Interopérabilité COM et .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1283
La portée de l'interopérabilité .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1283
Un exemple simple de .NET vers COM Interop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1284
Enquête sur un assembly .NET Interop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1287
Comprendre le wrapper appelable au moment de l'exécution. . . . . . . . . . . . . . . . . . . . . . . . . . 1289
Le rôle de COM IDL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1292
Utilisation d'une bibliothèque de types pour créer un assembly d'interopérabilité. . . . . . . . . . . . . . . . . . . . . . 1296
Construire un serveur COM plus élaboré. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1299
Examen de l'assemblage d'interopérabilité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1301
Comprendre l'interopérabilité COM vers .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . 1305
Le rôle de la CCAC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1306
Le rôle de l'interface de classe .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1307
xiv nTABLE DES MATIÈRES
Création de vos types .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1308
Génération de la bibliothèque de types et enregistrement des types .NET. . . . . . . . . . . . . . 1310
Examen des informations de type exportées. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1311
Création d'un client de test Visual Basic 6.0. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1312
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1313
nANNEXE B Développement .NET indépendant de la plate-forme avec Mono . . . . . . . . . . . 1315
La nature indépendante de la plate-forme de .NET. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1315
Obtention et installation de Mono . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1318
Les outils de développement Mono. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1321
Création d'applications .NET avec Mono . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1323
Suggestions pour une étude plus approfondie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1330
Résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1331
nINDEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1333
Développer
