Outils pour ASP.NET Core Blazor

Article
08/12/2024

Remarque

Ceci n’est pas la dernière version de cet article. Pour la version actuelle, consultez la version .NET 8 de cet article.

Avertissement

Cette version d’ASP.NET Core n’est plus prise en charge. Pour plus d’informations, consultez la Stratégie de prise en charge de .NET et .NET Core. Pour la version actuelle, consultez la version .NET 8 de cet article.

Important

Ces informations portent sur la préversion du produit, qui est susceptible d’être en grande partie modifié avant sa commercialisation. Microsoft n’offre aucune garantie, expresse ou implicite, concernant les informations fournies ici.

Pour la version actuelle, consultez la version .NET 8 de cet article.

Cet article décrit les outils permettant de créer des applications Blazor à l’aide de différents outils :

Visual Studio (VS) : l’environnement de développement intégré (IDE) le plus complet pour les développeurs .NET sur Windows. Comprend un ensemble d’outils et de fonctionnalités permettant d’élever et d’améliorer chaque étape du développement de logiciels.
Visual Studio Code (VS Code) est un éditeur de code open source multiplateforme qui peut être utilisé pour développer des applications Blazor.
Interface CLI .NET : l'interface de ligne de commande (CLI) .NET est une chaîne d'outils multiplateforme permettant de développer, de créer, d'exécuter et de publier des applications .NET. L’interface de ligne de commande .NET est incluse dans le Kit de développement logiciel (SDK) .NET et s’exécute sur n’importe quelle plateforme prise en charge par le SDK.

Sélectionnez le tableau croisé dynamique de cet article qui correspond à votre choix d’outils.

Pour créer une application Blazor avec Visual Studio, suivez les instructions suivantes :

Installer la dernière version de Visual Studio avec la charge de travail Développement web et ASP.NET.
Créez un projet à l’aide de l’un des modèles Blazor disponibles :
- Blazor Web App : crée une application web Blazor qui prend en charge le rendu interactif côté serveur (SSR interactif) et le rendu côté client (CSR). Le modèle Blazor Web App est recommandé pour bien démarrer avec Blazor et découvrir les fonctionnalités Blazor côté serveur et côté client.
- Application Blazor WebAssembly autonome : crée une application web client autonome qui peut être déployée en tant que site statique.

Cliquez sur Suivant.

Installer la dernière version de Visual Studio avec la charge de travail Développement web et ASP.NET.
Créez un projet :
- Pour une expérience Blazor Server, choisissez le modèle d’applicationBlazor Server, qui inclut le code de démonstration et Bootstrap, ou le modèle d’application videBlazor Server sans code de démonstration et démarrage. Cliquez sur Suivant.
- Pour une expérience Blazor WebAssembly autonome, choisissez le modèle Application Blazor WebAssembly, qui inclut le code de démonstration et de démarrage, ou le modèle Application Blazor WebAssembly vide sans code de démonstration ni démarrage. Cliquez sur Suivant.

Installer la dernière version de Visual Studio avec la charge de travail Développement web et ASP.NET.
Créez un projet :
- Pour une expérience Blazor Server, choisissez le modèle d’applicationBlazor Server. Sélectionnez Suivant.
- Pour une expérience Blazor WebAssembly, choisissez le modèle d’applicationBlazor WebAssembly. Sélectionnez Suivant.

Indiquez un nom de projet et vérifiez que l’emplacement est correct.
Pour plus d’informations sur les options de la boîte de dialogue Information supplémentaires, consultez la section Blazor Modèles de projet et options de modèle..

Remarque

Le modèle de projet Blazor WebAssembly hébergé n’est pas disponible dans ASP.NET Core 8.0 ou version ultérieure. Pour créer une application Blazor WebAssembly hébergée, une option Framework antérieure à .NET 8.0 doit être cochée avec la case à cocher ASP.NET Core hébergée.

Pour une application hébergéeBlazor WebAssembly, cochez la case ASP.NET Core hébergée dans la boîte de dialogue Informations supplémentaires.

Sélectionnez Créer.

Visual Studio Code est un environnement de développement intégré (IDE) multiplateforme open source qui peut être utilisé pour développer des applications Blazor.

Installez la dernière version de Visual Studio Code pour votre plateforme.

Installez le kit de développement C# pour Visual Studio Code. Pour plus d’informations, consultez Déboguer des applications Blazor ASP.NET Core.

