.NETowo


.NET Core, web development with React and other JavaScript Frameworks

Entity Framework Core z wykorzystaniem PostgreSQL

tags: C#, dotnet, Entity Framework, PostgreSQL, Visual Studio Code

Witam Serdecznie w kolejnym wpisie z serii .NET Core na (NIE)Windowsie. Tym razem chciałbym pokazać jak w prosty sposób nawiązać połącznie z bazą danych Postgre SQL wykorzystując Entity Framework Core.

Uworzenie projektu oraz dodanie odpowiednich paczek

Na początek utwórz nową solucję oraz projekt Web API za pomocą poniższych poleceń

 
Command: 
dotnet new sln –n EntityFrameworkCore 
dotnet new webapi –n EntityFrameworkCore.Web 
dotnet sln EntityFrameworkCore.sln add EntityFrameworkCore.Web/EntityFrameworkCore.Web.csproj 

Po tych operacjach u mnie wygląda to w następujący sposób

Teraz możesz otworzyć projekt w Visual Studio Code lub w innym edytorze (jeżeli masz problemy z podstawami .NET Core CLI sprawdź moje wcześniejsze posty).

Natępny krok to dodanie odpowiednich referencji w pliku EntityFrameworkCore.Web.csproj. Mój plik wygląda jak na listingu poniżej.

 
<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>netcoreapp1.1</TargetFramework>
  </PropertyGroup>
  <ItemGroup>
    <Folder Include="wwwroot\" />
  </ItemGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore" Version="1.1.1" />
    <PackageReference Include="Microsoft.AspNetCore.Mvc" Version="1.1.2" />
    <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="1.1.1" />
    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="1.1.2" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="1.1.2" />
    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="1.1.0" />
    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL.Design" Version="1.1.0" />
  </ItemGroup>
  <ItemGroup>
    <DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="1.0.1" />
  </ItemGroup>
</Project>

Dodaliśmy tutaj kilka paczek:

  • do entity framework core
  • do obsługi baz PostgreSQL
  • narzędzie dotnet ef umożliwiające wykonanie migracji z poziomu wiersza poleceń

Ostatni krok to instalacja paczek nugetowych. W głownym katalogu wykonaj polecenie: dotnet restore

Utworzenie modelu oraz kontekstu bazodanowego

Kolejnym naszym krokiem jest utworzenie modeli w bazie danych. W tym przykładzie dodam kilka klas wykorzystując dwie najpopularniejsze relacje 1 do wielu oraz wiele do wielu.

Na początek utwórzmy: Product.cs, Employee.cs, Shop.cs, Position.cs w katalogu Models. Prezentują się one w poniższy sposób

>Jak widać na diagramie została utworzona klasa Shop, która będzie posiadać relacje do dwóch pozostałych klas Product oraz Employee.
Pomiędzy klasą Shop, a klasą Employee będzie relacja wiele do jeden (sklep może mieć wielu pracowników, a pracownik może być zatrudniony w jednym sklepie).
Pomiędzy klasą Shop, a klasą Product będzie występować relacja wiele do wielu (sklep może posiadać wiele różnych produktów i dany produkt może być dostępny w kilku sklepach).

