asp.net-core Tutoriel
Démarrer avec asp.net-core

Remarques

Versions

Installation et configuration

Installation de Visual Studio

Si Visual Studio n'est pas installé, vous pouvez télécharger gratuitement Visual Studio Community Edition ici . Si vous l'avez déjà installé, vous pouvez passer à l'étape suivante.

Création d'une application ASP.NET Core MVC.

1. Ouvrez Visual Studio.
2. Sélectionnez Fichier> Nouveau projet.
3. Sélectionnez Web dans la langue de votre choix dans la section Modèles à gauche.
4. Choisissez un type de projet préféré dans la boîte de dialogue.
5. Facultatif: Choisissez un framework .NET que vous souhaitez cibler
6. Nommez votre projet et indiquez si vous souhaitez créer une solution pour le projet.
7. Cliquez sur OK pour créer le projet.

Une autre boîte de dialogue vous sera proposée pour sélectionner le modèle que vous souhaitez utiliser pour le projet:

Chacune des descriptions est explicite. Pour ce premier projet, sélectionnez Application Web , qui contiendra toutes les configurations par défaut, l'authentification et certains contenus existants.

Comme il s'agit d'une application d'introduction ne nécessitant aucune sécurité ou authentification, vous pouvez modifier l'option d'authentification sur Aucune authentification du côté droit de la boîte de dialogue et cliquer sur OK pour créer le projet .

Vous devriez alors voir le nouveau projet dans l'Explorateur de solutions:

Appuyez sur la touche F5 pour exécuter l'application et lancer une session de débogage, qui lancera l'application dans votre navigateur par défaut:

Vous pouvez maintenant voir que votre projet est opérationnel localement et que vous êtes prêt à créer votre application.

Créer un nouveau projet à partir de la ligne de commande

Il est possible de créer un nouveau projet ASP.NET Core entièrement à partir de la ligne de commande en utilisant la commande dotnet .

dotnet new web
dotnet restore
dotnet run

dotnet new web un nouveau projet web "vide". Le paramètre web indique à l'outil dotnet d'utiliser le modèle ASP.NET Core Empty . Utilisez dotnet new -all pour afficher tous les modèles disponibles actuellement installés. Les autres modèles de clé incluent console , classlib , mvc et xunit .

Une fois que le modèle a été échafaudé, vous pouvez restaurer les packages requis pour exécuter le projet ( dotnet restore ), puis le compiler et le démarrer ( dotnet run ).

Une fois le projet en cours, il sera disponible sur le port par défaut: http: // localhost: 5000

API Web ASP.NET Core minimale avec ASP.NET Core MVC

Avec ASP.NET Core 1.0, le framework MVC et Web API ont été fusionnés en un seul framework appelé ASP.NET Core MVC. C'est une bonne chose, puisque MVC et Web API partagent de nombreuses fonctionnalités, mais il y avait toujours des différences subtiles et la duplication de code.

Cependant, le fait de fusionner ces deux éléments dans le cadre du premier a rendu plus difficile la distinction entre les deux. Par exemple, Microsoft.AspNet.WebApi représente le framework Web API 5.xx, pas le nouveau. Mais lorsque vous incluez Microsoft.AspNetCore.Mvc (version 1.0.0 ), vous obtenez le package complet. Cela contiendra toutes les fonctionnalités prêtes à l'emploi proposées par le framework MVC. Comme le rasoir, les aides de balise et la reliure de modèle.

Lorsque vous souhaitez simplement créer une API Web, nous n’avons pas besoin de toutes ces fonctionnalités. Alors, comment pouvons-nous construire une API Web minimaliste? La réponse est: Microsoft.AspNetCore.Mvc.Core . Dans le nouveau monde, MVC est divisé en plusieurs packages et ce package ne contient que les composants principaux du framework MVC, tels que le routage et l’autorisation.

Pour cet exemple, nous allons créer une API MVC minimale. Y compris un formateur JSON et CORS. Créez une application Web ASP.NET Core 1.0 vide et ajoutez ces packages à votre project.json:

