Ce support sur Blazor, technologie de la famille ASP.NET, s’adresse aux développeurs C# désireux de développer des applications web dynamiques et interactives, sans avoir à utiliser le langage JavaScript. Pour apprécier au mieux le contenu de ce livre, la connaissance du langage C# est un prérequis, mais connaître ASP.NET n’est pas obligatoire. Des notions de base sont toutefois un plus pour rapidement entrer dans le sujet.

Grâce à un exemple mené en fil rouge qui vous fera réaliser une mini application de gestion de personnel, l’auteur vous mène des bases de Blazor jusqu’à la découverte de notions plus avancées.

Ainsi, après une introduction sur le fonctionnement et l’évolution des applications web, l’auteur explique comment Blazor s’est fait une place dans l’écosystème .NET et expose les différences entre les versions Blazor Server et WebAssembly. Vous êtes ensuite invité à préparer l’environnement de développement et à créer une première application.

Le fonctionnement du framework avec le concept de composant est ensuite détaillé et la logique modulaire de Blazor est explorée pour vous permettre de créer des applications composées de blocs performants réutilisables. Puis, vous appréhendez la conception d’applications web plus complexes mettant en œuvre l’interopérabilité avec JavaScript, une réflexion plus poussée sur les composants ou la communication avec une API. L’auteur étudie ensuite la gestion des données en Front End à l’aide du pattern Redux ainsi que le fonctionnement de la librairie Fluxor simplifiant l’intégration des données.

Pour finir, vous découvrez la transformation de l’application en WebAssembly, avec une variante d’exploitation en Progressive Web App, ainsi que la gestion des données en fonctionnement déconnecté.

Des éléments complémentaires sont en téléchargement sur le site www.editions-eni.fr

Téléchargements

• Des fichiers complémentaires (2 609 Ko)

Introduction

1. 1. Historique de l'évolution du Web
2. 2. Le fonctionnement d'un site internet
   1. 2.1 Les langages côté serveur
   2. 2.2 Les langages côté client

Première application

1. 1. Historique des applications .NET
2. 2. Installation des outils
   1. 2.1 Installation du SDK
   2. 2.2 Installation de Visual Studio 2019 sous Windows
   3. 2.3 Installation de Visual Studio Code sous macOS/Linux
3. 3. Les versions de Blazor
   1. 3.1 Blazor Server
   2. 3.2 Blazor Client
   3. 3.3 Le choix de la version
   4. 3.4 Choix d'architecture
4. 4. Créer une première application Blazor
   1. 4.1 Analyse des fichiers communs créés par le CLI
   2. 4.2 Analyse des fichiers Blazor générés par le CLI
   3. 4.3 Analyse d'un composant Blazor
   4. 4.4 Exécution de l'application
      1. 4.4.1 Exécuter une application Blazor avec Visual Studio 2019
      2. 4.4.2 Exécuter une application Blazor avec Visual Studio Code
5. 5. Exercice
   1. 5.1 Énoncé
   2. 5.2 Corrigé

Les composants en détail

1. 1. Analyse d'un composant
   1. 1.1 La structure d'un composant
   2. 1.2 Cycle de vie d'un composant
      1. 1.2.1 OnInitialized
      2. 1.2.2 OnParameterSet
      3. 1.2.3 OnAfterRender
      4. 1.2.4 ShouldRender
      5. 1.2.5 SetParametersAsync
      6. 1.2.6 Destruction
      7. 1.2.7 BuildRenderTree
      8. 1.2.8 Nouveautés .NET 5
   3. 1.3 Interactions d'un composant
      1. 1.3.1 Passage de paramètre par route
      2. 1.3.2 Passage d'objet par injection de dépendances
2. 2. Formulaires et interactions utilisateur
   1. 2.1 Bindings
      1. 2.1.1 One-way data binding
      2. 2.1.2 Two-way data binding
   2. 2.2 Validation
3. 3. Exercice
   1. 3.1 Énoncé
   2. 3.2 Corrigé
      1. 3.2.1 Gestion du personnel
      2. 3.2.2 Édition d'un employé