Si vous commencez à utiliser VS Code, consultez la Documentation sur VS Code. Si vous débutez avec le kit de développement logiciel (SDK) .NET, consultez la section Qu’est-ce que le kit de développement logiciel (SDK) .NET ? et les articles associés dans la documentation du kit de développement logiciel (SDK) .NET.

Créez un projet :

Ouvrez Visual Studio Code.
Accédez à l’affichage Explorateur et sélectionnez le bouton Créer un projet .NET. Vous pouvez également afficher la Palette de commandes à l’aide des touches Ctrl+Maj+P, puis taper « .NET », puis rechercher et sélectionner la commande .NET : Nouveau projet.
Sélectionnez le modèle de projet Blazor dans la liste.
Dans la boîte de dialogue Emplacement du projet, créez ou sélectionnez un dossier pour le projet.
Dans la Palette de commandes, indiquez un nom pour le projet ou acceptez le nom par défaut.
Sélectionnez Créer un projet pour créer le projet ou ajustez les options du projet en sélectionnant Afficher toutes les options de modèle. Pour plus d’informations sur les modèles et les options, consultez la section Blazor Modèles de projet et options de modèle.
Appuyez sur la touche F5 de votre clavier pour exécuter l’application avec le débogueur ou sur les touches Ctrl+F5 pour exécuter l’application sans le débogueur.

La Palette de commandes vous demande de sélectionner un débogueur. Sélectionnez C# dans la liste.

Ensuite, sélectionnez la configuration de lancement https.
Pour arrêter l’application, appuyez sur les touches Maj+F5 de votre clavier.

Les instructions Visual Studio Code (VS Code) relatives au développement ASP.NET Core dans certaines parties de la documentation Blazor utilisent l’interface de ligne de commande .NET, qui fait partie du kit de développement logiciel (SDK) .NET. Les commandes de l’interface de ligne de commande .NET sont émises dans le Terminal intégré de VS Code, qui est défini par défaut sur un interpréteur de commandes PowerShell. Le Terminal est ouvert en sélectionnant Nouveau terminal dans le menu Terminal dans la barre de menus.

Pour plus d’informations sur la configuration et l’utilisation de Visual Studio Code, consultez la documentation de Visual Studio Code.

Lancement hébergé Blazor WebAssembly et configuration des tâches

Pour les Blazor WebAssemblysolutions hébergées, ajoutez (ou déplacez) le dossier .vscode avec les fichiers launch.json et tasks.json dans le dossier parent de la solution, qui est le dossier qui contient les dossiers de projet standard : Client, Server et Shared. Mettez à jour ou vérifiez que la configuration dans les fichiers launch.json et tasks.json exécute une application Blazor WebAssembly hébergée à partir du projet Server.

Examinez le fichier Properties/launchSettings.json et déterminez l’URL de l’application à partir de la propriété applicationUrl. Selon la version de l’infrastructure, le protocole d’URL est sécurisé (HTTPS) https://localhost:{PORT} ou non sécurisé (HTTP) http://localhost:{PORT}, où l’espace réservé {PORT} est un port affecté. Notez l’URL à utiliser dans le fichier launch.json .

Dans la configuration de lancement du fichier .vscode/launch.json :

Définissez le répertoire de travail actuel (cwd) sur le dossier du projet Server.
Indiquez l’URL de l’application avec la propriété url. Utilisez la valeur enregistrée précédemment à partir du fichier Properties/launchSettings.json.

"cwd": "${workspaceFolder}/{SERVER APP FOLDER}",
"url": "{URL}"

Dans la configuration précédente :

L’espace réservé {SERVER APP FOLDER} est le dossier du projet Server, généralement Server.
L’espace réservé {URL} est l’URL de l’application, qui est spécifiée dans le fichier Properties/launchSettings.json de l’application dans la propriété applicationUrl.

Si Google Chrome est préféré à Microsoft Edge, mettez à jour ou ajoutez une propriété supplémentaire de "browser": "chrome" à la configuration.

L’exemple suivant .vscode/launch.json fichier :

Définit le répertoire de travail actuel sur le dossier Server.
Définit l’URL de l’application sur http://localhost:7268.
Modifie le navigateur par défaut de Microsoft Edge vers Google Chrome.

"cwd": "${workspaceFolder}/Server",
"url": "http://localhost:7268",
"browser": "chrome"

