C# 10 : développez des applications Windows avec Visual Studio 2022

Auteur(s) :

Hugon, Jérôme Découvrir l'auteur

Résumé

Découverte des bases de C# 10 et des possibilités les plus avancées offertes par ce langage, Visual Studio et le framework. L'auteur propose de construire une application fonctionnelle tout au long de l'ouvrage pour aborder les concepts de manière pratique. Avec des compléments à télécharger. Version gratuite en ligne.

Éditeur(s)
- Éditions ENI
Date
- C 2022
Notes
- La couv. porte en plus : "Informatique technique" ; "En téléchargement : code source des exemples" ; "+ quiz" ; "Version en ligne offerte ! pendant 1 an"
- La 4e de couv. porte en plus : "Sur www.editions-eni.fr : le code source des exemples du livre"
- Contient un "flashcode" permettant d'accéder à un contenu via Internet
Langues
- Français
Description matérielle
- 1 vol. (532 p.) : ill. ; 22 cm
Collections
- Expert IT
Sujet(s)
ISBN
- 978-2-409-03513-5
Indice
- 681.229 Langages C
Quatrième de couverture
- C# 10 - Développez des applications Windows avec Visual Studio 2022
  Ce livre sur le développement d'applications Windows avec le langage C# (en version 10) et Visual Studio 2022 est destiné aux développeurs qui débutent avec le framework .NET. Il leur permet d'apprendre les bases du langage C# et Introduit des concepts plus avancés leur donnant une vue d'ensemble des possibilités offertes par le langage C#, Visual Studio et le framework .NET en général. L'auteur a choisi une approche pas à pas tout en construisant une application fonctionnelle tout au long de l'ouvrage pour illustrer de manière pratique et cohérente les concepts abordés.
  L'apprentissage commence par la familiarisation avec l'interface de Visual Studio 2022 ainsi qu'avec le concept de l'architecture .NET. Les détails du langage C#, sa syntaxe et ses fonctionnalités comme les classes, l'héritage, les interfaces, les types génériques ou encore les délégués et les évènements sont ensuite expliqués avant d'aborder la conception d'interfaces utilisateur.
  La conception de l'interface utilisateur couvre toutes les phases utiles pour créer des applications Windows à la fois fonctionnelles et ergonomiques, allant de la création de formulaires à la création de contrôles en passant par l'Implémentation de gestionnaire d'évènements et la validation des données saisies. Une introduction à la conception d'application WPF est également incluse.
  Les outils de Visual Studio qui permettent de réaliser les tests et le débogage des applications sont également détaillés en présentant les techniques de gestion des erreurs mais aussi les concepts permettant de surveiller les applications comme le traçage, l'interaction avec les journaux d'évènements et l'utilisation des compteurs de performance.
  L'utilisation de Entity Framework est détaillée au sein d'exemples concrets permettant de comprendre rapidement comment créer des modèles de données et comment les utiliser pour communiquer avec une base de données, tout en apprenant à utiliser le langage de requête LINQ pour interagir avec des données sous différents formats (objets, SQL ou XML). L'alternative au stockage de données d'une application sur le système de fichiers et l'utilisation du concept de la sérialisation sont également détaillées, fournissant ainsi une vision globale des possibilités offertes par le framework .NET concernant la gestion des données.
  Des concepts plus avancés sont également abordés afin d'exposer une gamme plus large des possibilités offertes par le langage C# et Visual Studio : l'utilisation des expressions régulières, le développement d'applications multitâches et asynchrones, la globalisation et la localisation d'une application, la sécurité du code, l'implémentation d'applications client/serveur, le dessin avec GDI+ ainsi que la réflexion font partie des sujets introduits.
  La dernière partie de l'ouvrage est consacrée à la création d'assemblages ainsi qu'au déploiement des applications. Les outils et techniques mis à disposition par Visual Studio pour créer des installeurs Windows et configurer les applications y sont détaillés.
  Le code de l'application exemple traitée dans l'ouvrage est en téléchargement sur le site www.editions-eni.fr.
