Napojení na databázi

ASP.NET MVC

SSŠVT

Entity Framework

Abychom mohli data, která si vyměňuje klient se serverem, persistovat, potřebujeme několik věcí.

1. Připravit databázi
2. Upravit business objekty
3. Připravit datovou vrstvu
4. Připravit aplikační vrstvu
5. Připravit prezentační vrstvu
6. Propojit vrstvy pomocí Dependency Injection

Databáze

Především potřebujeme databázi a v ní nějaké databázové tabulky. Tabulky budou odpovídat našim business objektům.

Business objekty

V business objektech potřebujeme ještě doplnit toto:

• Přidat vlastnost ID.
• Přidat mapování busines objektu na tabulku v databázi (ORM).

  using System;
  using System.Collections.Generic;
  using System.ComponentModel.DataAnnotations;
  using System.ComponentModel.DataAnnotations.Schema;
  
  namespace PetEShopWebMVC.BusinessObjects
  {
      [Table("PE_HOUSE")]
      public class House
      {
  
          [Key]
          [Column("ID")]
          public int ID { get; set; }
  
          [Column("DESCRIPTION")]
          public string Description { get; set; }
  
          [Column("WIDTH")]
          public double Width { get; set; }
  
          [Column("LENGTH")]
          public double Length { get; set; }
  
          public House()
          {
          }
  
          public House(string description, double width, double length)
          {
              this.Description = description;
              this.Width = width;
              this.Length = length;
          }
  
      }
  }
                  

• Přidat DbSet do kontextové třídy Entity Frameworku. Naše kontextová třída se jmenuje ApplicationDbContext.

  public DbSet<House> Houses { get; set; }
                  

Datová vrstva a ORM

Dále vytvoříme interface a repo třídu pro daný business objekt. To je tzv. datová vrstva (DAO).

public interface IHouseRepo
{
    IList<House> GetList();
    IList<House> FindList(House house);
    bool Exists(House house);
    House Load(House house);
    void Store(House house);
    void Add(House house);
    void Remove(House house);
}
        

Implementace interface-u IHouseRepo je ve třídě HouseRepo.

Aplikační vrstva

Dále vytvoříme interface a servisní třídu pro tentýž business objekt. To je tzv. aplikační vrstva (někdy též business logic layer).

using System;
using System.Collections.Generic;
using PetEShopWebMVC.BusinessObjects;

namespace PetEShopWebMVC.Interfaces.Services.Test
{
    public interface IHouseService
    {
        House SaveHouse(House house);
    }
}
        

Implementace interface-u IHouseService je ve třídě HouseService.

Prezentační vrstva

Vrstva MVC (model-view-controller) je de facto prezentační vrstva celé aplikace.

V případě use-case-u pro editaci business objektu House použijeme tyto třídy a soubory:

• Business objekt House jako model (editujeme jedinou instanci entity pro dům).
• Razor-view soubor EditHouse.cshtml jako view.
• Třídu HouseController jako controller.

Business objekt House už máme hotový. Jen ho použijeme pro view EditHouse jako model.

Soubor EditHouse.cshtml jsme nechali vygenerovat právě k business objektu House. Tedy by měl zrcadlit vlastnosti našeho domu (popisku, šířku, délku).

Do třídy HouseController přidáme dvě akce (pro HTTP GET a HTTP POST).

První akce (ShowEditHouse) zobrazí prázdný editační formulář.

// GET /houses/edit-house
[HttpGet("edit-house")]
public IActionResult ShowEditHouse()
{
    return View("/Views/House/EditHouse.cshtml", new House());
}
        

Druhá akce (EditHouse) zpracuje data z webového formuláře (vypíše je do logu a uloží je do db). Vrací HTTP status code 200, což znamená OK (vše v pořádku).

// POST /House/EditHouse
[HttpPost("/houses")]
public IActionResult EditHouse([FromForm] House house)
{
    Console.WriteLine($"Descr.:  {house.Description}  Size: {house.Width}x{house.Length} m");
    this.houseService.SaveHouse(house);
    return new OkResult();
}
        

Dependency Injection

Ještě musíme jednotlivé vrstvy naší appky propojit. Využijeme tzv. Dependency Injection (DI):

• Napojíme servisní třídu (aplikační vrstva) přes interface na datovou vrstvu. Propojení je realizované přes interface IHouseRepo. Objekt, který implementuje tento interface, předáme do konstruktoru naší servisní třídy HouseService.

  public class HouseService : IHouseService
  {
      private readonly IHouseRepo houseRepo;
  
      public HouseService(IHouseRepo houseRepo)
      {
          this.houseRepo = houseRepo;
      }
  
      // ...
  }
                  

• Napojíme controller (prezentační vrstva) přes interface na aplikační vrstvu.

  [Route("houses")]
  public class HouseController : Controller
  {
      private readonly IHouseService houseService;
  
      public HouseController(IHouseService houseService, IAuthService authService)
      {
          this.houseService = houseService;
          this.authService = authService;
      }
  
      // ...
  }
                  

• Přidáme konfiguraci DI. Tam říkáme, jakou třídu má depedency resolver použít pro určitý interface. Konfiguraci doplníme do třídy Startup (soubor Startup.cs v root-u MVC projektu), konkrétně do její metody ConfigureServices.

  // This method gets called by the runtime. Use this method to add services to the container.
  public void ConfigureServices(IServiceCollection services)
  {
  
      // Configure the ORM layer.
      services.AddDbContext<ApplicationDbContext>(options =>
          options.UseSqlServer(
              Configuration.GetConnectionString("MssqlConnection")));
      services.AddDatabaseDeveloperPageExceptionFilter();
  
      // Configure authentication with individual accounts.
      services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
          .AddEntityFrameworkStores<ApplicationDbContext>();
  
      // Configure controllers and views.
      services.AddControllersWithViews();
  
      // Configure the application layer using Dependency Injection (DI).
      services.AddScoped<IHouseService, HouseService>();
  
      // Configure the data layer using DI.
      services.AddScoped<IHouseRepo, HouseRepo>();
  
  }