Fonctionnalités avancées

1. 1. JavaScript et CSS
   1. 1.1 Interopérabilité avec JavaScript
      1. 1.1.1 Invocation JavaScript depuis C#
      2. 1.1.2 Invocation C# depuis JavaScript
   2. 1.2 Nouveautés .NET 5
      1. 1.2.1 Isolation CSS
      2. 1.2.2 Isolation JavaScript
2. 2. Composant imbriqué
   1. 2.1 Création d'un loader
   2. 2.2 Ajout d'un message d'attente personnalisé
   3. 2.3 Réaliser des propriétés bindables
3. 3. Communication HTTP
   1. 3.1 Création d'un back-end
   2. 3.2 Appel HTTP de l'API
      1. 3.2.1 Stockage et récupération de l'URL
      2. 3.2.2 Création d’un service de contact de l'API
      3. 3.2.3 Configuration de l'injection de dépendances
      4. 3.2.4 Résilience HTTP
4. 4. Interactions avancées entre composants
   1. 4.1 Empêcher la validation d'un formulaire
      1. 4.1.1 Cascade de paramètres
      2. 4.1.2 Composant de validation
   2. 4.2 Navigation entre composants
5. 5. Exercice
   1. 5.1 Création du composant pour l'adresse
   2. 5.2 Intégration OpenStreetMap
   3. 5.3 Loader réutilisable
   4. 5.4 Ajout d'une API et appels HTTP
   5. 5.5 Ajout d'employé et utilisation de MatBlazor

Magasin de données

1. 1. Présentation du pattern Flux/Redux
   1. 1.1 Concepts essentiels
      1. 1.1.1 Le store
      2. 1.1.2 Actions
      3. 1.1.3 Reducers
   2. 1.2 Fonctionnement du pattern
2. 2. Implémentation du store
   1. 2.1 Création du store
      1. 2.1.1 Classe contenant l'état de l'application
      2. 2.1.2 Classes d'action
      3. 2.1.3 Méthodes de reducers
   2. 2.2 Utilisation manuelle des éléments
      1. 2.2.1 Création du service de store
      2. 2.2.2 Utilisation du store
   3. 2.3 Utilisation de la librairie Fluxor
      1. 2.3.1 Installation et configuration
      2. 2.3.2 Modification des objets pour une utilisation de Fluxor
      3. 2.3.3 Effects
3. 3. Débogage du store
   1. 3.1 Installation de l'extension Redux DevTools
   2. 3.2 Utilisation de l'extension Redux DevTools
4. 4. Nouveautés .NET 5
5. 5. Exercice
   1. 5.1 Énoncé
   2. 5.2 Corrigé
      1. 5.2.1 Architecture du projet
      2. 5.2.2 Implémentation des classes du store
      3. 5.2.3 Modification du composant pour utiliser le store

Blazor Client

1. 1. Présentation et concepts clés
2. 2. Mise en pratique
   1. 2.1 Première application Blazor Client
   2. 2.2 Architecture d'un projet Blazor Client
      1. 2.2.1 Modification du projet Server pour utiliser la librairie
      2. 2.2.2 Mise en commun des services
      3. 2.2.3 Modification de l'application Blazor Client
3. 3. Les spécificités de Blazor Client
   1. 3.1 Fonctionnement hors ligne
      1. 3.1.1 Chargement du script
      2. 3.1.2 Récupération des données depuis l'API
      3. 3.1.3 Empilement des ordres à destination de l'API
   2. 3.2 Progressive web app
      1. 3.2.1 Transformation en PWA
      2. 3.2.2 Publication d'une PWA
      3. 3.2.3 Exploitation d'une PWA en image Docker
4. 4. Exercice
   1. 4.1 Énoncé
   2. 4.2 Corrigé
      1. 4.2.1 Création de la librairie de composants
      2. 4.2.2 Modification de l'application Blazor Client
      3. 4.2.3 Mode hors ligne
   3. Index