Août 2016
Volume 31, numéro 8
Cet article a fait l'objet d'une traduction automatique.
ASP.NET Core - Concevoir des applications avec Visual Studio Code et Entity Framework
Par Alessandro Del Del | Août 2016
Le développement multiplateforme et Open source sont essentielles pour les stratégies actuelles et futures de Microsoft. Blocs de construction de la pile .NET ont été open source, tandis que d’autres ont été développées pour adopter et prendre en charge la nouvelle stratégie. Base d’ASP.NET 1.0, actuellement en mode Release Candidate (RC), est la dernière technologie open source pour la création d’applications multiplateformes pour le Web et le nuage, en cours d’exécution sur Linux, Mac OS X et Windows.
ASP.NET vous permet d’écrire des applications de Model-View-Controller (MVC) avec c# et s’appuie sur .NET Core (dotnet.github.io), le nouveau ouvre source et interplateforme modulaire de compilateurs, les bibliothèques et les runtimes — version RC trop. Le principal avantage de base d’ASP.NET est qu’il est totalement indépendante de n’importe quel système de projet propriétaire ou un environnement de développement intégré, ce qui signifie que vous pouvez également créer une application ASP.NET Core en dehors de Microsoft Visual Studio, ainsi que sur les systèmes d’exploitation différent de Windows.
Pour ce faire, vous utilisez différents outils de ligne de commande pour structurer, générer et exécuter des applications, vous pouvez utiliser le Code de Visual Studio pour la modification. Il y a beaucoup de travail en cours encore, par conséquent, certaines fonctionnalités peuvent modifier jusqu'à ce qu’il atteigne le jalon de la mise en fabrication (RTM). Par exemple, ASP.NET Core permet de s’appuient sur l’environnement d’exécution .NET (DNX) et son interface de ligne de commande (CLI) pour créer et gérer des applications ; ASP.NET Core repose sur .NET Core, DNX sera retirée et sa CLI basculera vers les outils de ligne de commande .NET Core pour les versions futures, donc Gardez cela à l’esprit si vous souhaitez commencer à écrire des applications Web avec ASP.NET Core et c#.
Cet article explique comment créer une application ASP.NET Core Web multiplateforme qui exploite Entity Framework 7 pour exécuter des opérations de données sur une base de données et comment écrire du code dans Visual Studio Code (code.visualstudio.com), que vous utilisez sur Linux, OS X et Windows. Étant donné que le focus est sur les données, je vous recommande de lire le document « .NET et Visual Studio Code principal » sur le site Web officiel (bit.ly/1PhzoC7). Vous allez écrire plusieurs commandes basées sur l’environnement DNX de cohérence avec la version RC actuelle ; n’oubliez pas que cela sera remplacé avec les commandes de la CLI de base .NET une fois ASP.NET Core se transforme en RTM.
Je vous donnerai des commandes que vous auront remplacés le cas échéant. Je vais créer mon exemple d’application à l’aide du nouvel outil de Code Visual Studio. Code Visual Studio est un outil de développement sophistiquées, multilingues et interplateforme qui place l’écriture de code au centre et qui a des raccordements donc vous pouvez émettre des commandes de génération. Je suppose que vous avez déjà installé Visual Studio Code, Node.js (nodejs.org), SQL Server Express Edition (bit.ly/1PhzoC7) et ASP.NET Core 1.0 RC (get.asp.net/OtherDownloads).
Création d’une base de données exemple
Tout d’abord, créez une base de données avec lequel travailler. Vous pouvez utiliser une base de données existante, ou vous pouvez également définir le modèle de données avec l’approche Entity Framework Code First, mais la prise en charge pour les migrations code dans ASP.NET Core est toujours en cours et stable pas pour l’instant. Par conséquent, vous allez créer simplement une nouvelle base de données qui stocke la liste des modèles de voitures et les noms de leurs fabricants. Dans SQL Server Management Studio, créez une nouvelle base de données appelée voitures, puis écrire et exécuter la requête illustrée dans Figure 1, qui définit une table appelée voitures, avec trois colonnes : ID (clé primaire et incrémentation automatique), CarModel (de type NVarChar(Max)) et fabricant (de type NVarChar(Max)).
Figure 1 Création d’un exemple de Table
CREATE TABLE [dbo].[Cars](
[id] [int] IDENTITY(1,1) NOT NULL,
[CarModel] [nvarchar](max) NOT NULL,
[Brand] [nvarchar](max) NOT NULL,
CONSTRAINT [PK_Cars] PRIMARY KEY CLUSTERED
(
[id] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF,
ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO
SET IDENTITY_INSERT [dbo].[Cars] ON
GO
INSERT [dbo].[Cars] ([id], [CarModel], [Brand]) VALUES (1, N'Mustang', N'Ford')
GO
INSERT [dbo].[Cars] ([id], [CarModel], [Brand]) VALUES (2, N'500', N'Fiat')
GO
INSERT [dbo].[Cars] ([id], [CarModel], [Brand]) VALUES (3, N'Giulia', N'Alfa Romeo')
GO
SET IDENTITY_INSERT [dbo].[Cars] OFF
GO
USE [master]
GO
ALTER DATABASE [CARS] SET READ_WRITE
GO
Selon votre scénario, vous pouvez être amené à prendre en compte une colonne de type bit qui vous permet de marquer un élément comme supprimé, mais qui en fait est jamais supprimée du magasin de données.
Assurez-vous que la base de données, la table et des exemples de données sont affichés correctement dans l’Explorateur d’objets de Management Studio.
Installer c# pour Visual Studio Code
Dans Visual Studio Code, la prise en charge linguistique c# a récemment déplacé vers une extension que vous devez télécharger et installer séparément. Il est fortement recommandé de qu'installer l’extension de langage c# pour obtenir toutes les fonctionnalités d’édition ont évolué comme code de syntaxe, IntelliSense, la colorisation émettre détection comme type et bien plus encore. Pour installer le c#, exécuter le Code de Visual Studio, ouvrez la Palette de commandes (F1), puis « installer ext » et appuyez sur ENTRÉE. Dans la liste des extensions, double-cliquez sur c# et attendez que l’installation se termine. Lorsque vous y êtes invité, accepter pour redémarrer Visual Studio Code.
Structure d’une Application ASP.NET Core
Code Visual Studio n’a aucune commande intégrée qui automatise la génération d’un projet ASP.NET Core et création manuelle d’un projet nécessite des efforts. Des cours RC d’ASP.NET principaux, vous pouvez utiliser un outil de ligne de commande appelé Yeoman (yeoman.io), un outil populaire de la structure qui fournit, entre autres choses, une option permettant de générer une structure de l’application ASP.NET Core. Yeoman repose sur Node.js et doit être installé à partir de la ligne de commande à l’aide du Gestionnaire de package Node.js (npm). Ceci dit, ouvrez une invite de commandes et tapez la ligne suivante :
> npm install -g yo generator-aspnet gulp bower
Qui va installer Yeoman (représenté par « yo ») dans l’emplacement global (-g) ainsi que les choses (il s’agit d’un outil d’automatisation des tâches) et bower (un gestionnaire de bibliothèque côté client). Notez que Yeoman est livré avec un certain nombre de générateurs, y compris le générateur ASP.NET et le Générateur d’extension Visual Studio Code. L’option aspnet générateur dans la ligne de commande précédente télécharge et installe le générateur ASP.NET Core destiné à simplifier votre travail. Lorsque vous êtes prêt, à l’aide de la commande cd (ou chdir), déplacer vers un dossier dans lequel vous souhaitez créer une nouvelle application (cd C:\temp). À ce stade, tapez la ligne de commande suivante :
> yo aspnet
Cette opération ouvre le générateur Yeoman ASP.NET, comme vous pouvez le voir dans Figure 2.
.png "Démarrer le Générateur de Yeoman")
Figure 2 démarrer le Générateur de Yeoman
Sélectionnez le modèle d’Application Web et appuyez sur ENTRÉE. Dans l’écran suivant, entrez CarModels comme nom d’application et appuyez sur ENTRÉE. Le générateur définit l’espace de noms racine de l’application en fonction de la casse du nom application. Par conséquent, si CarModels est le nom de l’application, puis l’espace de noms racine doit également être CarModels ; mais si vous entrez carmodels ou carModels comme nom de l’application, puis votre espace de noms racine est carmodels ou carModels, respectivement. Prendre en charge cela lorsque vous spécifiez le nom de l’application. Après quelques secondes, Yeoman termine la génération d’une application ASP.NET Core dans un sous-dossier appelé CarModels. Avec les futures que versions d’ASP.NET Core, vous également sera en mesure d’utiliser l’interface CLI cœur de .NET pour la structure d’une application Web. Vous allez utiliser la ligne de commande doit ressembler à ceci :
> dotnet new
La version actuelle de l’interface CLI ne prend pas en charge la structure d’une application Web au lieu de cela, il génère une application de Console vide, c’est une autre raison, pourquoi vous voyez Yeoman dans action ici. Entrez le dossier CarModels en écrivant « cd CarModels », puis tapez « code », afin que le Code de Visual Studio démarre, ouvrir le dossier actif et son contenu. Lorsque Visual Studio Code ouvre un dossier, il recherche des noms de fichier projet connus, tels que project.json, package.json ou .sln fichiers de solution de MSBuild. Dans le cas d’un projet ASP.NET Core, Visual Studio Code recherche project.json, collecte des informations de dépendance et organise les sous-dossiers et fichiers de code de façon appropriée. La première fois que le projet est ouvert, Visual Studio Code détecte les packages NuGet manquants et vous permet d’effectuer une restauration pour vous.
Cliquez sur Restaurer dans la barre d’information et attendre que les packages NuGet à télécharger. Lorsque vous avez terminé, vous pouvez exploiter toutes les édition de code de fonctionnalités avancées de Visual Studio Code pour écrire et de modifier des fichiers de code et de réutiliser la plupart de vos compétences avec ASP.NET MVC. En fait, Visual Studio Code non seulement prend en charge c#, mais également offres colorisation de la syntaxe et d’autres fonctionnalités avancées pour tous les types de fichiers qui composent une application ASP.NET Core, y compris .cshtml, des feuilles de style CSS, des fichiers JavaScript et .json.
Création du modèle de données avec Entity Framework 7
Maintenant que vous avez une application ASP.NET Core vide, l’étape suivante est de créer un modèle de données avec Entity Framework 7, la nouvelle version du mappeur relationnel objet populaire auprès de Microsoft, qui offre une prise en charge de base d’ASP.NET. Au moment de la rédaction de cet article, Entity Framework 7 est à la version RC1. Création du modèle s’effectue en cours d’exécution les commandes dnx approprié à partir de l’invite de commandes et implique deux packages NuGet. Le premier package NuGet est appelé EntityFramework.MicrosoftSqlServer et est automatiquement référencé par le projet nouvellement créé. Le second package NuGet est appelé EntityFramework.MicrosoftSqlServer.Design et doit être ajouté manuellement pour les dépendances du projet. Pour ce faire, dans le Code de Visual Studio, ouvrez le fichier project.json et recherchez la ligne suivante dans le nœud dépendances :
"EntityFramework.MicrosoftSqlServer": "7.0.0-rc1-final",
Après cette ligne, ajoutez ceci :
"EntityFramework.MicrosoftSqlServer.Design": "7.0.0-rc1-final",
Notez que les deux packages doivent avoir le même numéro de version, qui changera lors des futures versions. Enregistrer project.json. Code Visual Studio détecte un package NuGet manquants et vous invite à nouveau pour un restauration du package. Comme d’habitude, accepter son offre.
Maintenant, ouvrez une invite de commandes sur le dossier qui contient le projet ASP.NET Core. L’environnement dnx fournit la commande Entity Framework, qui vous permet de générer des modèles de données d’entité à partir de la ligne de commande. Cette commande propose des commandes supplémentaires, telles que la base de données, dbcontext et migrations. La commande de base de données vous permet de gérer une base de données et dbcontext vous permet de structurer les entités et un type DbContext migrations vous permet de travailler avec des migrations code. Vous utiliserez la commande dbcontext pour générer une classe DbContext et les entités nécessaires. Vous pouvez écrire dnx Entity Framework pour afficher la liste des commandes disponibles (voir Figure 3) ou tapez une commande complète directement.
.png "Liste des commandes de Framework entité disponible")
Figure 3 la liste des commandes de Framework d’entité disponible
Lorsque vous êtes prêt, écrivez la ligne de commande suivante :
> dnx ef dbcontext scaffold "Server=.\sqlexpress;Database=Cars;Trusted_Connection=True;"
EntityFramework.MicrosoftSqlServer --outputDir Models
La commande de dbcontext accepte une option appelée scaffold, qui génère les entités et DbContext approprié à partir de la base de données spécifiée dans la chaîne de connexion fournie. Bien sûr, vous devez remplacer le nom du serveur avec les vôtres. EntityFramework.MicrosoftSqlServer Spécifie le fournisseur de données que vous voulez utiliser pour la génération de modèles automatique. Notez la façon dont vous pouvez spécifier un répertoire de sortie pour votre modèle de données via l’option--outputDir, qui respecte la casse. Dans ce cas, le répertoire de sortie est un dossier appelé modèles, qui existe déjà dans le projet et est l’emplacement approprié, logique pour la classe DbContext et des entités. Une fois le message d’achèvement, vous verrez comment le dossier Modèles contienne un fichier de classe appelé CarsContext.cs, qui contient la classe CarsContext qui hérite de DbContext, et un fichier appelé Cars.cs, qui définit une classe appelée voitures et qui expose les propriétés qui mappent des colonnes de la table de voitures dans la base de données (voir Figure 4). Notez qu’il n’existe aucune option permettant de contrôler la pluralisation des noms d’entité, donc cela doit être géré manuellement et dépasse le cadre de cet article.
.png "Classe de modèle de voitures dans l’éditeur de Code")
Figure 4 voitures dans l’éditeur de Code de classe de modèle
À ce stade, vous devez fournir la chaîne de connexion que l’application utilisera pour se connecter à la base de données. Au lieu de passer la chaîne de connexion dans le fichier Web.config, cela est possible dans la classe de démarrage. Cette instruction déclare une méthode appelée ConfigureServices, qui est appelée par le runtime pour configurer les services nécessaires via l’injection de dépendance (DI) et est l’emplacement recommandé pour fournir la chaîne de connexion. ConfigureServices utilise un argument appelé services, de type Microsoft.Extensions.DependencyInjection.IServiceCollection, qui stocke la liste des services qui sont incluses. Prenez en compte ces lignes de code :
var connection = @"Server=.\sqlexpress;Database=Cars;Trusted_Connection=True;";
services.AddEntityFramework()
.AddSqlServer()
.AddDbContext<CarsContext>(options => options.UseSqlServer(connection));
Ce que fait la deuxième ligne est inscrire les services d’Entity Framework et SQL Server nécessaires pour l’injection de dépendance et inscrit la classe DbContext en tant que service. La méthode AddDbContext vous permet de spécifier la chaîne de connexion via la méthode DbContextBuilder.UseSqlServer, appelée via un délégué appelé options. Les deux lignes doivent être placés au début de la méthode ConfigureServices, dont le code complet est indiqué dans Figure 5.
Figure 5 l’inscription de la classe DbContext pour l’Injection de dépendance
public void ConfigureServices(IServiceCollection services)
{
// Add framework services
var connection = @"Server=.\sqlexpress;Database=Cars;Trusted_Connection=True;";
services.AddEntityFramework()
.AddSqlServer()
.AddDbContext<CarsContext>(options => options.UseSqlServer(
connection));
services.AddEntityFramework()
.AddSqlite()
.AddDbContext<ApplicationDbContext>(options => options.UseSqlite(
Configuration["Data:DefaultConnection:ConnectionString"]));
services.AddIdentity<ApplicationUser, IdentityRole>()
.AddEntityFrameworkStores<ApplicationDbContext>()
.AddDefaultTokenProviders();
services.AddMvc();
// Add application services
services.AddTransient<IEmailSender, AuthMessageSender>();
services.AddTransient<ISmsSender, AuthMessageSender>();
}
Jusqu'à présent, vous avez implémenté votre modèle de données. Vous devez à présent d’une manière d’exposer les actions qui appelle l’interface utilisateur pour travailler sur des données.
L’implémentation des contrôleurs MVC
ASP.NET Core prend en charge les services API Web et les applications MVC. L’API Web est la meilleure approche si vous créez un service RESTful. l’exemple actuel est à la place une application Web avec une interface utilisateur, afin que vous allez utiliser MVC. Comme vous le feriez dans n’importe quelle application ASP.NET MVC, vous pouvez implémenter les contrôleurs MVC et des vues. Un contrôleur est une classe qui hérite de Microsoft.AspNet.Mvc.Controller et expose les actions que l’interface utilisateur (ou autres clients) peuvent appeler pour travailler sur des données. Pour ajouter un contrôleur, cliquez sur le dossier contrôleurs, puis sélectionnez Nouveau fichier de Code de Visual Studio. Lorsque la zone de texte s’affiche, entrez le nouveau nom de fichier CarsController.cs. Cela ajoutera un fichier c# ouvre également dans l’éditeur de code. Ce que le nouveau contrôleur doit implémenter sont des méthodes qui vous permettent d’interroger, ajouter et supprimer des données. La liste complète pour le contrôleur est indiqué dans Figure 6 (avec des commentaires). Bien que le code peut sembler un peu long, IntelliSense vous aidera à écrire du code plus rapidement et efficacement.
Figure 6 implémentation d’un contrôleur MVC qui fonctionne sur des données
using System.Linq;
using Microsoft.AspNet.Mvc;
using CarModels.Models;
namespace CarModels.Controllers
{
public class CarsController : Controller
{
// Declares the DbContext class
private CarsContext dataContext;
// The instance of DbContext is passed via dependency injection
public CarsController(CarsContext context)
{
this.dataContext=context;
}
// GET: /<controller>/
// Return the list of cars to the caller view
public IActionResult Index()
{
return View(this.dataContext.Cars.ToList());
}
public IActionResult Create()
{
return View();
}
// Add a new object via a POST request
[HttpPost]
[ValidateAntiForgeryToken]
public IActionResult Create(Cars car)
{
// If the data model is in a valid state ...
if (ModelState.IsValid)
{
// ... add the new object to the collection
dataContext.Cars.Add(car);
// Save changes and return to the Index method
dataContext.SaveChanges();
return RedirectToAction("Index");
}
return View(car);
}
[ActionName("Delete")]
public IActionResult Delete(int? id)
{
if (id == null)
{
return HttpNotFound();
}
Cars car = dataContext.Cars.Single(m => m.id == id);
if (car == null)
{
return HttpNotFound();
}
return View(car);
}
// POST: Cars/Delete/5
// Delete an object via a POST request
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public IActionResult DeleteConfirmed(int id)
{
Cars car = dataContext.Cars.SingleOrDefault(m => m.id == id);
// Remove the car from the collection and save changes
dataContext.Cars.Remove(car);
dataContext.SaveChanges();
return RedirectToAction("Index");
}
}
}
En résumé, vous avez quatre actions : Index, qui retourne la liste de voitures à la vue de l’appelant ; Créer, qui ajoute une nouvelle voiture via une demande HTTP POST ; et Delete et DeleteConfirmed, qui attendent la confirmation de l’utilisateur et supprimer une voiture via une demande HTTP POST, respectivement. Sur les index, vous pouvez également écrire une requête LINQ pour retourner une liste filtrée.
Ajout et la conception des vues MVC
Dans MVC, les vues sont des pages Web lié aux données qui composent l’interface utilisateur de l’application. Dans cet exemple, vous avez besoin de trois vues : une page d’Index qui affiche la liste des voitures ; une page de création qui permet aux utilisateurs d’ajouter de nouvelles voitures ; et une page de suppression qui demande confirmation avant de supprimer une voiture à partir de la base de données. Les vues doivent être organisés en sous-dossiers résidant dans le dossier Views, dont le nom est utilisé par l’application pour acheminer les demandes Web. Par exemple, si vous créez un dossier appelé voitures, toutes les vues à l’intérieur de ce dossier seront ouvre aux convention de routage ApplicationName/voitures. En supposant que vous avez créé un dossier nommé voitures dans les affichages, faites un clic droit et sélectionnez Nouveau fichier. Entrez le nom de fichier Index.cshtml et appuyez sur entrée, afin que le nouveau fichier est immédiatement disponible dans l’éditeur de code ; en fonction de son extension, Visual Studio Code reconnaît comme un fichier Razor. Cette vue est utilisée pour afficher la liste complète des articles dans une table ; chaque ligne affiche le modèle de voiture, le nom du fabricant et un lien hypertexte sur lequel les utilisateurs peuvent cliquer pour supprimer un élément. Figure 7 illustre le code complet pour la page Index.cshtml.
Figure 7 la création d’une vue d’Index
@model IEnumerable<CarModels.Models.Cars>
@{
ViewBag.Title = "Cars";
}
<h2>Car models</h2>
<p>
<a asp-controller="Cars" asp-action="Create">Add New</a>
</p>
<table class="table">
<tr>
<th>Car Model</th>
<th>Brand</th>
</tr>
@foreach (var item in Model)
{
<tr>
<td>
@Html.DisplayFor(modelItem => item.CarModel)
</td>
<td>
@Html.DisplayFor(modelItem => item.Brand)
</td>
<td>
<a asp-controller="Cars" asp-action="Delete"
asp-route-id="@item.id">Delete</a>
</td>
</tr>
}
</table>
Notez comment le balisage tire parti de la liaison de modèle soi-disant pour spécifier le type .NET de la classe de modèle et pour appeler et lier ses propriétés pour chaque ligne. En outre, notez comment le lien Supprimer pointe vers l’action de même nom dans le contrôleur de voitures, l’ID de l’élément via une liaison de modèle. De même, une action appelée points créer à l’action de création dans le contrôleur de voitures et ouvre une nouvelle vue qui vous permet d’ajouter de nouveaux objets. Cette vue est appelée à créer, et vous pouvez en créer un en effectuant les mêmes étapes que vous l’avez fait précédemment avec la vue Index, ce qui signifie que l’ajout d’un fichier Create.cshtml dans le sous-dossier Views\Cars. Dans cette nouvelle vue, vous fait créez un formulaire de données où les utilisateurs peuvent écrire des informations basées sur les propriétés du modèle, en fournissant un bouton qui envoie des informations au contrôleur lié. Figure 8 montre comment réaliser cette opération.
Figure 8 définition d’une vue créer
@model CarModels.Models.Cars
@{
ViewBag.Title = "New car";
}
<h2>@ViewData["Title"]</h2>
<form asp-controller="Cars" asp-action="Create" method="post"
class="form-horizontal" role="form">
<div class="form-horizontal">
<div asp-validation-summary="ValidationSummary.All" class="text-danger"></div>
<div class="form-group">
<label asp-for="CarModel" class="col-md-2 control-label"></label>
<div class="col-md-10">
<input asp-for="CarModel" class="form-control" />
<span asp-validation-for="CarModel" class="text-danger"></span>
</div>
<label asp-for="Brand" class="col-md-2 control-label"></label>
<div class="col-md-10">
<input asp-for="Brand" class="form-control" />
<span asp-validation-for="Brand" class="text-danger"></span>
</div>
</div>
<div class="form-group">
<div class="col-md-offset-2 col-md-10">
<input type="submit" value="Create" class="btn btn-default" />
</div>
</div>
</div>
</form>
La dernière étape ajoute une nouvelle vue nommée Delete.cshtml dans le sous-dossier Views\Cars. Lors de l’ajout, tapez le code indiqué dans Figure 9, qui affiche des informations détaillées sur l’élément qui sera supprimé et fournit une option permettant d’envoyer ou annuler les modifications.
Figure 9 Création d’une vue de la suppression
@model CarModels.Models.Cars
@{
ViewData["Title"] = "Delete";
}
<h2>Delete</h2>
<h3>Are you sure you? The operation cannot be undone.</h3>
<div>
<h4>Cars</h4>
<hr />
<dl class="dl-horizontal">
<dt>
@Html.DisplayNameFor(model => model.Brand)
</dt>
<dd>
@Html.DisplayFor(model => model.Brand)
</dd>
<dt>
@Html.DisplayNameFor(model => model.CarModel)
</dt>
<dd>
@Html.DisplayFor(model => model.CarModel)
</dd>
</dl>
<form asp-action="Delete">
<div class="form-actions no-color">
<input type="submit" value="Delete" class="btn btn-default" /> |
<a asp-action="Index">Back to List</a>
</div>
</form>
</div>
À ce stade, vous avez le modèle de données, les actions et l’interface utilisateur. Cela signifie que vous êtes prêt à commencer à tester l’exemple d’application.
Exécution de l’Application
Vous pouvez exécuter directement une application ASP.NET Core à partir de Code Visual Studio. Pour ce faire, ouvrez la Palette de commandes, tapez dnx et appuyez sur ENTRÉE. Ensuite, sélectionnez dnx : Exécutez la commande et appuyez sur ENTRÉE. Cliquez ensuite sur dnx web. Il s’agit de l’équivalent de frappe dnx web dans une invite de commandes. Dans les futures versions, vous allez écrire dotnet exécuter à partir de la ligne de commande. À ce stade, le Code de Visual Studio démarre Kestrel, un serveur de Web open source pour les applications ASP.NET Core (bit.ly/1rdEfxV), pour héberger votre application Web. Dans Visual Studio Code, vous verrez également une fenêtre de Console où Kestrel redirige la sortie et tous les messages que le runtime envoie, y compris la trace de pile en cas d’exceptions, qui est particulièrement utile pour le débogage. Par défaut, Kestrel commence à écouter sur le port 5000, ce qui signifie que vous pouvez ouvrir votre navigateur préféré et tapez http://localhost : 5000 pour démarrer l’application. Figure 10 montre l’exécution de l’application.
.png "L’exécution de l’Application")
Figure 10 l’exécution de l’Application
Dans la barre d’adresse du navigateur Web, tapez localhost:5000 / afficher les voitures pour ouvrir la valeur par défaut pour le contrôleur de voitures. Comme vous pouvez le voir dans Figure 11, l’application affiche la liste des voitures, comme prévu.
.png "Application affichant la liste de voitures dans la base de données")
Application de la figure 11 montrant la liste de voitures dans la base de données
Cliquez sur Nouveau, afin que vous ayez une option pour ajouter un nouvel élément (voir Figure 12). Lorsque vous cliquez sur Créer, le nouvel élément est enregistré dans la base de données et l’application permet d’accéder à la vue précédente, où vous pouvez consulter la liste de mises à jour de voitures.
.png "Ajouter un nouvel élément")
Figure 12 Ajout d’un nouvel élément
Maintenant, cliquez sur le lien hypertexte Delete près de la voiture que vous avez ajoutée précédemment. La suppression s’affiche, indiquant les détails de l’élément sélectionné et demander confirmation de l’utilisateur (voir Figure 13). Cliquez sur Supprimer pour supprimer l’élément et revenir à l’index. N’oubliez pas qu’il s’agit d’une application Web multiplateforme, donc elle peut être publiée sur Linux, OS X et Windows.
.png "Suppression d’un élément")
Suppression d’un élément de la figure 13
Conseils sur la publication de votre Application
Vous disposez des alternatives à la publication de votre application ASP.NET Core, notamment (liste non exhaustive) Microsoft Azure et IIS. La première option implique l’activation de l’intégration de Git, tandis que l’autre implique actuellement l’utilitaire DNX (dnu) et le dnu publier la ligne de commande et implique la dotnet publier ligne de commande dans les versions futures. La publication a été traitée sur les ressources de Microsoft. Publication sur Azure est traitée à bit.ly/22QXTh6, alors que l’utilisation dnu est traitée sur bit.ly/1TWvfWh.
Synthèse
Code Visual Studio vous permet d’écrire des applications de base d’ASP.NET en tirant parti de toutes les fonctionnalités d’éditions ont évolué disponibles pour c# et les autres types de fichiers dans le projet. Un interplateforme lui-même, il est la solution idéale pour commencer à écrire des applications MVC pour Linux, OS X et Windows. La disponibilité d’Entity Framework pour différentes plateformes et la possibilité de réutiliser vos existant c# MVC compétences et facilitent l’écriture des applications Web orientées données une expérience encore plus étonnante. N’oubliez pas de consulter la documentation principale de ASP.NET et .NET Core pour les mises à jour de la CLI de base .NET.
Alessandro Del Sole est MVP Microsoft depuis 2008. Promu MVP de l’année cinq fois, il est l’auteur de nombreux livres, livres, des vidéos et articles sur le développement .NET avec Visual Studio. DEL unique fonctionne comme un solution developer expert de cerveau-Sys (www.brain-sys.it), en mettant l’accent sur le développement .NET, formation et de Conseil. Vous pouvez le suivre sur Twitter : @progalex.
Merci à l'experte technique Microsoft suivante d'avoir relu cet article : James McCaffrey
Dr. James McCaffrey travaille pour Microsoft Research à Redmond, Wash. Il a travaillé sur plusieurs produits Microsoft, notamment Internet Explorer et Bing. Dr. Vous pouvez contacter James McCaffrey à jammc@microsoft.com.