Entity Framework
Code First - Vloeiende API

Opmerkingen

Modellen in kaart brengen

EntityFramewok Fluent API is een krachtige en elegante manier om uw code-first domeinmodellen toe te wijzen aan de onderliggende database. Dit kan ook worden gebruikt met code-first met bestaande database . U hebt twee opties bij het gebruik van Fluent API : u kunt uw modellen rechtstreeks toewijzen op de OnModelCreating- methode of u kunt mapper-klassen maken die erven van EntityTypeConfiguration en die modellen vervolgens toevoegen aan modelBuilder op de OnModelCreating- methode. De tweede optie is waar ik de voorkeur aan geef en ga er een voorbeeld van tonen.

Stap één: Model maken.

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

Stap twee: Maak een mapper-klasse

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

Laten we toewijzingen toelichten:

• HasKey - definieert de primaire sleutel. Samengestelde primaire sleutels kunnen ook worden gebruikt. Bijvoorbeeld: this.HasKey (m => new {m.DepartmentId, m.PositionId}) .
• Eigenschap - hiermee kunnen we modeleigenschappen configureren.
• HasColumnType - geef kolomtype op databaseniveau op. Houd er rekening mee dat het kan verschillen voor verschillende databases zoals Oracle en MS SQL.
• HasDatabaseGeneratedOption - geeft aan of de eigenschap wordt berekend op databaseniveau. Numerieke PK's zijn DatabaseGeneratedOption . Standaard moet u DatabaseGeneratedOption.None opgeven als u niet wilt dat dit zo is.
• HasMaxLength - beperkt de lengte van de string.
• IsRequired - markeert de eigenschap als vereist.
• HasPrecision - hiermee kunnen we precisie opgeven voor decimalen.
• Negeren - Negeert eigenschap volledig en wijst deze niet toe aan de database. We hebben FullName genegeerd, omdat we deze kolom niet aan onze tafel willen hebben.
• ToTable - geef de tabelnaam en schemanaam (optioneel) op voor het model.
• HasColumnName - eigenschap koppelen aan kolomnaam. Dit is niet nodig wanneer eigenschapnamen en kolomnamen identiek zijn.

Stap drie: voeg een toewijzingsklasse toe aan configuraties.

We moeten EntityFramework vertellen onze mapper-klasse te gebruiken. Om dit te doen, moeten we het toevoegen aan modelBuilder.Configurations on OnModelCreating method:

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

En dat is het dan. We zijn allemaal klaar om te gaan.

Hoofdsleutel

Door de .HasKey () -methode te gebruiken, kan een eigenschap expliciet worden geconfigureerd als primaire sleutel van de entiteit.

using System.Data.Entity;    
// ..

public class PersonContext : DbContext
{
    // ..

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

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

Samengestelde primaire sleutel

Door de .HasKey () -methode te gebruiken, kan een set eigenschappen expliciet worden geconfigureerd als de samengestelde primaire sleutel van de entiteit.

using System.Data.Entity;    
// ..

public class PersonContext : DbContext
{
    // ..

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

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

Maximale lengte

Door de methode .HasMaxLength () te gebruiken, kan het maximale aantal tekens worden geconfigureerd voor een eigenschap.

using System.Data.Entity;    
// ..

public class PersonContext : DbContext
{
    // ..

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

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

De resulterende kolom met de opgegeven kolomlengte:

Vereiste eigenschappen (NIET NULL)

Door de .IsRequired () -methode te gebruiken, kunnen eigenschappen als verplicht worden opgegeven, wat betekent dat de kolom een NOT NULL-beperking heeft.

using System.Data.Entity;    
// ..

public class PersonContext : DbContext
{
    // ..

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

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

De resulterende kolom met de beperking NOT NULL:

Verklaar de naam van een buitenlandse sleutel

Wanneer er een navigatie-eigenschap op een model bestaat, maakt Entity Framework automatisch een kolom Buitenlandse sleutel. Als een specifieke buitenlandse sleutelnaam is gewenst maar niet als eigenschap in het model is opgenomen, kan deze expliciet worden ingesteld met behulp van de Fluent API. Door de Map methode te gebruiken bij het vaststellen van de relatie met een externe sleutel, kan elke unieke naam worden gebruikt voor buitenlandse sleutels.

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

Na het specificeren van de relatie, staat de Map methode toe dat de buitenlandse MapKey expliciet wordt ingesteld door MapKey . Wat in dit voorbeeld zou hebben geresulteerd in een kolomnaam van Employer_Id is nu EmployerId.