Compartilhar via

Como: mapear hierarquias de herança

  • Artigo

Para implementar o mapeamento de herança no LINQ, será necessário especificar os atributos e as propriedades de atributo na classe raiz da hierarquia de herança conforme descrito nas etapas a seguir. Desenvolvedores que utilizam o Visual Studio poderão usar o Object Relational Designer para mapear as hierarquias de herança. Consulte Como configurar a herança usando o Object Relational Designer.

Observação

Qualquer atributo ou propriedade de especial são necessários nas subclasses. Observe que as subclasses especialmente não têm o atributo de TableAttribute .

Para mapear uma hierarquia de herança

  1. Adicione o atributo de TableAttribute a classe raiz.

  2. Também à classe raiz, adicione um atributo de InheritanceMappingAttribute para cada classe na estrutura da hierarquia.

  3. Para cada atributo de InheritanceMappingAttribute , defina uma propriedade de Code .

    Esta propriedade contém um valor que pareça na tabela de base de dados na coluna de IsDiscriminator para indicar que a classe ou da subclasse esta linha de dados pertencem.

  4. Para cada atributo de InheritanceMappingAttribute , também adicionar uma propriedade de Type .

    Esta propriedade contém um valor que especifica que a classe ou da subclasse o valor da chave significa.

  5. Em apenas um dos atributos de InheritanceMappingAttribute , adicione uma propriedade de IsDefault .

    Essa propriedade serve para designar um mapeamento de fallback quando o valor discriminador da tabela do banco de dados não corresponder a nenhum valor de Code nos mapeamentos de herança.

  6. Adicione uma propriedade de IsDiscriminator para um atributo de ColumnAttribute .

    Esta propriedade significa que esta é a coluna que contém o valor de Code .

Exemplo

Observação

Se estiver usando o Visual Studio, poderá usar o Object Relational Designer para configurar a herança. Consulte Como configurar a herança usando o Object Relational Designer

No exemplo de código a seguir, Vehicle é definido como a classe raiz e as etapas anteriores foram implementadas para descrever a hierarquia para 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

Confira também