Ce livre s’adresse aux étudiants et aux développeurs ayant déjà une première expérience de la programmation structurée et qui sont désireux de passer à la Programmation Orientée Objet (POO) avec le langage C# 10, pour développer des applications .NET

Après un historique de la POO et du langage C#, l’auteur explique pourquoi ce type de programmation est devenu incontournable pour développer dans les environnements graphiques événementiels. Les notions d’objet, de classe et de référence sont présentées suivies par les fondements de la POO que sont l’encapsulation, l’héritage, le polymorphisme et l’abstraction.

Les différentes étapes d’un développement objet avec les principes de modélisation UML sont abordées, suivies par une présentation du .NET 6, de son intérêt, de sa richesse et de son environnement de développement Microsoft Visual Studio 2022 Community.

Le lecteur découvre comment C# 10 reproduit les principes de la POO avec des explications simples, des exemples concrets et des exercices corrigés à télécharger sur le site www.editions-eni.fr. Les types de base du développement .NET et leurs utilisations sont présentés. Les programmes d’essais sont de type console ou graphique, basés sur l’utilisation des Windows Forms et de WPF pour illustrer les communications entre objets. Quand ils seront pertinents, des parallèles seront menés avec les langages de programmation objet C++ et Java.

La programmation multithread et asynchrone, permettant l’exécution simultanée de plusieurs flux d’instructions, sera abordée tout comme la communication entre mondes managés (.NET) et non managés (Win32). L’écriture de tests unitaires objets avec MS Test permettra au lecteur de s’assurer de la stabilité de son code. L’auteur présente ensuite une façon dynamique de programmer par réflexion sur les objets. Le lecteur découvre également comment instrumenter son code pour analyser ses performances, ainsi que l’objet appliqué à la gestion des données avec LINQ, l’utilisation des fichiers XML, ADO.NET (en mode connecté et en mode déconnecté) et d’Entity Framework Core. Enfin, les bases de programmation du WPF (Windows Presentation Foundation), de XAML, du binding et de MVVM terminent cet ouvrage.

À la fin de ce livre, le lecteur disposera de bases solides pour appréhender les puissantes bibliothèques du .NET et réaliser des programmes objet modulaires, fiables et extensibles.


Quizinclus dans
la version en ligne !

• Testez vos connaissances à l'issue de chaque chapitre
• Validez vos acquis

Téléchargements

• Des fichiers complémentaires (973 Ko)

Introduction à la POO

1. 1. Histoire de la POO
2. 2. Historique du C#

La conception orientée objet

1. 1. Approche procédurale et décomposition fonctionnelle
2. 2. La transition vers l'approche objet
3. 3. Les caractéristiques de la POO
   1. 3.1 L'objet, la classe et la référence
      1. 3.1.1 L'objet
      2. 3.1.2 La classe
      3. 3.1.3 La référence
   2. 3.2 L'encapsulation
   3. 3.3 L'héritage
   4. 3.4 Le polymorphisme
   5. 3.5 L'abstraction
4. 4. Le développement objet
   1. 4.1 Cahier des charges du logiciel
   2. 4.2 Présentation du cycle en V
   3. 4.3 Modélisation et représentation UML
      1. 4.3.1 Diagrammes de cas d'utilisation
      2. 4.3.2 Diagrammes de classes
      3. 4.3.3 Énumérations
      4. 4.3.4 Diagrammes de séquences
   4. 4.4 Rédaction du code et des tests unitaires
5. 5. Exercices corrigés
   1. 5.1 Hiérarchie de classes
   2. 5.2 Relations entre objets
   3. 5.3 Agrégation d’objets
   4. 5.4 Diagramme de cas d’utilisation
   5. 5.5 Diagramme de séquences

Introduction à .NET 6 et à VS

1. 1. Introduction
2. 2. Environnement d'exécution
3. 3. Le choix des langages
4. 4. Utiliser plusieurs langages
5. 5. Une librairie très complète
6. 6. Un outil de développement complet

Les types du C#

1. 1. "En C#, tout est typé !"
2. 2. "Tout le monde hérite de System.Object"
   1. 2.1 Les types Valeurs
   2. 2.2 Les types Références
   3. 2.3 Boxing/unboxing
   4. 2.4 Utilisation des méthodes de System.Object
      1. 2.4.1 Equals
      2. 2.4.2 GetHashCode
      3. 2.4.3 ToString
      4. 2.4.4 Finalize
      5. 2.4.5 Object.GetType et les opérateurs typeof et is
      6. 2.4.6 object.ReferenceEquals
      7. 2.4.7 Object.MemberwiseClone
   5. 2.5 Le type System.String et son alias string