Przejdźmy zatem do utworzenia omówionych relacji

  1. Relacja 1 do wielu (one to many)

    Jest to naturalna i bardzo prosta do utworzenia relacja po stronie entity framework core, dlatego od niej zaczniemy.

    Na początek przejdź do klasy Employee i dodaj dwa poniższe pola:

     
    public int ShopId { get; set; }
    public Shop Shop { get; set; }
    

    Na polu ShopId po stronie bazie danych zostanie założony klucz obcy (FK) do pola Id w klasie Shop.
    Pole Shop umożliwi nam bezpośrednie odwołanie się do instancji klasy Shop powiązanej z danym obiektem klasy Employee.

    Teraz nadszedł czas na klasę Shop. Aby utworzyć relację wiele do jeden wystarczy dodać kolekcję obiektów danego typu.

     
    public ICollection<Employee> Employees {get; set; }
    

  2. Relacja wiele do wielu (many to many)

    Jest do drugi typ relacji, który omówimy w tym tutorialu. Niestety sprawa tutaj nie wygląda tak dobrze jak w klasycznym Entity Framework
    i ten typ relacji nie jest bezpośrednio wspierany przez EF Core. Aby utworzyć tą relację potrzebna jest klasa pomocnicza którą nazwiemy
    ShopProduct. Będzie ona pomostem pomiędzy klasą Shop, a klasą Product.

    Tak wygląda w tym momencie katalog Models

    Przejdźmy do pliku ShopProduct.cs i wypełnij go jak na obrazku poniżej

    Kolejny krok to dodanie relacji pomiędzy klasą pomocniczą ShopProduct, a klasami Employee i Product.

    Żeby dokończyć tworzenie relacji many to many konieczne jest utworzenie klasy, która będzie zawierać wszystkie encje utworzone przez nas.
    W tym celu w katalogu Models utwórz plik DbEntities.cs, a następnie dodaj DbSety.

    Jak widzisz nie dodawałem tutaj DbSet, ponieważ jest to tylko tabela pomocnicza i nie widzę potrzeby odwoływania się bezpośrednio do niej z poziomu aplikacji w tym prostym przypadku.
    Jeżeli chcesz mieć taką opcję nic nie stoi na przeszkodzie, aby to zrobić. Kolejnym krokiem jest przesłonięcie metody OnModelCreating i poinformowanie generatora o tym jak ma się
    zachować w przypadku naszej relacji many to many.

     
        public class DbEntities : DbContext
        {
            public DbEntities(DbContextOptions<DbEntities> options) : base(options)
            {
    
            }
            protected override void OnModelCreating(ModelBuilder modelBuilder)
            {
                modelBuilder.Entity<ShopProduct>()
                            .HasKey(entity => new { entity.ProductId, entity.ShopId });
    
                modelBuilder.Entity<ShopProduct>()
                            .HasOne(sp => sp.Product)
                            .WithMany(p => p.ProductShops)
                            .HasForeignKey(sp => sp.ProductId);
    
                modelBuilder.Entity<ShopProduct>()
                             .HasOne(sp => sp.Shop)
                             .WithMany(s => s.ShopProducts)
                             .HasForeignKey(sp => sp.ShopId);
            }
    
            public DbSet<Employee> Employees { get; set; }
            public DbSet<Product> Products { get; set; }
            public DbSet<Shop> Shops { get; set; }
           // public DbSet<ShopProduct> ShopProducts { get; set; }
        }
    

Migracje z ef tools

Ostatnim już krokiem będzie odzwierciedlenie naszej struktury po stronie relacyjnej bazy danych w postaci tabel.

Na początek zdefiniujmy connection string w pliku appsettings.json

Teraz w pliku Startup.cs przypiszmy Db Context

Mamy już wszystko czego potrzebujemy do przeprowadzenia migracji. Otwórz wiersz poleceń w katalogu z plikiem EntityFrameworkCore.Web.csproj i wykonaj poniższe komendy

  1. dotnet ef migrations add InitialMigration

    Po wykonaniu tej komendy jeżeli wszystko poszło dobrze zostanie utworzony katalog Migrations jak na poniższym obrazku

  2. Teraz wystarczy nasze zmiany zapisać w bazie danych

    Użyj do tego polecenia: dotnet ef database update

    W efekcie zostanie utworzona nasza baza danych

Podsumowanie

W powyższym wpisie przedstawiłem w jaki sposób przygotować odpowiednio projekt w .NET Core, utworzyć kontekst w Entity Framework Core zawierający relacje 1:N oraz N:N, a następnie jak za pomocą narzędzia dotnet ef dokonać migracji i zrobić aktualizację naszej bazy danych.

Mam nadzieję, że powyższy wpis będzie zrozumiały dla osób początkujących. Czekam na feedback i życzę miłej zabawy z .NET Core

GIT repository: https://github.com/artzie92/dotnetowo_ef_core_postgre


Got Something To Say:

Twój adres email nie zostanie opublikowany. Pola, których wypełnienie jest wymagane, są oznaczone symbolem *