Fichier .vscode/launch.json complet :

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "blazorwasm",
      "name": "Launch and Debug Blazor WebAssembly Application",
      "request": "launch",
      "cwd": "${workspaceFolder}/Server",
      "url": "http://localhost:7268",
      "browser": "chrome"
    }
  ]
}

Dans .vscode/tasks.json, ajoutez un argument build qui spécifie le chemin d’accès au fichier projet de l’application Server :

"${workspaceFolder}/{SERVER APP FOLDER}/{PROJECT NAME}.csproj",

Dans l’argument précédent :

L’espace réservé {SERVER APP FOLDER} est le dossier du projet Server, généralement Server.
L’espace réservé {PROJECT NAME} est le nom de l’application, généralement basé sur le nom de la solution suivi de .Server dans une application générée à partir du modèle de projet Blazor WebAssembly.

Un exemple de fichier .vscode/tasks.json avec un projet Server nommé BlazorHosted dans le dossier Server de la solution :

{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "build",
      "command": "dotnet",
      "type": "process",
        "args": [
          "build",
          "${workspaceFolder}/Server/BlazorHosted.Server.csproj",
          "/property:GenerateFullPaths=true",
          "/consoleloggerparameters:NoSummary",
        ],
        "group": "build",
        "presentation": {
          "reveal": "silent"
        },
        "problemMatcher": "$msCompile"
    }
  ]
}

Remarque

Seul le débogage de navigateur est pris en charge pour l’instant.

Vous ne pouvez pas reconstruire automatiquement l’application back-end Server d’une solution hébergée Blazor WebAssembly pendant le débogage, par exemple en exécutant l’application avec dotnet watch run.

.vscode/launch.json (configuration launch) :

...
"cwd": "${workspaceFolder}/{SERVER APP FOLDER}",
...

Dans la configuration précédente du répertoire de travail actuel (cwd), l’espace réservé {SERVER APP FOLDER} est le dossier du projet Server, généralement «Server».

Si Microsoft Edge est utilisé et que Google Chrome n’est pas installé sur le système, ajoutez une propriété supplémentaire de "browser": "edge" à la configuration.

Exemple pour un dossier de projet de Server et qui génère Microsoft Edge en tant que navigateur pour le débogage s’exécute au lieu du navigateur par défaut Google Chrome :

...
"cwd": "${workspaceFolder}/Server",
"browser": "edge"
...

.vscode/tasks.json (Arguments de la commande dotnet) :

...
"${workspaceFolder}/{SERVER APP FOLDER}/{PROJECT NAME}.csproj",
...

Dans l’argument précédent :

L’espace réservé {SERVER APP FOLDER} est le dossier du projet Server, généralement «Server».
L’espace réservé {PROJECT NAME} est le nom de l’application, généralement basé sur le nom de la solution suivi de «.Server» dans une application générée à partir du modèle de projet Blazor.

L’exemple suivant du tutoriel pour l’utilisation de SignalR avec une application Blazor WebAssembly utilise un nom de dossier de projet de Server et un nom de projet deBlazorWebAssemblySignalRApp.Server :

...
"args": [
  "build",
    "${workspaceFolder}/Server/BlazorWebAssemblySignalRApp.Server.csproj",
    ...
],
...

Le Kit de développement logiciel (SDK) .NET est un ensemble de bibliothèques et d’outils que les développeurs utilisent pour créer des applications et des bibliothèques .NET.

Installez le Kit de développement logiciel (SDK) pour .NET. Les commandes sont émises dans un interpréteur de commandes à l’aide de l’interface de ligne de commande.NET.

Si vous avez déjà installé un ou plusieurs kits de développement logiciel .NET et souhaitez afficher votre version active, exécutez la commande suivante dans un interpréteur de commandes :

dotnet --version

Si vous débutez avec le kit de développement logiciel (SDK) .NET, consultez la section Qu’est-ce que le kit de développement logiciel (SDK) .NET ? et les articles associés dans la documentation du kit de développement logiciel (SDK) .NET.

Créez un projet :

Accédez au répertoire à l’aide de la commande cd vers l’emplacement dans lequel vous souhaitez créer le dossier du projet (par exemple cd c:/users/Bernie_Kopell/Documents).
Pour une expérience Blazor Web App avec le rendu interactif côté serveur par défaut (SSR interactif), exécutez la commande suivante :
```
dotnet new blazor -o BlazorApp
```
Pour une expérience Blazor WebAssembly autonome, exécutez la commande suivante dans un interpréteur de commandes qui utilise le modèle blazorwasm :
```
dotnet new blazorwasm -o BlazorApp
```