3. 3. Exercice corrigé
   1. 3.1 Énoncé
   2. 3.2 Correction

Création d’objets

1. 1. Introduction
2. 2. Les espaces de noms
3. 3. Déclaration d'une classe
   1. 3.1 Accessibilité des membres
   2. 3.2 Attributs
      1. 3.2.1 Attributs constants
      2. 3.2.2 Attributs en lecture seule
   3. 3.3 Propriétés
   4. 3.4 Constructeur
      1. 3.4.1 Étapes de la construction d'un objet
      2. 3.4.2 Surcharge de constructeurs
      3. 3.4.3 Constructeurs avec valeurs de paramètres par défaut
      4. 3.4.4 Chaînage de constructeurs
      5. 3.4.5 Les constructeurs de type static
      6. 3.4.6 Les constructeurs de type private
      7. 3.4.7 Les initialiseurs d'objets
   5. 3.5 Destructeur
   6. 3.6 Autre utilisation de using
   7. 3.7 Le mot-clé this et ses vertus
   8. 3.8 Méthodes
      1. 3.8.1 Déclaration
      2. 3.8.2 Passage par valeur et passage par référence
   9. 3.9 Mécanisme des exceptions
      1. 3.9.1 Présentation
      2. 3.9.2 Principe de fonctionnement des exceptions
      3. 3.9.3 Prise en charge de plusieurs exceptions
      4. 3.9.4 try ... catch ... finally et using
   10. 3.10 Surcharge des méthodes
   11. 3.11 Exercice
       1. 3.11.1 Énoncé
       2. 3.11.2 Conseils
       3. 3.11.3 Correction
4. 4. Les interfaces
   1. 4.1 Introduction
   2. 4.2 Le contrat
   3. 4.3 Déclaration d'une interface
   4. 4.4 Implémentation
   5. 4.5 Visual Studio et les interfaces
   6. 4.6 Représentation UML d'une interface
   7. 4.7 Interfaces et polymorphisme
   8. 4.8 Exercice
      1. 4.8.1 Énoncé
      2. 4.8.2 Conseils
      3. 4.8.3 Correction
   9. 4.9 Les interfaces du .NET
5. 5. Association, composition et agrégation
   1. 5.1 Les tableaux
   2. 5.2 Les collections
      1. 5.2.1 List<> et LinkedList<>
      2. 5.2.2 Queue<T> et Stack<T>
      3. 5.2.3 Dictionary<TKey, TValue>
      4. 5.2.4 Les énumérateurs
      5. 5.2.5 La magie du yield
   3. 5.3 Exercice
      1. 5.3.1 Énoncé
      2. 5.3.2 Correction
6. 6. Les classes imbriquées
7. 7. Les structures
   1. 7.1 Déclaration d'une structure
   2. 7.2 Instanciation d'une structure
8. 8. Les classes partielles
9. 9. Les méthodes partielles
10. 10. Les indexeurs
11. 11. Surcharge d'opérateurs
12. 12. Fonctions locales
13. 13. Les objets "gourmands" en références faibles
14. 14. Les objets "dynamics"
15. 15. Les "Tuple" et "ValueTuple"
16. 16. Les records
    1. 16.1 Introduction
    2. 16.2 Déclaration complète
    3. 16.3 Déclaration simplifiée
    4. 16.4 Comparaison de records
    5. 16.5 Déconstruction d’un record
    6. 16.6 Mutation d’un record

Héritage et polymorphisme

1. 1. Comprendre l'héritage
2. 2. Codage de la classe de base et de son héritière
   1. 2.1 Interdire l'héritage
   2. 2.2 Définir les membres héritables
   3. 2.3 Codage de l'héritage
   4. 2.4 Exploitation d'une classe héritière
3. 3. Communication entre classe de base et classe héritière
   1. 3.1 Les constructeurs
   2. 3.2 Accès aux membres de base depuis l'héritier
   3. 3.3 Masquage ou substitution de membres hérités
      1. 3.3.1 Codage du masquage
      2. 3.3.2 Codage de la substitution
4. 4. Exercice
   1. 4.1 Énoncé
   2. 4.2 Corrigé
5. 5. Les classes abstraites
6. 6. Les méthodes d'extension
7. 7. Le polymorphisme
   1. 7.1 Comprendre le polymorphisme
   2. 7.2 Exploitation du polymorphisme
   3. 7.3 Les opérateurs is, as et ()

Communication entre objets

