Entity Framework
Kod först - flytande API

Anmärkningar

Kartlägga modeller

EntityFramewok Fluent API är ett kraftfullt och elegant sätt att kartlägga dina kod-första domänmodeller till underliggande databas. Detta kan också användas med kod-först med befintlig databas . Du har två alternativ när du använder Fluent API : du kan direkt kartlägga dina modeller på OnModelCreating- metoden eller så kan du skapa mapperklasser som ärver från EntityTypeConfiguration och sedan lägga till modellerna till modelBuilder på OnModelCreating- metoden. Det andra alternativet är vilket jag föredrar och kommer att visa exempel på det.

Steg ett: Skapa modell.

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}";
        }
    }
}

Steg två: Skapa mapper-klass

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");
    }
}

Låt oss förklara kartläggningar:

• HasKey - definierar den primära nyckeln. Sammansatta primärnycklar kan också användas. Till exempel: this.HasKey (m => new {m.DepartmentId, m.PositionId}) .
• Egenskap - låter oss konfigurera modellegenskaper.
• HasColumnType - ange kolumntyp för databasnivå. Observera att det kan vara annorlunda för olika databaser som Oracle och MS SQL.
• HasDatabaseGeneratedOption - anger om egenskapen beräknas på databasnivå. Numeriska PK: er är DatabaseGeneratedOption.Identity som standard bör du ange DatabaseGeneratedOption.None om du inte vill att de ska vara det.
• HasMaxLength - begränsar längden på strängen.
• IsRequired - markerar egenskapen som krävs.
• HasPrecision - låter oss specificera precision för decimaler.
• Ignorera - Ignorerar egenskapen helt och kartlägger inte den till databasen. Vi ignorerade FullName eftersom vi inte vill ha den här kolumnen vid vårt bord.
• ToTable - ange tabellnamn och schemanamn (valfritt) för modellen.
• HasColumnName - relatera egenskap med kolumnnamn. Detta behövs inte när egendomens namn och kolumnnamn är identiska.

Steg tre: Lägg till kartläggningsklass i konfigurationer.

Vi måste berätta för EntityFramework att använda vår mapper-klass. För att göra det måste vi lägga till det i modelBuilder.Configurations på OnModelCreating- metoden:

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

Och det är det. Vi är beredda att gå.

Primärnyckel

Genom att använda metoden .HasKey () kan en egenskap uttryckligen konfigureras som enhetens primära nyckel.

using System.Data.Entity;    
// ..

public class PersonContext : DbContext
{
    // ..

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

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

Sammansatt primär nyckel

Genom att använda metoden .HasKey () kan en uppsättning egenskaper konfigureras uttryckligen som den sammansatta primära nyckeln för enheten.

using System.Data.Entity;    
// ..

public class PersonContext : DbContext
{
    // ..

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

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

Maximal längd

Genom att använda metoden .HasMaxLength () kan det maximala teckenantalet konfigureras för en egenskap.

using System.Data.Entity;    
// ..

public class PersonContext : DbContext
{
    // ..

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

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

Den resulterande kolumnen med den angivna kolumnlängden:

Obligatoriska egenskaper (INTE NULL)

Genom att använda metoden .IsRequired () kan egenskaper specificeras som obligatoriska, vilket innebär att kolumnen kommer att ha en INTE NULL-begränsning.

using System.Data.Entity;    
// ..

public class PersonContext : DbContext
{
    // ..

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

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

Den resulterande kolumnen med INTE NULL-begränsningen:

Förklara utländsk nyckelnamn

När en navigationsegenskap finns på en modell skapar Entity Framework automatiskt en kolumn med utländsk nyckel. Om ett specifikt främmande nyckelnamn önskas men inte finns som en egenskap i modellen kan det ställas in uttryckligen med hjälp av Fluent API. Genom att använda Map när du skapar relationen med utländsk nyckel kan alla unika namn användas för utländska nycklar.

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"));
    }
}

Efter att ange relationen, den Map gör metoden den främmande nyckeln namn som ska explicit genom att köra MapKey . I det här exemplet, vad som skulle ha resulterat i ett kolumnnamn för Arbetsgivare_Id är nu Arbetsgivar-ID.