Apprendre à créer une application CRUD avec ASP.NET Core et Entity Framework Core,

Un tutoriel de Hinault Romaric

Les modifications profondes qu’a subi ASP.NET Core peuvent sembler déconcertantes pour certains à première vue. Cependant, en dehors des changements dans les fichiers de configuration (abandon du XML pour du JSON), le modèle de programmation reste sensiblement le même.



Ce billet de blog s’adresse essentiellement aux débutants et pourra servir de base à ceux-ci pour démarrer avec leur première application ASP.NET Core avec Entity Framework Core. Nous allons utiliser dans ce billet l’approche Code First.

Vous devez disposer de Visual Studio 2015 Community Edition et .NET Core 1.0.0 - VS 2015 Tooling Preview 2.

Création du projet.

Créez un nouveau projet (SampleApp), en utilisant le modèle Web Application. Pour cela :

• Lancez Visual Studio 2015 ;
  
• Cliquez sur le menu Fichier, puis sur Nouveau et enfin Projet ;
  
• Dans le menu de gauche, sélectionnez .NET Core ;
  
• Choisissez le modèle de projet “ASP.NET Core Web Application (.NET Core)” ;
  
• Entrez le nom du projet (SampleApp) et cliquez sur Ok ;
  
• Dans la fenêtre qui va s’afficher, sélectionnez “Web Application” et cliquez sur Ok, pour créer le projet.
  

Ceci fait, ajoutez une référence à Entity Framework Core à partir de la console NuGet. Pour cela :
-cliquez sur le menu Outils, puis sur Gestionnaire de package NuGet et ensuite sur Console du Gestionnaire de package ;
- Dans la console qui va s’afficher, exécutez les deux commandes suivantes, pour installer Entity Framework Core et les outils rattachés.

Install-Package Microsoft.EntityFrameworkCore.SqlServer

Install-Package Microsoft.EntityFrameworkCore.Tools –Pre

219941

Ouvrez le fichier Project.json et copiez la ligne suivante dans la section “tools” :

"Microsoft.EntityFrameworkCore.Tools": "1.0.0-preview2-final"

Cette dernière devrait ressembler à ceci :

"tools": {
"BundlerMinifier.Core": "2.0.238",
"Microsoft.EntityFrameworkCore.Tools": "1.0.0-preview2-final",
"Microsoft.AspNetCore.Razor.Tools": "1.0.0-preview2-final",
"Microsoft.AspNetCore.Server.IISIntegration.Tools": "1.0.0-preview2-final"
},

Création du Model

Créez un nouveau dossier “Models” dans votre projet (Clic droit sur le projet dans l’explorateur de solution, puis sur Nouveau, ensuite sur Dossier et saisir le nom du dossier).

Ajoutez dans ce dossier un nouveau fichier Student.cs (Clic droit sur le dossier dans l’explorateur de solution, puis sur Ajouter, ensuite Class et saisir le nom du fichier).

Dans ce fichier, ajoutez le code suivant :

[Table("Student")]
public class Student
{
public int Id { get; set; }


[StringLength(50)]
public string FirstName { get; set; }


[StringLength(50)]
public string LastName { get; set; }


[DataType(DataType.EmailAddress)]
[StringLength(50)]
public string Email { get; set; }
}

Vous devez ajouter les références suivantes :

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

Vous venez de définir une table de votre base de données. Maintenant, vous allez créer le DbContext. Pour cela, vous devez ajouter un nouveau fichier SampleAppContext.cs au dossier Models de votre projet. Dans ce dernier, ajoutez le code suivant :

public class SampleAppContext : DbContext
{

public SampleAppContext(DbContextOptions options)
: base(options)
{ }


public DbSet Students { get; set; }

}

Vous devez ajouter la référence suivante :

using Microsoft.EntityFrameworkCore;

Maintenant, vous allez utiliser l’injection des dépendances qu’offre ASP.NET Core pour enregistrer votre Context. Pour cela, ouvrez le fichier Startup.cs de votre projet. Ajoutez dans un premier temps les références suivantes :

using SampleApp.Models;
using Microsoft.EntityFrameworkCore;

Dans la méthode ConfigureServices, ajoutez les lignes de code suivantes :

var connection = @"Server=(localdb)\mssqllocaldb;Database=StudentDB;Trusted_Connection=True;";
services.AddDbContext(options => options.UseSqlServer(connection));

Enregistrez les modifications.

Génération de la base de données

Passons maintenant à la création de la base de données. Ouvrez à nouveau la console NuGet et exécutez les commandes suivantes :

Add-Migration InitDatabase

Update-Database

La commande Add-Migration va créer dans votre projet un dossier “Migrations”, avec du code représentant le schéma de votre base de données. La commande Update-Database va utiliser ce code pour mettre à jour la base de données. Parce qu’elle n’existe pas, elle sera automatiquement créée.

