Code First-konventioner

Med Code First kan du beskriva en modell med hjälp av C# eller Visual Basic .NET-klasser. Modellens grundläggande form identifieras med hjälp av konventioner. Konventioner är uppsättningar med regler som används för att automatiskt konfigurera en konceptuell modell baserat på klassdefinitioner när du arbetar med Code First. Konventionerna definieras i namnområdet System.Data.Entity.ModelConfiguration.Conventions.

Du kan konfigurera din modell ytterligare med hjälp av dataanteckningar eller fluent-API:et. Prioritet ges till konfiguration via api:et fluent följt av dataanteckningar och sedan konventioner. Mer information finns i Dataanteckningar, Fluent API – Relationer, Fluent API – Typer och egenskaper och Fluent API med VB.NET.

En detaljerad lista över Code First-konventioner finns i API-dokumentationen. Det här avsnittet innehåller en översikt över de konventioner som används av Code First.

Typidentifiering

När du använder Code First-utveckling börjar du vanligtvis med att skriva .NET Framework-klasser som definierar din konceptuella modell (domän). Förutom att definiera klasserna måste du även låta DbContext veta vilka typer du vill inkludera i modellen. För att göra detta definierar du en kontextklass som härleds från DbContext och exponerar DbSet-egenskaper för de typer som du vill vara en del av modellen. Code First innehåller dessa typer och hämtar även alla refererade typer, även om de refererade typerna definieras i en annan sammansättning.

Om dina typer deltar i en arvshierarki räcker det att definiera en DbSet-egenskap för basklassen, och de härledda typerna inkluderas automatiskt om de finns i samma sammansättning som basklassen.

I följande exempel finns det bara en DbSet-egenskap som definierats i klassen SchoolEntities (Avdelningar). Code First använder den här egenskapen för att identifiera och hämta alla refererade typer.

public class SchoolEntities : DbContext
{
    public DbSet<Department> Departments { get; set; }
}

public class Department
{
    // Primary key
    public int DepartmentID { get; set; }
    public string Name { get; set; }

    // Navigation property
    public virtual ICollection<Course> Courses { get; set; }
}

public class Course
{
    // Primary key
    public int CourseID { get; set; }

    public string Title { get; set; }
    public int Credits { get; set; }

    // Foreign key
    public int DepartmentID { get; set; }

    // Navigation properties
    public virtual Department Department { get; set; }
}

public partial class OnlineCourse : Course
{
    public string URL { get; set; }
}

public partial class OnsiteCourse : Course
{
    public string Location { get; set; }
    public string Days { get; set; }
    public System.DateTime Time { get; set; }
}

Om du vill undanta en typ från modellen använder du attributet NotMapped eller DbModelBuilder.Ignore fluent API.

modelBuilder.Ignore<Department>();

Primärnyckelkonvention

Code First härleder att en egenskap är en primärnyckel om en egenskap i en klass heter "ID" (inte skiftlägeskänsligt) eller klassnamnet följt av "ID". Om typen av primärnyckelegenskap är numerisk eller GUID konfigureras den som en identitetskolumn.

public class Department
{
    // Primary key
    public int DepartmentID { get; set; }

    . . .  

}

Relationskonvention

I Entity Framework ger navigeringsegenskaper ett sätt att navigera i en relation mellan två entitetstyper. Varje objekt kan ha en navigeringsegenskap för varje relation som det deltar i. Med navigeringsegenskaper kan du navigera och hantera relationer i båda riktningarna, antingen returnera ett referensobjekt (om multipliciteten är antingen en eller noll eller en) eller en samling (om multipliciteten är många). Code First härleder relationer baserat på navigeringsegenskaperna som definierats för dina typer.

Förutom navigeringsegenskaper rekommenderar vi att du inkluderar egenskaper för främmande nyckel för de typer som representerar beroende objekt. Alla egenskaper med samma datatyp som huvudets primärnyckelegenskap och med ett namn som följer något av följande format representerar en sekundärnyckel för relationen: "<navigationsegenskapens namn><huvudets primärnyckelegenskap>", "<huvudklassens namn><primärnyckelegenskap>" eller "<huvudets primärnyckelegenskap>". Om flera matchningar hittas ges prioritet i den ordning som anges ovan. Identifiering av främmande nyckel är inte skiftlägeskänslig. När en sekundärnyckelegenskap identifieras härleder Code First relationens multiplicitet baserat på den främmande nyckelns nullbarhet. Om egenskapen är null kan relationen registreras som valfri. annars registreras relationen efter behov.

Om en främmande nyckel på den beroende entiteten inte är nullbar, ställer Code First in kaskadborttagning för relationen. Om en sekundärnyckel på den beroende entiteten är null, anger Code First inte kaskadborttagning för relationen och när huvudkontot tas bort anges den externa nyckeln till null. Multiplicitets- och kaskadborttagningsbeteendet som identifieras av konventionen kan åsidosättas med hjälp av fluent API.

I följande exempel används navigeringsegenskaperna och en sekundärnyckel för att definiera relationen mellan klasserna Avdelning och Kurs.

public class Department
{
    // Primary key
    public int DepartmentID { get; set; }
    public string Name { get; set; }

    // Navigation property
    public virtual ICollection<Course> Courses { get; set; }
}

public class Course
{
    // Primary key
    public int CourseID { get; set; }

    public string Title { get; set; }
    public int Credits { get; set; }

    // Foreign key
    public int DepartmentID { get; set; }

    // Navigation properties
    public virtual Department Department { get; set; }
}

Konvention för komplexa typer

När Code First identifierar en klassdefinition där det inte går att härleda en primärnyckel och ingen primärnyckel registreras via dataanteckningar eller fluent-API:et registreras typen automatiskt som en komplex typ. Komplex typidentifiering kräver också att typen inte har egenskaper som refererar till entitetstyper och inte refereras från en samlingsegenskap på en annan typ. Med tanke på följande klassdefinitioner skulle Code First härleda att Information är en komplex typ eftersom den inte har någon primärnyckel.

public partial class OnsiteCourse : Course
{
    public OnsiteCourse()
    {
        Details = new Details();
    }

    public Details Details { get; set; }
}

public class Details
{
    public System.DateTime Time { get; set; }
    public string Location { get; set; }
    public string Days { get; set; }
}

Anslutningssträngskonvention

Information om de konventioner som DbContext använder för att identifiera anslutningen som ska användas finns i Anslutningar och modeller.

Ta bort konventioner

Du kan ta bort någon av de konventioner som definierats i namnområdet System.Data.Entity.ModelConfiguration.Conventions. Följande exempel tar bort PluralizingTableNameConvention.

public class SchoolEntities : DbContext
{
     . . .

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        // Configure Code First to ignore PluralizingTableName convention
        // If you keep this convention, the generated tables  
        // will have pluralized names.
        modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
    }
}

Anpassade konventioner

Anpassade konventioner stöds i EF6 och senare. Mer information finns i De första konventionerna för anpassad kod.