Procedura: mappare le gerarchie di ereditarietà (LINQ to SQL)

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 utilizzano Visual Studio possono adoperare Object Relational Designer per eseguire il mapping delle gerarchie di ereditarietà.

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à IsDefault solo a uno degli attributi InheritanceMappingAttribute.

   Questa proprietà viene utilizzata 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 utilizza Visual Studio, è possibile adoperare Object Relational Designer per configurare l'ereditarietà.

Nell'esempio di codice seguente Vehicle viene definita come classe radice e i passaggi precedenti sono stati implementati per descrivere la gerarchia per LINQ. Nella figura seguente vengono illustrate queste relazioni.

<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

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

Vedere anche

Concetti

Supporto dell'ereditarietà (LINQ to SQL)

Altre risorse

Procedura: personalizzare le classi di entità mediante l'editor del codice (LINQ to SQL)