Tables des matières
- - C# 10
  - Développez des applications Windows avec Visual Studio 2022
  - Édition Eni
  - Avant-propos
  - Chapitre 1
  - Travailler avec Visual Studio 2022
  - 1. Introduction19
  - 2. L'interface de développement20
  - 2.1 L'éditeur de texte22
  - 2.2 Le concepteur de vues27
  - 2.3 Le débogueur intégré28
  - 2.4 Le gestionnaire d'extensions29
  - 2.5 NuGet31
  - 2.6 Fenêtres personnalisées33
  - 3. La création de solutions33
  - 3.1 Définir le point d'entrée34
  - 3.2 La différence entre projets et solutions36
  - 3.3 Configurer le projet37
  - 3.4 La conversion de solutions39
  - 3.5 Les projets partagés39
  - 3.6 Les outils de refactorisation41
  - Chapitre 2
  - L'architecture .NET
  - 1. Introduction43
  - 2. CLR44
  - 3. Les bibliothèques de classes45
  - 4. Les types47
  - 4.1 Les types valeur48
  - 4.2 Les types référence49
  - Chapitre 3
  - Introduction au langage C#
  - 1. La syntaxe51
  - 1.1 Les identifiants51
  - 1.2 Les mots-clés51
  - 1.3 La ponctuation53
  - 1.4 Les opérateurs54
  - 1.4.1 Les opérateurs de calcul54
  - 1.4.2 Les opérateurs d'assignation55
  - 1.4.3 Les opérateurs de comparaison55
  - 1.5 La déclaration de variables56
  - 1.6 Les instructions de contrôle57
  - 1.6.1 Les instructions conditionnelles57
  - 1.6.2 Les instructions itératives62
  - 1.6.3 Les instructions de saut65
  - 1.7 Les commentaires67
  - 2. Les espaces de noms70
  - 2.1 Déclarer un espace de noms71
  - 2.2 Le mot-clé using71
  - 2.3 Le mot-clé alias72
  - 2.4 Les classes statiques73
  - 2.5 Les directives using globales73
  - 3. Les types de base73
  - 3.1 Les types numériques73
  - 3.1.1 Les entiers74
  - 3.1.2 Les décimaux75
  - 3.2 Les booléens75
  - 3.3 Les chaînes de caractères75
  - 3.4 Les types nullable78
  - 3.5 La conversion de types80
  - 3.5.1 La conversion implicite80
  - 3.5.2 La conversion explicite81
  - 4. Les constantes et les énumérations82
  - 4.1 Les constantes82
  - 4.2 Les énumérations82
  - 5. Les tableaux85
  - 6. Les collections86
  - 7. Les directives preprocessor88
  - Chapitre 4
  - La création de types
  - 1. Introduction91
  - 2. Les niveaux d'accès92
  - 3. Les structures93
  - 4. Les classes94
  - 4.1 Les champs94
  - 4.2 Les propriétés95
  - 4.3 Les méthodes98
  - 4.3.1 La surcharge100
  - 4.3.2 Les paramètres100
  - 4.3.3 Les tuples107
  - 4.3.4 Les méthodes partielles107
  - 4.4 Les constructeurs108
  - 4.5 Les destructeurs109
  - 4.6 Les classes et membres statiques110
  - 4.7 Les classes partielles110
  - 4.8 Le mot-clé this112
  - 4.9 Les indexeurs113
  - 4.10 Les attributs114
  - 4.11 La surcharge d'opérateurs115
  - 4.11.1 Les opérateurs arithmétiques116
  - 4.11.2 Les opérateurs de comparaison118
  - 5. Les records120
  - Chapitre 5
  - L'héritage
  - 1. L'héritage de classe121
  - 1.1 Implémenter l'héritage121
  - 1.2 Les membres virtuels123
  - 1.3 Masquer les membres hérités124
  - 1.4 Le mot-clé base125
  - 1.5 Les classes et membres abstraits125
  - 1.6 Les classes et les méthodes scellées126
  - 1.7 Les constructeurs dérivés128
  - 1.8 Le polymorphisme130
  - 2. Les interfaces132
  - 2.1 L'implémentation d'interfaces132
  - 2.2 Le polymorphisme d'interface134
  - 2.3 L'héritage d'interfaces136
  - Chapitre 6
  - Types génériques
  - 1. Introduction137
  - 2. La création de types génériques138
  - 3. Les contraintes de type141
  - 4. Les interfaces génériques142
  - 4.1 La variance dans les interfaces génériques143
  - 4.1.1 La covariance143
  - 4.1.2 La contravariance144
  - 4.2 La création d'interfaces génériques variantes145
  - 4.3 L'héritage d'interfaces génériques variantes146
  - 5. La création de méthodes génériques147
  - 6. Valeur par défaut générique150
  - 7. L'héritage de classe générique150
  - Chapitre 7
  - Délégués, événements et expressions lambda
  - 1. Les délégués151
  - 1.1 Les paramètres de méthode152
  - 1.2 Les méthodes cibles multiples153
  - 1.3 Les délégués génériques154
  - 1.4 La compatibilité des délégués154
  - 2. Les événements156
  - 3. Les expressions lambda159
  - 3.1 L'utilisation des expressions lambda160
  - 3.2 Les délégués génériques162
  - 3.3 La capture de variable162
  - 3.4 Les fonctions locales165
  - Chapitre 8
  - Création de formulaires
  - 1. Utiliser les formulaires167
  - 1.1 Ajouter des formulaires au projet167
  - 1.2 Modifier le formulaire de démarrage170
  - 1.3 Les propriétés des formulaires170
  - 1.4 Les méthodes des formulaires173
  - 1.5 Les événements des formulaires174
  - 2. Utiliser les contrôles175
  - 2.1 Les types de contrôles175
  - 2.2 Ajouter des contrôles aux formulaires177
  - 2.3 Les propriétés des contrôles179
  - 2.4 Les menus181
  - 2.5 Les conteneurs183
  - 2.6 L'ergonomie185
  - 2.7 Ajouter des contrôles à la boîte à outils186
  - Chapitre 9
  - Implémentation de gestionnaires d'événements
  - 1. Introduction189
  - 2. La création de gestionnaires d'événements190
  - 2.1 La mécanique d'un événement192
  - 2.2 L'ajout dynamique d'un gestionnaire d'événements192
  - 2.3 La suppression dynamique d'un gestionnaire d'événements193
  - 3. Les gestionnaires d'événements avancés194
  - 3.1 Un gestionnaire pour plusieurs événements194
  - 3.2 Plusieurs gestionnaires pour un événement195
  - Chapitre 10
  - Validation de la saisie
  - 1. Introduction197
  - 2. La validation au niveau des champs197
  - 2.1 Les propriétés de validation197
  - 2.2 Les événements de validation198
  - 2.2.1 KeyDown et KeyUp198
  - 2.2.2 KeyPress199
  - 2.2.3 Validating et Validated199
  - 3. La validation au niveau du formulaire201
  - 4. Les méthodes de retour à l'utilisateur204
  - 4.1 MessageBox205
  - 4.2 ErrorProvider206
  - Chapitre 11
  - Création de contrôles utilisateurs
  - 1. Introduction209
  - 2. Les contrôles personnalisés210
  - 3. L'héritage de contrôles212
  - 4. Les contrôles utilisateurs214
  - Chapitre 12
  - Création d'applications UWP
  - 1. Introduction221
  - 2. Principes222
  - 3. Les outils de développement224
  - 4. Le langage XAML226
  - 5. Une première application UWP229
  - 5.1 Les bases d'un projet UWP229
  - 5.2 Les contrôles et événements231
  - 5.3 Les styles232
  - Chapitre 13
  - Débogage
  - 1. Les types d'erreurs237
  - 1.1 Les erreurs de syntaxe237
  - 1.2 Les erreurs d'exécution238
  - 1.3 Les erreurs de logique240
  - 2. Le débogueur240
  - 2.1 Contrôler l'exécution242
  - 2.2 Les points d'arrêt243
  - 2.2.1 Les conditions d'arrêt244
  - 2.2.2 Le nombre d'accès245
  - 2.2.3 Le filtrage246
  - 2.2.4 Les actions246
  - 2.2.5 Exécuter l'exécution jusqu'ici247
  - 2.3 Les DataTips247
  - 2.4 Les PerfTips248
  - 2.5 Les attributs Caller249
  - 3. Les fenêtres251
  - 3.1 La fenêtre Sortie252
  - 3.2 La fenêtre Variables locales252
  - 3.3 La fenêtre Automatique253
  - 3.4 La fenêtre Espion253
  - 3.5 La fenêtre Exécution254
  - 3.6 Les autres fenêtres255
  - Chapitre 14
  - Gestion des exceptions
  - 1. La classe Exception257
  - 2. La création d'exceptions personnalisées258
  - 3. Le déclenchement des exceptions259
  - 4. L'interception et la gestion des exceptions262
  - Chapitre 15
  - Monitoring
  - 1. Le traçage269
  - 1.1 Les classes Debug et Trace269
  - 1.2 La collection d'écouteurs272
  - 1.2.1 La création d'écouteurs272
  - 1.2.2 La sauvegarde des traces273
  - 1.3 Les commutateurs de trace275
  - 1.3.1 Le fonctionnement des commutateurs de trace275
  - 1.3.2 La configuration des commutateurs de trace276
  - 2. Les journaux d'événements277
  - 2.1 L'interaction avec les journaux d'événements278
  - 2.2 La gestion des journaux d'événements279
  - 2.3 L'écriture d'événements280
  - 3. Les compteurs de performance281
  - 3.1 La création de compteurs de performance282
  - 3.1.1 Depuis Visual Studio282
  - 3.1.2 Depuis le code283
  - 3.2 L'utilisation de compteurs de performance285
  - 3.3 L'analyse de compteurs de performance288
  - Chapitre 16
  - Tests unitaires
  - 1. Introduction aux tests unitaires291
  - 1.1 La création du projet291
  - 1.2 Les classes de tests unitaires292
  - 2. La mise en place d'une série de tests294
  - 2.1 La création de tests au projet294
  - 2.2 Le déroulement des tests295
  - Chapitre 17
  - Création du modèle de données
  - 1. Introduction299
  - 2. La création d'un modèle300
  - 3. La création d'entités302
  - 4. La génération de la base de données308
  - 5. La création d'entités à partir du code (Code First)313
  - Chapitre 18
  - Présentation d'Entity Framework
  - 1. Introduction319
  - 2. Le mappage320
  - 2.1 La couche logique320
  - 2.2 La couche conceptuelle322
  - 2.3 La couche de mappage325
  - 3. Travailler avec les entités326
  - 3.1 Les entités328
  - 3.2 La classe DbContext329
  - 3.3 Les relations330
  - 3.3.1 Le concept de table par type330
  - 3.3.2 Le concept de table par hiérarchie330
  - Chapitre 19
  - Présentation de LINQ
  - 1. Les requêtes LINQ333
  - 1.1 La syntaxe333
  - 1.2 Les méthodes d'extension334
  - 2. Les opérateurs de requêtes336
  - 2.1 Filtrer336
  - 2.1.1 Where336
  - 2.1.2 OfType<TResult>336
  - 2.1.3 SelectMany337
  - 2.1.4 Skip et Take337
  - 2.2 Ordonner338
  - 2.2.1 OrderBy338
  - 2.2.2 ThenBy339
  - 2.3 Grouper339
  - 2.3.1 GroupBy339
  - 2.3.2 Join340
  - 2.4 Agréger341
  - 2.5 Convertir341
  - 3. Les requêtes parallèles342
  - 3.1 Partitionner une requête343
  - 3.2 Annuler une requête344
  - Chapitre 20
  - LINQ to Entities
  - 1. Introduction345
  - 2. Extraire les données346
  - 2.1 L'extraction simple346
  - 2.2 L'extraction conditionnelle347
  - 3. Ajouter, modifier et supprimer des données349
  - 3.1 Ajouter des données349
  - 3.2 Modifier des données350
  - 3.3 Supprimer des données350
  - 3.4 L'envoi des modifications350
  - Chapitre 21
  - LINQ to SQL
  - 1. La création de classes LINQ to SQL351
  - 2. L'objet DataContext354
  - 2.1 La méthode ExecuteQuery355
  - 2.2 Utiliser des transactions355
  - 2.3 Les autres membres de DataContext356
  - 3. Exécuter des requêtes avec LINQ357
  - 3.1 Les requêtes simples357
  - 3.2 Les requêtes filtrées358
  - 3.3 Les requêtes de jointure358
  - 4. Les procédures stockées358
  - 4.1 L'ajout de procédures stockées au modèle359
  - 4.2 L'exécution de procédures stockées360
  - Chapitre 22
  - LINQ to XML
  - 1. Les objets XML361
  - 1.1 XDocument361
  - 1.2 XElement362
  - 1.3 XNamespace363
  - 1.4 XAttribute364
  - 1.5 XComment364
  - 2. Exécuter des requêtes avec LINQ365
  - 2.1 Les requêtes simples365
  - 2.2 Les requêtes filtrées366
  - 2.3 Les requêtes de jointure366
  - Chapitre 23
  - Le système de fichiers
  - 1. Les classes de gestion du système de fichiers367
  - 1.1 DriveInfo367
  - 1.2 Directory et DirectoryInfo369
  - 1.3 File et FileInfo371
  - 1.4 Path374
  - 2. Travailler avec le système de fichiers377
  - 2.1 Les objets Stream377
  - 2.2 La classe FileStream377
  - 2.3 Lire un fichier texte379
  - 2.3.1 Lire avec la classe File379
  - 2.3.2 Lire avec la classe StreamReader380
  - 2.4 Écrire dans un fichier texte382
  - 2.4.1 Ecrire avec la classe File382
  - 2.4.2 Ecrire avec la classe StreamWriter383
  - Chapitre 24
  - Sérialisation
  - 1. Introduction385
  - 2. La sérialisation binaire386
  - 2.1 Les bases386
  - 2.2 Contrôler la sérialisation388
  - 2.2.1 Le contrôle par attribut388
  - 2.2.2 Le contrôle par interface390
  - 3. La sérialisation XML393
  - 3.1 Les bases394
  - 3.2 Contrôler la sérialisation397
  - 3.3 La sérialisation XML SOAP398
  - Chapitre 25
  - Expressions régulières
  - 1. Introduction401
  - 2. Une première expression régulière402
  - 3. Les options de recherche493
  - 4. Les caractères d'échappement404
  - 5. Les ensembles404
  - 6. Les groupes406
  - 7. Les ancres407
  - 8. Les quantifieurs408
  - Chapitre 26
  - Multithreading
  - 1. Introduction409
  - 2. La classe Thread410
  - 2.1 Créer un thread410
  - 2.2 Suspendre un thread411
  - 2.3 Échanger des données avec un thread412
  - 2.4 Verrouiller un thread414
  - 2.5 Priorité des threads415
  - 3. Fonctions asynchrones416
  - 3.1 Task et Task<TResult>417
  - 3.2 async et await419
  - 4. Le composant BackgroundWorker421
  - Chapitre 27
  - Globalisation et localisation
  - 1. Introduction425
  - 2. La culture426
  - 3. La globalisation428
  - 4. La localisation430
  - Chapitre 28
  - Sécurité
  - 1. Introduction435
  - 2. Les éléments de base436
  - 2.1 L'interface IPermission436
  - 2.2 La classe CodeAccessPermission437
  - 2.3 L'interface IPrincipal437
  - 3. Implémentation de la sécurité439
  - 3.1 La sécurité basée sur les rôles439
  - 3.2 La sécurité basée sur les droits d'accès441
  - 3.2.1 Sécurité impérative441
  - 3.2.2 Sécurité déclarative442
  - 4. Introduction à la cryptographie443
  - Chapitre 29
  - Pour aller plus loin
  - 1. Le dessin avec GDI+447
  - 1.1 La classe Graphics448
  - 1.1.1 Les coordonnées448
  - 1.1.2 Les formes449
  - 1.2 La structure Color et les classes Brush et Pen451
  - 1.2.1 La structure Color451
  - 1.2.2 La classe Brush452
  - 1.2.3 La classe Pen452
  - 1.2.4 Les paramètres système453
  - 1.3 Les exemples453
  - 1.3.1 L'affichage de texte453
  - 1.3.2 Redimensionner une image455
  - 2. Le remoting456
  - 2.1 Le principe456
  - 2.2 L'implémentation457
  - 2.2.1 La couche commune457
  - 2.2.2 L'application serveur458
  - 2.2.3 L'application cliente460
  - 3. Reflection464
  - 3.1 La classe System.Type464
  - 3.2 Charger un assemblage dynamiquement466
  - 3.2.1 L'énumération des types466
  - 3.2.2 L'instanciation d'objets467
  - 3.2.3 L'utilisation des membres468
  - Chapitre 30
  - Assemblages et configurations
  - 1. Introduction471
  - 2. Les assemblages privés472
  - 3. Les assemblages partagés475
  - 4. Les fichiers de configuration476
  - Chapitre 31
  - Déploiement
  - 1. Introduction479
  - 2. Les projets de déploiement480
  - 2.1 XCOPY480
  - 2.2 Projet CAB481
  - 2.3 Projet de module de fusion482
  - 2.4 Projet d'installation482
  - 3. L'assistant Installation483
  - 4. Configuration du projet487
  - 4.1 Les propriétés du projet487
  - 4.2 Les éditeurs de configuration490
  - 4.2.1 Éditeur du système de fichiers491
  - 4.2.2 Éditeur du registre492
  - 4.2.3 Éditeur des types de fichiers493
  - 4.2.4 Éditeur de l'interface utilisateur495
  - 4.2.5 Éditeur des actions personnalisées497
  - 4.2.6 Éditeur des conditions de lancement498
  - Index501
Origine de la notice:
- BPI