Création du contrôleur

Ceci fait, exécutez successivement les commandes suivantes pour installer les packages qui permettront de disposer du scaffolding CRUD dans Visual Studio.

Install-Package Microsoft.EntityFrameworkCore.SqlServer

Install-Package Microsoft.VisualStudio.Web.CodeGeneration.Tools -Pre

Install-Package Microsoft.VisualStudio.Web.CodeGeneration.Core -Pre

Install-Package Microsoft.VisualStudio.Web.CodeGenerators.Mvc -Pre


Ouvrez le fichier Project.json, ajoutez les données suivantes dans la section Tools et enregistrez :

"Microsoft.VisualStudio.Web.CodeGeneration.Tools": {
"version": "1.0.0-preview2-final",
"imports": [
"portable-net45+win8+dnxcore50",
"portable-net45+win8"
]
}

NB : Vous devez modifier "version": "1.0.0-preview2-final" afin que celle-ci corresponde à la version Microsoft.VisualStudio.Web.CodeGeneration.Tools dans la section dependencies.

Faites ensuite un clic droit sur le dossier “Controllers”, puis cliquez sur Ajouter, ensuite sur Controller. Dans la fenêtre qui va s’afficher, sélectionnez “MVC Controller with views, using Entity Framework”, puis cliquez sur “Ajouter”. Dans la fenêtre qui va s’afficher, sélectionnez le modèle (Student), puis le Data Context (SampleAppContext), et cliquez sur Ajouter :

219942

Le contrôleur sera généré avec des actions pour la consultation, la création, la modification et la suppression. Les vues correspondantes seront automatiquement ajoutées :

219943

Si vous ouvrez le fichier StudentsController.cs, vous aurez le code suivant :

public class StudentsController : Controller
{
private readonly SampleAppContext _context;

public StudentsController(SampleAppContext context)
{
_context = context;
}

// GET: Students
public async Task Index()
{
return View(await _context.Students.ToListAsync());
}

// GET: Students/Details/5
public async Task Details(int? id)
{
if (id == null)
{
return NotFound();
}

var student = await _context.Students.SingleOrDefaultAsync(m => m.Id == id);
if (student == null)
{
return NotFound();
}

return View(student);
}

// GET: Students/Create
public IActionResult Create()
{
return View();
}

// POST: Students/Create
// To protect from overposting attacks, please enable the specific properties you want to bind to, for
// more details see http://go.microsoft.com/fwlink/?LinkId=317598.


public async Task Create([Bind("Id,Email,FirstName,LastName")] Student student)
{
if (ModelState.IsValid)
{
_context.Add(student);
await _context.SaveChangesAsync();
return RedirectToAction("Index");
}
return View(student);
}

// GET: Students/Edit/5
public async Task Edit(int? id)
{
if (id == null)
{
return NotFound();
}

var student = await _context.Students.SingleOrDefaultAsync(m => m.Id == id);
if (student == null)
{
return NotFound();
}
return View(student);
}

// POST: Students/Edit/5
// To protect from overposting attacks, please enable the specific properties you want to bind to, for
// more details see http://go.microsoft.com/fwlink/?LinkId=317598.


public async Task Edit(int id, [Bind("Id,Email,FirstName,LastName")] Student student)
{
if (id != student.Id)
{
return NotFound();
}

if (ModelState.IsValid)
{
try
{
_context.Update(student);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentExists(student.Id))
{
return NotFound();
}
else
{
throw;
}
}
return RedirectToAction("Index");
}
return View(student);
}

// GET: Students/Delete/5
public async Task Delete(int? id)
{
if (id == null)
{
return NotFound();
}

var student = await _context.Students.SingleOrDefaultAsync(m => m.Id == id);
if (student == null)
{
return NotFound();
}

return View(student);
}

// POST: Students/Delete/5
[HttpPost, ActionName("Delete")]

public async Task DeleteConfirmed(int id)
{
var student = await _context.Students.SingleOrDefaultAsync(m => m.Id == id);
_context.Students.Remove(student);
await _context.SaveChangesAsync();
return RedirectToAction("Index");
}

private bool StudentExists(int id)
{
return _context.Students.Any(e => e.Id == id);
}
}


Exécutez votre application. Dans le lien qui va s’afficher dans le navigateur, saisissez à la suite /students/create. Vous aurez la page suivante:

220472

Vous venez de créer votre première application CRUD ASP.NET Core MVC avec Entity Framework Core. Vous pouvez désormais continuer à l’enrichir en fonctionnalités.

Vous avez lu gratuitement 3 329 articles depuis plus d'un an.
Soutenez le club developpez.com en souscrivant un abonnement pour que nous puissions continuer à vous proposer des publications.