Créez un projet :

Accédez au répertoire à l’aide de la commande cd vers l’emplacement dans lequel vous souhaitez créer le dossier du projet (par exemple cd c:/users/Bernie_Kopell/Documents).
Pour une expérience Blazor Server avec le code de démonstration et Bootstrap, exécutez la commande suivante :
```
dotnet new blazorserver -o BlazorApp
```
Pour une expérience Blazor WebAssembly autonome avec le code de démonstration et de démarrage, exécutez la commande suivante :
```
dotnet new blazorwasm -o BlazorApp
```
Pour une expérience Blazor WebAssembly hébergée avec le code de démonstration et Bootstrap, ajoutez l’option hébergée (-ho/--hosted) à la commande :
```
dotnet new blazorwasm -o BlazorApp -ho
```
Remarque

Le modèle de projet Blazor WebAssembly hébergé n’est pas disponible dans ASP.NET Core 8.0 ou version ultérieure. Pour créer une application Blazor WebAssembly hébergée à l’aide d’un kit de développement logiciel (SDK) .NET 8.0 ou version ultérieure, passez l’option -f|--framework avec une version cible de .NET Framework 7.0 (net7.0) :
```
dotnet new blazorwasm -o BlazorApp -ho -f net7.0
```

Créez un projet :

Accédez au répertoire à l’aide de la commande cd vers l’emplacement dans lequel vous souhaitez créer le dossier du projet (par exemple cd c:/users/Bernie_Kopell/Documents).
Pour une expérience Blazor WebAssembly, exécutez la commande suivante :
```
dotnet new blazorwasm -o BlazorApp
```
Pour une expérience hébergée Blazor WebAssembly, ajoutez l’option hébergée (-ho ou --hosted) à la commande :
```
dotnet new blazorwasm -o BlazorApp -ho
```
Remarque

Le modèle de projet Blazor WebAssembly hébergé n’est pas disponible dans ASP.NET Core 8.0 ou version ultérieure. Pour créer une application Blazor WebAssembly hébergée à l’aide d’un SDK .NET 8.0 ou version ultérieure, passez l’option -f|--framework avec le moniker de framework cible (par exemple, net6.0) :
```
dotnet new blazorwasm -o BlazorApp -ho -f net6.0
```
Pour une expérience Blazor Server, exécutez la commande suivante :
```
dotnet new blazorserver -o BlazorApp
```

Pour plus d’informations sur les modèles et les options, consultez la section Blazor Modèles de projet et options de modèle.

Exécuter l’application

Important

Lors de l’exécution d’une Blazor Web App, exécutez l’application à partir du projet serveur de la solution, qui est le projet portant un nom qui ne se termine pas par .Client.

Important

Quand il s’agit d’exécuter une application Blazor WebAssembly hébergée, faites-le depuis le projet Server de la solution.

Appuyez sur les touches Ctrl+F5 de votre clavier pour exécuter l’application sans le débogueur.

Visual Studio affiche la boîte de dialogue suivante lorsqu’un projet n’est pas configuré pour utiliser SSL :

Boîte de dialogue Approuver un certificat auto-signé

Sélectionnez Oui si vous approuvez le certificat SSL ASP.NET Core.

La boîte de dialogue suivante s’affiche :

Boîte de dialogue Avertissement de sécurité

Sélectionnez Oui pour reconnaître le risque et installer le certificat.

Visual Studio :

Compile et exécute l’application.
Lance le navigateur par défaut sur https://localhost:{PORT}, qui affiche l’interface utilisateur de l’application. L’espace réservé {PORT} est le port aléatoire attribué lors de la création de l’application. Si vous devez modifier le port en raison d’un conflit de port local, modifiez le port dans le fichier Properties/launchSettings.json du projet.

Dans VS Code, appuyez sur les touches Ctrl+F5 (Windows) ou ⌘+F5 (macOS) pour exécuter l’application sans débogage.

À l’invite Sélectionner le débogueur dans la Palette de commandes en haut de l’interface utilisateur de VS Code, sélectionnez C#. À l’invite suivante, sélectionnez le profil HTTPS ([https]).

Le navigateur par défaut est lancé sur https://localhost:{PORT}, qui affiche l’interface utilisateur de l’application. L’espace réservé {PORT} est le port aléatoire attribué lors de la création de l’application. Si vous devez modifier le port en raison d’un conflit de port local, modifiez le port dans le fichier Properties/launchSettings.json du projet.