"Microsoft.AspNetCore.Mvc.Core": "1.0.0",
"Microsoft.AspNetCore.Mvc.Cors": "1.0.0",
"Microsoft.AspNetCore.Mvc.Formatters.Json": "1.0.0"

Maintenant, nous pouvons enregistrer MVC en utilisant AddMvcCore() dans la classe de démarrage:

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvcCore()
            .AddCors()
            .AddJsonFormatters();
}

AddMvcCore renvoie une instance IMvcCoreBuilder qui permet la création ultérieure. La configuration du middleware est la même que d'habitude:

public void Configure(IApplicationBuilder app)
{
    app.UseCors(policy =>
    {
        policy.AllowAnyOrigin();
    });
    app.UseMvc();
}

Contrôleurs

L'ancienne API Web est livrée avec sa propre classe de base de contrôleur: ApiController . Dans le nouveau monde, il n’ya rien de tel, seulement la classe de Controller par défaut. Malheureusement, cette classe de base est relativement volumineuse et liée à la liaison de modèle, aux vues et à JSON.NET.

Heureusement, dans le nouveau framework, les classes de contrôleur n'ont pas à dériver de Controller pour être captées par le mécanisme de routage. Il suffit d'ajouter le nom avec Controller . Cela nous permet de construire notre propre classe de base de contrôleur. Appelons cela ApiController , juste pour le bon vieux temps:

/// <summary>
/// Base class for an API controller.
/// </summary>
[Controller]
public abstract class ApiController
{
    [ActionContext]
    public ActionContext ActionContext { get; set; }

    public HttpContext HttpContext => ActionContext?.HttpContext;

    public HttpRequest Request => ActionContext?.HttpContext?.Request;

    public HttpResponse Response => ActionContext?.HttpContext?.Response;

    public IServiceProvider Resolver => ActionContext?.HttpContext?.RequestServices;
}

L'attribut [Controller] indique que le type ou tout type dérivé est considéré comme un contrôleur par le mécanisme de découverte de contrôleur par défaut. L'attribut [ActionContext] spécifie que la propriété doit être définie avec le paramètre ActionContext actuel lorsque MVC crée le contrôleur. ActionContext fournit des informations sur la requête en cours.

ASP.NET Core MVC offre également une classe ControllerBase qui fournit une classe de base de contrôleur sans support de vues. C'est quand même beaucoup plus grand que le nôtre. Utilisez-le si vous le trouvez pratique.

Conclusion

Nous pouvons maintenant construire une API Web minimale en utilisant le nouveau framework ASP.NET Core MVC. La structure modulaire du package nous permet de récupérer les packages dont nous avons besoin et de créer une application simple et simple.

Utilisation du code Visual Studio pour développer une application core aspnet cross plateforme

Avec AspNetCore, vous pouvez développer l'application sur n'importe quelle plate-forme, y compris Mac, Linux, Window et Docker.

Installation et configuration

1. Installer Visual Studio Code d' ici
2. Ajouter l' extion C #
3. Installez dot net core sdk. Vous pouvez installer à partir d' ici

Vous avez maintenant tous les outils disponibles. Développer l'application Maintenant, vous avez besoin d'une option d'échafaudage. Pour cela, vous devriez envisager d'utiliser Yeoman. Pour installer Yeoman

1. Installez NPM. Pour cela, vous avez besoin d'un nœud sur votre machine. Installer à partir d' ici

2. Installez Yeoman en utilisant NPM

   npm install -g yo

3. Maintenant, installez le générateur d'aspnet

   npm install -g generator-aspnet

Maintenant, nous avons toute la configuration sur votre machine. Commençons par créer un nouveau projet avec la commande de base DotNetCore et ensuite créer un nouveau projet en utilisant Yo.

Nouveau projet utilisant la ligne de commande

1. Créer un nouveau dossier de projet

   mkdir CoreApplication cd CoreApplication

