Partager via

Procédure : Mapper des hiérarchies d’héritage

  • Article

Pour implémenter un mappage d’héritage dans LINQ, vous devez spécifier les attributs et les propriétés d’attribut sur la classe racine de la hiérarchie d’héritage, comme décrit dans les étapes suivantes. Les développeurs qui utilisent Visual Studio peuvent utiliser le Concepteur Objet Relationnel pour mapper les hiérarchies d’héritage. Consultez Guide pratique pour configurer l’héritage à l’aide du Concepteur O/R.

Notes

Les sous-classes ne requièrent pas de propriétés ni d'attributs spéciaux. Notez surtout que les sous-classes n'ont pas l'attribut TableAttribute.

Pour mapper une hiérarchie d'héritage

  1. Ajoutez l'attribut TableAttribute à la classe racine.

  2. Ajoutez-lui également un attribut InheritanceMappingAttribute pour chaque classe dans la structure hiérarchique.

  3. Pour chaque attribut InheritanceMappingAttribute, définissez une propriété Code.

    Cette propriété contient une valeur qui apparaît dans la table de base de données dans la colonne IsDiscriminator pour indiquer à quelle classe ou sous-classe appartient cette ligne de données.

  4. Pour chaque attribut InheritanceMappingAttribute, ajoutez également une propriété Type.

    Cette propriété contient une valeur qui spécifie la classe ou la sous-classe que la valeur de clé désigne.

  5. Ajoutez une propriété InheritanceMappingAttribute à un seul des attributs IsDefault.

    Cette propriété sert à désigner un mappage de secours quand la valeur de discriminateur de la table de base de données ne correspond à aucune valeur Code dans les mappages d’héritage.

  6. Ajoutez une propriété IsDiscriminator pour un attribut ColumnAttribute.

    Cette propriété signifie qu'il s'agit de la colonne qui contient la valeur Code.

Exemple

Notes

Si vous utilisez Visual Studio, vous pouvez utiliser le Concepteur Objet Relationnel pour configurer l’héritage. Consultez Guide pratique pour configurer l’héritage à l’aide du Concepteur O/R.

Dans l’exemple de code suivant, Vehicle est défini comme classe racine. Les étapes précédentes ont été implémentées pour décrire la hiérarchie de LINQ.

[Table]
[InheritanceMapping(Code = "C", Type = typeof(Car))]
[InheritanceMapping(Code = "T", Type = typeof(Truck))]
[InheritanceMapping(Code = "V", Type = typeof(Vehicle),
    IsDefault = true)]
public class Vehicle
{
    [Column(IsDiscriminator = true)]
    public string DiscKey;
    [Column(IsPrimaryKey = true)]
    public string VIN;
    [Column]
    public string MfgPlant;
}
public class Car : Vehicle
{
    [Column]
    public int TrimCode;
    [Column]
    public string ModelName;
}

public class Truck : Vehicle
{
    [Column]
    public int Tonnage;
    [Column]
    public int Axles;
}

<Table()> _
<InheritanceMapping(Code:="C", Type:=GetType(Car))> _
<InheritanceMapping(Code:="T", Type:=GetType(Truck))> _
<InheritanceMapping(Code:="V", Type:=GetType(Vehicle), _
    IsDefault:=True)> _
Public Class Vehicle
    <Column(IsDiscriminator:=True)> _
    Private DiscKey As String
    <Column(IsPrimaryKey:=True)> _
    Private VIN As String
    <Column()> _
    Private MfgPlant As String
End Class

Public Class Car
    Inherits Vehicle
    <Column()> _
    Private TrimCode As Integer
    <Column()> _
    Private ModelName As String
End Class

Public Class Truck
    Inherits Vehicle
    <Column()> _
    Private Tonnage As Integer
    <Column()> _
    Private Axles As Integer
End Class

Voir aussi