Dans un interpréteur de commandes ouvert au dossier racine du projet, exécutez la commande dotnet watch pour compiler et démarrer l’application :

dotnet watch

Lorsqu’une application créée à partir du modèle de projet Blazor Web App est exécutée avec l’interface de ligne de commande .NET, l’application s’exécute sur un point de terminaison HTTP (non sécurisé), car le premier profil trouvé dans le fichier de paramètres de lancement de l’application (Properties/launchSettings.json) est le profil HTTP (non sécurisé), qui est nommé http. Le profil HTTP a été placé en première position pour faciliter la transition de l’adoption de la sécurité SSL/HTTPS pour les utilisateurs qui ne sont pas sous Windows.

Une approche pour l’exécution de l’application avec SSL/HTTPS consiste à passer l’option -lp|--launch-profile avec le nom du profil https à la commande dotnet watch :

dotnet watch -lp https

Une autre approche consiste à déplacer le profil https au-dessus du profil http dans le fichier Properties/launchSettings.json et à enregistrer la modification. Après avoir modifié l’ordre du profil dans le fichier, la commande dotnet watch utilise toujours le profil par défaut https.

Arrêter l’application

Vous pouvez arrêter l’application de deux façons différentes :

Fermez la fenêtre du navigateur.
Dans Visual Studio, soit :
- Utilisez le bouton Arrêter dans la barre de menus de Visual Studio :
- Appuyez sur les touches Maj+F5 de votre clavier.

Arrêtez l’application de la façon suivante :

Fermez la fenêtre du navigateur.
Dans VS Code, soit :
- Dans le menu Exécuter, sélectionnez Arrêter le débogage.
- Appuyez sur les touches Maj+F5 de votre clavier.

Arrêtez l’application de la façon suivante :

Fermez la fenêtre du navigateur.
Dans l’interpréteur de commandes, appuyez sur les touches Ctrl+C (Windows) ou ⌘+C (macOS).

Fichier de solution Visual Studio (`.sln`)

Une solution est un conteneur pour organiser un ou plusieurs projets de code associés. Les fichiers solution utilisent un format unique et ne sont pas destinés à être modifiés directement.

Visual Studio et Visual Studio Code (VS Code) utilisent un fichier solution (.sln) pour stocker les paramètres d’une solution. L’interface de ligne de commande .NET n’organise pas les projets à l’aide d’un fichier solution, mais elle peut créer des fichiers de solution et répertorier/modifier les projets dans les fichiers de solution via la dotnet sln commande. D’autres commandes CLI .NET utilisent le chemin d’accès du fichier solution pour diverses commandes de publication, de test et d’empaquetage.

Tout au long de la documentation Blazor, solution est utilisée pour décrire les applications créées à partir du modèle de projet Blazor WebAssembly avec l’option ASP.NET Core Hosted activée ou à partir d’un modèle de projet Blazor Hybrid. Les applications produites à partir de ces modèles de projet incluent un fichier de solution (.sln). Pour les applications hébergées Blazor WebAssembly où le développeur n’utilise pas Visual Studio, le fichier de solution peut être ignoré ou supprimé s’il n’est pas utilisé avec des commandes CLI .NET.

Pour plus d’informations, consultez les ressources suivantes :

modèles de projet et options de modèle Blazor

L’infrastructure Blazor fournit des modèles de projet pour la création d’applications. Les modèles sont utilisés pour créer de nouveaux projets et solutions Blazor, quel que soit l’outil que vous sélectionnez pour le développement Blazor (Visual Studio, Visual Studio Code ou l’interface de ligne de commande (CLI).NET) :

Modèle de projet Blazor Web App : blazor
Modèle de projet d’application Blazor WebAssembly autonome : blazorwasm

Modèles de projet Blazor Server : blazorserver, blazorserver-empty
Blazor WebAssemblymodèles de projet : blazorwasm, blazorwasm-empty

Blazor Server modèle de projet : blazorserver
Modèle de projet Blazor WebAssembly : blazorwasm

Pour plus d’informations sur les modèles de projet Blazor, consultez ASP.NET structure de projet principale Blazor.

Les termes et concepts de rendu utilisés dans les sous-sections suivantes sont présentés dans les sections suivantes de l’article de vue d’ensemble des Principes de base :

Des instructions détaillées sur les modes de rendu sont fournies par l’article sur les modes de rendu Blazor ASP.NET Core.