2. Echafaudage d'un projet dotnet très basique en utilisant l'option de ligne de commande par défaut

   dotnet Nouveau

1. Restaurez les packages et exécutez l'application

   dotNet restauration de runnet

Utilisez Yeoman comme option d'échafaudage

Créer un dossier de projet et exécuter la commande Yo

yo aspnet

Yeoman demandera des entrées comme Type de projet, Nom du projet, etc.

Maintenant, restaurez les paquets en exécutant la commande dotnet restore et exécutez l'application

Utiliser le code VS pour développer l'application

Exécutez le code studio visuel comme

Ouvrez maintenant les fichiers et exécutez l'application. Vous pouvez également rechercher l'extension pour votre aide.

Variable d'environnement d'installation dans ASP.NET Core [Windows]

=> Poste d'origine <=

ASP.NET Core utilise la variable d'environnement ASPNETCORE_ENVIRONMENT pour déterminer l'environnement actuel. Par défaut, si vous exécutez votre application sans définir cette valeur, elle sera automatiquement utilisée par défaut dans l'environnement de Production .

> dotnet run
Project TestApp (.NETCoreApp,Version=v1.0) was previously compiled. Skipping compilation.

Hosting environment: Production  
Content root path: C:\Projects\TestApp  
Now listening on: http://localhost:5000  
Application started. Press Ctrl+C to shut down. 

Définition de la variable d'environnement dans Windows

Sur la ligne de commande

Vous pouvez facilement définir une variable d'environnement à partir d'une invite de commandes à l'aide de la commande setx.exe incluse dans Windows. Vous pouvez l'utiliser pour définir facilement une variable utilisateur:

>setx ASPNETCORE_ENVIRONMENT "Development"

SUCCESS: Specified value was saved.

Notez que la variable d'environnement n'est pas définie dans la fenêtre ouverte en cours. Vous devrez ouvrir une nouvelle invite de commande pour voir l'environnement mis à jour. Il est également possible de définir des variables système (plutôt que des variables utilisateur) si vous ouvrez une invite de commande administrative et ajoutez le commutateur / M:

>setx ASPNETCORE_ENVIRONMENT "Development" /M

SUCCESS: Specified value was saved.

Utilisation de PowerShell Vous pouvez également utiliser PowerShell pour définir la variable. Dans PowerShell, ainsi que les variables utilisateur et système normales, vous pouvez également créer une variable temporaire à l'aide de la commande $Env: :

$Env:ASPNETCORE_ENVIRONMENT = "Development"

La variable créée ne dure que pendant la durée de votre session PowerShell. Une fois la fenêtre fermée, l'environnement revient à sa valeur par défaut.

Vous pouvez également définir directement les variables d'environnement utilisateur ou système. Cette méthode ne modifie pas les variables d'environnement dans la session en cours. Vous devrez donc ouvrir une nouvelle fenêtre PowerShell pour voir vos modifications. Comme précédemment, la modification des variables système (machine) nécessitera un accès administratif

[Environment]::SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development", "User")
[Environment]::SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development", "Machine")

Utilisation du panneau de configuration Windows Si vous n'êtes pas fan de l'invite de commande, vous pouvez facilement mettre à jour vos variables avec la souris! Cliquez sur le bouton Démarrer de Windows (ou appuyez sur la touche Windows), recherchez environment variables environnement variables pour votre compte:

La sélection de cette option ouvre la boîte de dialogue Propriétés système

Cliquez sur Variables d'environnement pour afficher la liste des variables d'environnement actuelles sur votre système.

En supposant que vous ne possédez pas déjà une variable appelée ASPNETCORE_ENVIRONMENT , cliquez sur le bouton Nouveau ... et ajoutez une nouvelle variable d'environnement de compte: Cliquez sur OK pour enregistrer toutes vos modifications. Vous devrez rouvrir toutes les fenêtres de commande pour vous assurer que les nouvelles variables d'environnement sont chargées.