1. 1. L'événementiel : être à l'écoute
2. 2. Le pattern Observateur
3. 3. La solution C# : delegate et event
   1. 3.1 Utilisation du delegate dans le design pattern Observateur
   2. 3.2 Utilisation d'un event
   3. 3.3 Comment accompagner l'event de données
   4. 3.4 Les génériques en renfort pour encore simplifier
   5. 3.5 Les expressions lambda
   6. 3.6 Exemple d'utilisation d'event
4. 4. Appels synchrones, appels asynchrones
5. 5. Exercice
   1. 5.1 Énoncé
   2. 5.2 Conseils pour la réalisation
   3. 5.3 Correction
6. 6. Des messages entre les classes

Le multithreading

1. 1. Introduction
2. 2. Comprendre le multithreading
3. 3. Multithreading et .NET
4. 4. Implémentation en C#
   1. 4.1 Utilisation d'un BackgroundWorker
      1. 4.1.1 Communication du thread principal vers le thread secondaire
      2. 4.1.2 Abandon du thread secondaire depuis le thread principal
      3. 4.1.3 Communication du thread secondaire vers le thread principal
      4. 4.1.4 Communication en fin de traitement du thread secondaire
      5. 4.1.5 Exemple de code
   2. 4.2 Utilisation du pool de threads créé par .NET
   3. 4.3 Gestion "manuelle" avec Thread/ParameterizedThreadStart
5. 5. Synchronisation entre threads
   1. 5.1 Nécessité de la synchronisation
   2. 5.2 Le mot-clé lock
   3. 5.3 La classe Monitor
   4. 5.4 La classe Mutex
   5. 5.5 La classe Semaphore
6. 6. Communication entre threads
   1. 6.1 Join
   2. 6.2 Les synchronization events
   3. 6.3 Communication entre threads secondaires et IHM
   4. 6.4 Exercice
      1. 6.4.1 Énoncé
      2. 6.4.2 Correction
7. 7. La programmation asynchrone
   1. 7.1 Les « Task »
   2. 7.2 async et await
   3. 7.3 Le mot-clé async
   4. 7.4 Contenu d’une méthode async
   5. 7.5 Preuve à l’appui
   6. 7.6 Retours possibles d’une méthode async

P-Invoke

1. 1. Introduction
   1. 1.1 Rappel sur les DLL non managées
   2. 1.2 P-Invoke et son Marshal
2. 2. Le cas simple
   1. 2.1 Déclaration et appel
   2. 2.2 Réglage de Visual Studio pour la mise au point
3. 3. Appel avec paramètres et retour de fonction
4. 4. Traitement avec des chaînes de caractères
   1. 4.1 Encodage des caractères
   2. 4.2 Encodage des chaînes
   3. 4.3 Transmission des chaînes
5. 5. Échange de tableaux
   1. 5.1 Du C# au C/C++
   2. 5.2 Du C# au C/C++ puis retour au C#
6. 6. Partage de structures
   1. 6.1 Déclaration des structures
   2. 6.2 Utilisation des structures
7. 7. Les directives [In] et [Out]
8. 8. Réalisation d’un wrapper
   1. 8.1 Une région "NativeMethods"
   2. 8.2 Stockage des informations de la DLL native
   3. 8.3 Instanciation de DLL native
   4. 8.4 Méthodes d’utilisation de la DLL managée depuis le wrapper
   5. 8.5 Utilisation du wrapper
9. 9. Exercice
   1. 9.1 Énoncé
   2. 9.2 Correction

Les tests

1. 1. Introduction
2. 2. Environnement d’exécution des tests unitaires
3. 3. Le projet de tests unitaires
4. 4. La classe de tests
5. 5. Contenu d’une méthode de test
6. 6. Traitements de préparation et de nettoyage
7. 7. DynamicData et source de données
8. 8. Automatisation des tests à la compilation
9. 9. Automatisation des tests en dehors de Visual Studio
10. 10. CodedUI
11. 11. Exercice
    1. 11.1 Énoncé
    2. 11.2 Correction
12. 12. Simulation par stub ou par shim

Traçage et instrumentation des applications

1. 1. Présentation
2. 2. Des objets de mise au point
   1. 2.1 System.Diagnostics.Debug
   2. 2.2 System.Diagnostics.Trace
   3. 2.3 System.Diagnostics.TraceSource
3. 3. Principe de fonctionnement des écouteurs
4. 4. Comportement dynamique
5. 5. Mesurer le temps passé
6. 6. Exercice
   1. 6.1 Énoncé
   2. 6.2 Correction

La réflexion