Mode de rendu interactif

Le rendu interactif côté serveur (SSR interactif) est activé avec l’option Serveur.
Pour activer uniquement l’interactivité avec le rendu côté client (CSR), utilisez l’option WebAssembly.
Pour activer les deux modes de rendu interactif et la possibilité de basculer automatiquement entre eux au moment de l’exécution, utilisez l’option de mode de rendu (automatique) Automatique (Serveur et WebAssembly).
Si l’interactivité est définie sur None, l’application générée n’a aucune interactivité. L’application est configurée uniquement pour le rendu statique côté serveur.

Le mode de rendu interactif Automatique utilise initialement le SSR interactif tandis que l’ensemble d’applications .NET et le runtime sont téléchargés dans le navigateur. Une fois le runtime WebAssembly .NET activé, le mode de rendu bascule vers le rendu WebAssembly interactif.

Le modèle Blazor Web App active le SSR statique et le SSR interactif en utilisant un seul projet. Si vous activez également le CSR, le projet inclut un projet client supplémentaire (.Client) pour vos composants basés sur WebAssembly. La sortie générée du projet client est téléchargée dans le navigateur et exécutée sur le client. Tous les composants utilisant les modes de rendu WebAssembly ou Automatique doivent être générés à partir du projet client.

Important

Lors de l’utilisation d’une Blazor Web App, la plupart des composants de l’exemple de documentation Blazornécessitent une interactivité pour fonctionner et démontrer les concepts couverts par les articles. Lorsque vous testez un composant d’exemple fourni par un article, assurez-vous que l’application adopte une interactivité globale ou que le composant adopte un mode de rendu interactif.

Emplacement d’interactivité

Options d’emplacement d’interactivité :

Par page/composant : la valeur par défaut configure l’interactivité par page ou par composant.
Global : cette option configure l’interactivité globalement pour l’ensemble de l’application.

L’emplacement d’interactivité ne peut être défini que si le mode d’affichage interactif n’est pas None et que l’authentification n’est pas activée.

Exemples de pages

Pour inclure des pages d’exemples et une disposition basée sur le style Bootstrap, utilisez l’option Inclure les pages d’exemples. Désactivez cette option pour des projets sans exemples de pages et de style Bootstrap.

Conseils supplémentaires sur les options de modèle

Modes de rendu ASP.NET Core Blazor
L’article Modèles .NET par défaut pour dotnet new de la documentation .NET Core :
- blazor
- blazorwasm
Passage de l’option d’aide (-h ou --help) à la commande CLI dotnet new dans un interpréteur de commandes :
- dotnet new blazor -h
- dotnet new blazorwasm -h

Pour plus d’informations sur les options de modèle, consultez les ressources suivantes :

L’article Modèles .NET par défaut pour dotnet new de la documentation .NET Core :
- blazorserver (inclut les options blazorserver-empty)
- blazorwasm (inclut les options blazorwasm-empty)
Passage de l’option d’aide (-h ou --help) à la commande CLI dotnet new dans un interpréteur de commandes :
- dotnet new blazorserver -h
- dotnet new blazorserver-empty -h
- dotnet new blazorwasm -h
- dotnet new blazorwasm-empty -h

Pour plus d’informations sur les options de modèle, consultez les ressources suivantes :

L’article Modèles .NET par défaut pour dotnet new de la documentation .NET Core :
- blazorserver
- blazorwasm
Passage de l’option d’aide (-h ou --help) à la commande CLI dotnet new dans un interpréteur de commandes :
- dotnet new blazorserver -h
- dotnet new blazorwasm -h

Partage via

Outils pour ASP.NET Core Blazor

Exécuter l’application

Arrêter l’application

Fichier de solution Visual Studio (`.sln`)

modèles de projet et options de modèle Blazor

Mode de rendu interactif

Emplacement d’interactivité

Exemples de pages

Conseils supplémentaires sur les options de modèle

Ressources supplémentaires

Ressources supplémentaires

Partage via

Outils pour ASP.NET Core Blazor

Exécuter l’application

Arrêter l’application

Fichier de solution Visual Studio (.sln)

modèles de projet et options de modèle Blazor

Mode de rendu interactif

Emplacement d’interactivité

Exemples de pages

Conseils supplémentaires sur les options de modèle

Ressources supplémentaires

Ressources supplémentaires

Fichier de solution Visual Studio (`.sln`)