Condividi tramite

Procedura: eseguire il mapping di gerarchie di ereditarietà

  • Articolo

Per implementare il mapping di ereditarietà in LINQ, è necessario specificare gli attributi e le relative proprietà sulla classe radice della gerarchia di ereditarietà, come descritto nei passaggi seguenti. Gli sviluppatori che usano Visual Studio possono usare Object Relational Designer per eseguire il mapping delle gerarchie di ereditarietà. Vedere Procedura: configurare l'ereditarietà tramite Object Relational Designer.

Nota

Non sono richiesti attributi o proprietà speciali sulle sottoclassi. Notare, in particolare, che le sottoclassi non dispongono dell'attributo TableAttribute.

Per eseguire il mapping di una gerarchia di ereditarietà

  1. Aggiungere l'attributo TableAttribute alla classe radice.

  2. Aggiungere inoltre alla classe radice un attributo InheritanceMappingAttribute per ogni classe nella struttura gerarchica.

  3. Per ogni attributo InheritanceMappingAttribute definire una proprietà Code.

    Questa proprietà contiene un valore che viene visualizzato nella colonna IsDiscriminator della tabella di database per indicare la classe o sottoclasse a cui appartiene questa riga di dati.

  4. Per ogni attributo InheritanceMappingAttribute aggiungere inoltre una proprietà Type.

    Questa proprietà contiene un valore che specifica a quale classe o sottoclasse corrisponde il valore della chiave.

  5. Aggiungere una proprietà InheritanceMappingAttribute solo a uno degli attributi IsDefault.

    Questa proprietà viene usata per definire un mapping di fallback quando il valore discriminante dalla tabella di database non corrisponde ad alcun valore Code nei mapping di ereditarietà.

  6. Aggiungere una proprietà IsDiscriminator per un attributo ColumnAttribute.

    Questa proprietà indica che la colonna specificata contiene il valore Code.

Esempio

Nota

Se si usa Visual Studio, è possibile usare Object Relational Designer per configurare l'ereditarietà. Vedere Procedura: configurare l'ereditarietà tramite Object Relational Designer

Nell'esempio di codice seguente Vehicle viene definita come classe radice e i passaggi precedenti sono stati implementati per descrivere la gerarchia per 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

Vedi anche