1. 1. Introduction
2. 2. Mais pour quoi faire ?
3. 3. Introspection d'une classe C#
   1. 3.1 Introspection "manuelle"
   2. 3.2 Introspection "logicielle"
      1. 3.2.1 Découverte et instanciation
      2. 3.2.2 Découverte et utilisation des propriétés
      3. 3.2.3 Découverte et utilisation des méthodes
   3. 3.3 Exercice
      1. 3.3.1 Énoncé
      2. 3.3.2 Quelques conseils
      3. 3.3.3 Correction
4. 4. Chargement dynamique d’un objet implémentant une interface
   1. 4.1 Création d’une interface "plug-in"
   2. 4.2 Écriture d’un plug-in
   3. 4.3 L’application supportant les plug-ins
   4. 4.4 Exercice
      1. 4.4.1 Énoncé
      2. 4.4.2 Correction
5. 5. Décompilation et obfuscation
6. 6. Conclusion

Gestion des données

1. 1. Introduction
2. 2. LINQ
   1. 2.1 Qu’est-ce que c’est ?
   2. 2.2 Les deux syntaxes LINQ
      1. 2.2.1 La syntaxe "développeur SQL"
      2. 2.2.2 La syntaxe "développeur C#"
   3. 2.3 Requêtes et filtres
   4. 2.4 Quelques calculs
   5. 2.5 Regroupement des résultats
   6. 2.6 Les jointures
   7. 2.7 Exercice
      1. 2.7.1 Énoncé
      2. 2.7.2 Solution
3. 3. Persistance des données en XML
   1. 3.1 Rappels sur le XML
   2. 3.2 XML et .NET
      1. 3.2.1 Sérialisation/désérialisation d’un modèle de données
      2. 3.2.2 Les décorations de sérialisation XML
      3. 3.2.3 XmlSerializer : écrire et lire
   3. 3.3 XSD.EXE, un outil de conversion
   4. 3.4 Exercice
      1. 3.4.1 Énoncé
      2. 3.4.2 Correction
   5. 3.5 LINQ to XML
      1. 3.5.1 Lecture
      2. 3.5.2 Écriture
      3. 3.5.3 Interrogations
   6. 3.6 Exercice
      1. 3.6.1 Énoncé
      2. 3.6.2 Correction
4. 4. Persistance dans des bases de données avec ADO.NET
   1. 4.1 Présentation
   2. 4.2 Les termes utilisés
   3. 4.3 Les modules ADO.NET
   4. 4.4 Notre environnement d’apprentissage
   5. 4.5 ADO en mode connecté
      1. 4.5.1 Les fournisseurs de données en .NET
      2. 4.5.2 Se connecter avec DbConnection
      3. 4.5.3 Envoyer des requêtes avec DbCommand
      4. 4.5.4 Lire des enregistrements avec DbDataReader
   6. 4.6 Exercice
      1. 4.6.1 Énoncé
      2. 4.6.2 Correction
   7. 4.7 ADO en mode déconnecté
      1. 4.7.1 La classe DataSet
      2. 4.7.2 Le DataSet typé
      3. 4.7.3 Persistance du DataSet en XML
      4. 4.7.4 LINQ to DataSet
      5. 4.7.5 Intégrité référentielle
   8. 4.8 DbAdapter : jonction des deux modes
      1. 4.8.1 Lecture de la source
      2. 4.8.2 Mise à jour de la source
5. 5. Entity Framework
   1. 5.1 Présentation de l’Entity Data Model
   2. 5.2 Création d’un EDM depuis une base de données
   3. 5.3 DbContext
   4. 5.4 LINQ to Entities
   5. 5.5 Mise à jour de la source
   6. 5.6 Création d’un EDM depuis un modèle
   7. 5.7 Exercice
      1. 5.7.1 Présentation du binding
      2. 5.7.2 Énoncé
      3. 5.7.3 Correction
6. 6. Conclusion

WPF MVVM et le toolkit Microsoft

1. 1. Présentation
2. 2. Historique des API
3. 3. C# et XAML Développeur et Graphiste
4. 4. Balises et Attributs pour Objets et Propriétés
5. 5. Utilisation basique de WPF
6. 6. Utilisation des layout
7. 7. Récupération des informations SANS le binding
8. 8. Introduction au binding
   1. 8.1 Le DataContext
   2. 8.2 L'interface INotifyPropertyChange
   3. 8.3 Les convertisseurs
   4. 8.4 Exercice
   5. 8.5 Binding de commandes
9. 9. Le modèle de conception MVVM
   1. 9.1 Objectifs
   2. 9.2 Les dépendances
   3. 9.3 Mise en application
10. 10. Présentation de MVVM Toolkit
    1. 10.1 La classe Observable
    2. 10.2 La classe ObservableValidator
    3. 10.3 Messenger
    4. 10.4 L'injection de dépendances
13. Index