Partager via


Conventions Code First

Code First vous permet de décrire un modèle à l’aide de classes C# ou Visual Basic .NET. La forme de base du modèle est détectée à l’aide de conventions. Les conventions sont un ensemble de règles utilisées pour configurer automatiquement un modèle conceptuel selon des définitions de classe lors de l'utilisation de Code First. Les conventions sont définies dans l’espace de noms System.Data.Entity.ModelConfiguration.Conventions.

Vous pouvez configurer davantage votre modèle à l’aide d’annotations de données ou de l’API Fluent. La priorité est donnée à la configuration via l’API Fluent suivie d’annotations de données, puis de conventions. Pour plus d’informations, consultez Annotations de données, API Fluent – Relations, API Fluent – Types et Propriétés et API Fluent avec VB.NET.

Une liste détaillée des conventions Code First est disponible dans la documentation de l’API. Cette rubrique fournit une vue d’ensemble des conventions utilisées par Code First.

Découverte du type

Quand vous utilisez le développement Code First, vous commencez généralement par écrire des classes .NET Framework qui définissent votre modèle (domaine) conceptuel. En plus de définir les classes, vous devez également laisser DbContext savoir quels types vous souhaitez inclure dans le modèle. Pour ce faire, vous définissez une classe de contexte qui dérive de dbContext et expose propriétés DbSet pour les types que vous souhaitez faire partie du modèle. Le code First inclut ces types et extrait également tous les types référencés, même si les types référencés sont définis dans un autre assemblage.

Si vos types participent à une hiérarchie d’héritage, il suffit de définir une propriété DbSet pour la classe de base, et les types dérivés sont automatiquement inclus, s’ils se trouvent dans le même assemblage que la classe de base.

Dans l’exemple suivant, il n’existe qu’une seule propriété DbSet définie sur la classe SchoolEntities (Départements). Code First utilise cette propriété pour découvrir et extraire des types référencés.

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

Si vous souhaitez exclure un type du modèle, utilisez l’attribut NotMapped ou l’API Fluent DbModelBuilder.Ignore.

modelBuilder.Ignore<Department>();

Convention de clé primaire

Code First déduit qu’une propriété est une clé primaire si une propriété d’une classe est nommée « ID » (pas sensible à la casse) ou le nom de classe suivi de « ID ». Si le type de la propriété de clé primaire est numérique ou GUID, il est configuré en tant que colonne d’identité.

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

    . . .  

}

Convention de relation

Dans Entity Framework, les propriétés de navigation offrent un moyen de parcourir une relation entre deux types d’entités. Chaque objet peut avoir une propriété de navigation pour chaque relation à laquelle il participe. Les propriétés de navigation permettent de parcourir et de gérer les relations dans les deux directions, en retournant un objet de référence (si la multiplicité est un ou zéro-à-un) ou une collection (si la multiplicité est plusieurs). Code First déduit les relations basées sur les propriétés de navigation définies sur vos types.

En plus des propriétés de navigation, nous vous recommandons d’inclure des propriétés de clé étrangère sur les types qui représentent des objets dépendants. Toute propriété ayant le même type de données que la propriété de clé primaire principale et avec un nom qui suit l’un des formats suivants représente une clé étrangère pour la relation : <nom de propriété de navigation><nom de propriété de clé primaire principal>', '<nom de classe principale><nom de propriété de clé primaire>', ou '<nom de propriété de clé primaire principale>'. Si plusieurs correspondances sont trouvées, la priorité est donnée dans l’ordre indiqué ci-dessus. La détection de clé étrangère n’est pas sensible à la casse. Lorsqu’une propriété de clé étrangère est détectée, Code First déduit la multiplicité de la relation en fonction de la capacité à recevoir la valeur Null de la clé étrangère. Si la propriété peut accepter la valeur Null, la relation est inscrite comme facultative ; sinon, la relation est inscrite en fonction des besoins.

Si une clé étrangère sur l’entité dépendante ne peut pas accepter la valeur Null, Code First définit la suppression en cascade sur la relation. Si une clé étrangère sur l’entité dépendante ne peut pas accepter la valeur Null, Code First ne définit pas de suppression en cascade sur la relation, et lorsque le principal est supprimé, la clé étrangère est définie sur Null. La multiplicité et le comportement de suppression en cascade détectés par convention peuvent être substitués à l’aide de l’API Fluent.

Dans l’exemple suivant, les propriétés de navigation et une clé étrangère sont utilisées pour définir la relation entre les classes Department et Course.

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

Remarque

Si vous avez plusieurs relations entre les mêmes types (par exemple, supposons que vous définissez les classes personne et Book , où la classe Person contient les ReviewedBooks et AuthoredBooks propriétés de navigation et la classe Book contient le Créez et réviseur propriétés de navigation), vous devez configurer manuellement les relations à l’aide d’annotations de données ou de l’API Fluent. Pour plus d’informations, consultez Annotations de données : Relations et API Fluent : Relations.

Convention sur les types complexes

Lorsque Code First découvre une définition de classe où une clé primaire ne peut pas être déduite et qu’aucune clé primaire n’est inscrite par le biais d’annotations de données ou de l’API Fluent, le type est automatiquement inscrit en tant que type complexe. La détection de type complexe nécessite également que le type ne possède pas de propriétés qui référencent des types d’entités et qu’il n’est pas référencé à partir d’une propriété de collection sur un autre type. Étant donné les définitions de classe suivantes, Code First déduit que Details est un type complexe, car il n’a pas de clé primaire.

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

Convention de chaînes de connexion

Pour en savoir plus sur les conventions utilisées par DbContext pour découvrir la connexion à utiliser, consultez Connexions et modèles.

Suppression des conventions

Vous pouvez supprimer les conventions définies dans l’espace de noms System.Data.Entity.ModelConfiguration.Conventions. L’exemple suivant supprime 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>();
    }
}

Conventions personnalisées

Les conventions personnalisées sont prises en charge dans EF6. Pour plus d’informations, consultez Conventions Code First personnalisées.