Entity Framework
Najpierw kod - płynne API

Uwagi

Modele mapowania

EntityFramewok Fluent API to potężny i elegancki sposób mapowania modeli domen z kodem do bazowej bazy danych. Można tego również użyć w przypadku kodu najpierw w istniejącej bazie danych . Przy korzystaniu z Fluent API masz dwie opcje: możesz bezpośrednio zamapować swoje modele na metodzie OnModelCreating lub możesz stworzyć klasy mapujące, które dziedziczą z EntityTypeConfiguration, a następnie dodać te modele do modelBuilder na metodzie OnModelCreating . Druga opcja jest tym, co wolę i pokażę jej przykład.

Krok pierwszy: Utwórz model.

public class Employee
{
    public int Id { get; set; }
    public string Surname { get; set; }    
    public string FirstName { get; set; }    
    public string LastName { get; set; }        
    public short Age { get; set; }    
    public decimal MonthlySalary { get; set; }
        
    public string FullName
    {
        get
        {
            return $"{Surname} {FirstName} {LastName}";
        }
    }
}

Krok drugi: Utwórz klasę mapowania

public class EmployeeMap
    : EntityTypeConfiguration<Employee>
{
    public EmployeeMap()
    {
        // Primary key
        this.HasKey(m => m.Id);
        
        this.Property(m => m.Id)
            .HasColumnType("int")
            .HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
            
        // Properties
        this.Property(m => m.Surname)
            .HasMaxLength(50);
            
        this.Property(m => m.FirstName)
            .IsRequired()
            .HasMaxLength(50);
            
        this.Property(m => m.LastName)
            .HasMaxLength(50);
            
        this.Property(m => m.Age)
            .HasColumnType("smallint");
            
        this.Property(m => m.MonthlySalary)
            .HasColumnType("number")
            .HasPrecision(14, 5);
            
        this.Ignore(m => m.FullName);
        
        // Table & column mappings
        this.ToTable("TABLE_NAME", "SCHEMA_NAME");
        this.Property(m => m.Id).HasColumnName("ID");
        this.Property(m => m.Surname).HasColumnName("SURNAME");
        this.Property(m => m.FirstName).HasColumnName("FIRST_NAME");
        this.Property(m => m.LastName).HasColumnName("LAST_NAME");
        this.Property(m => m.Age).HasColumnName("AGE");
        this.Property(m => m.MonthlySalary).HasColumnName("MONTHLY_SALARY");
    }
}

Wyjaśnijmy mapowania:

• HasKey - definiuje klucz podstawowy. Można również użyć kompozytowych kluczy podstawowych . Na przykład: this.HasKey (m => new {m.DepartmentId, m.PositionId}) .
• Właściwość - pozwala nam skonfigurować właściwości modelu.
• HasColumnType - określ typ kolumny na poziomie bazy danych. Należy pamiętać, że może być inaczej dla różnych baz danych, takich jak Oracle i MS SQL.
• HasDatabaseGeneratedOption - określa, czy właściwość jest obliczana na poziomie bazy danych. Numeryczne PK są domyślnie DatabaseGeneratedOption.Identity , należy określić DatabaseGeneratedOption.None, jeśli nie chcesz, aby tak było.
• HasMaxLength - ogranicza długość łańcucha.
• IsRequired - oznacza właściwość jako wymaganą.
• HasPrecision - pozwala określić precyzję liczb dziesiętnych.
• Ignoruj - Ignoruje właściwość całkowicie i nie mapuje jej do bazy danych. Zignorowaliśmy FullName, ponieważ nie chcemy tej kolumny przy naszej tabeli.
• ToTable - podaj nazwę tabeli i nazwę schematu (opcjonalnie) dla modelu.
• HasColumnName - powiązanie właściwości z nazwą kolumny. Nie jest to konieczne, gdy nazwy właściwości i nazwy kolumn są identyczne.

Krok trzeci: Dodaj klasę mapowania do konfiguracji.

Musimy powiedzieć EntityFramework, aby użył naszej klasy mapera. Aby to zrobić, musimy dodać go do modeluBuilder.Configurations w metodzie OnModelCreating :

public class DbContext()
    : base("Name=DbContext")
{
    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Configurations.Add(new EmployeeMap());
    }
}

I to jest to. Wszyscy jesteśmy gotowi do wyjścia.

Klucz podstawowy

Przy użyciu metody .HasKey () właściwość można jawnie skonfigurować jako klucz podstawowy encji.

using System.Data.Entity;    
// ..

public class PersonContext : DbContext
{
    // ..

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        // ..

        modelBuilder.Entity<Person>().HasKey(p => p.PersonKey);
    }
}

Złożony klucz główny

Korzystając z metody .HasKey (), zestaw właściwości można jawnie skonfigurować jako złożony klucz podstawowy encji.

using System.Data.Entity;    
// ..

public class PersonContext : DbContext
{
    // ..

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        // ..

        modelBuilder.Entity<Person>().HasKey(p => new { p.FirstName, p.LastName });
    }
}

Maksymalna długość

Za pomocą metody .HasMaxLength () można skonfigurować maksymalną liczbę znaków dla właściwości.

using System.Data.Entity;    
// ..

public class PersonContext : DbContext
{
    // ..

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        // ..

        modelBuilder.Entity<Person>()
                    .Property(t => t.Name)
                    .HasMaxLength(100);
    }
}

Powstała kolumna o określonej długości kolumny:

Wymagane właściwości (NOT NULL)

Korzystając z metody .IsRequired (), właściwości można określić jako obowiązkowe, co oznacza, że kolumna będzie miała ograniczenie NOT NULL.

using System.Data.Entity;    
// ..

public class PersonContext : DbContext
{
    // ..

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        // ..

        modelBuilder.Entity<Person>()
                    .Property(t => t.Name)
                    .IsRequired();
    }
}

Powstała kolumna z ograniczeniem NOT NULL:

Wyjaśnij nazewnictwo klucza obcego

Gdy w modelu istnieje właściwość nawigacji, Entity Framework automatycznie utworzy kolumnę Klucz obcy. Jeśli określona nazwa klucza obcego jest pożądana, ale nie jest zawarta w modelu jako właściwość, można ją jawnie ustawić za pomocą płynnego interfejsu API. Korzystając z metody Map podczas ustanawiania relacji klucza obcego, można użyć dowolnej unikalnej nazwy dla kluczy obcych.

public class Company
{
    public int Id { get; set; }
}

public class Employee
{
    property int Id { get; set; }
    property Company Employer { get; set; }
}

public class EmployeeContext : DbContext
{
    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Employee>()
                    .HasRequired(x => x.Employer)
                    .WithRequiredDependent()
                    .Map(m => m.MapKey("EmployerId"));
    }
}

Po określeniu relacji metoda Map pozwala jawnie ustawić nazwę klucza obcego poprzez wykonanie MapKey . W tym przykładzie wynikiem nazwy kolumny Employer_Id jest teraz EmployerId.