InheritanceMappingAttribute Classe

Definição

public ref class InheritanceMappingAttribute sealed : Attribute

[System.AttributeUsage(System.AttributeTargets.Class, AllowMultiple=true, Inherited=false)]
public sealed class InheritanceMappingAttribute : Attribute

[<System.AttributeUsage(System.AttributeTargets.Class, AllowMultiple=true, Inherited=false)>]
type InheritanceMappingAttribute = class
    inherit Attribute

Public NotInheritable Class InheritanceMappingAttribute
Inherits Attribute

Herança

Object

Attribute

InheritanceMappingAttribute

Atributos

AttributeUsageAttribute

Exemplos

Este exemplo mostra o mapeamento de herança para uma hierarquia onde a classe top, mapeada (Shape) é abstrata.

public enum ShapeType
{
    Square = 0, Circle = 1
}
[Table(Name = "Shape")]
[InheritanceMapping(Code = ShapeType.Square, Type = typeof(Square),
    IsDefault = true)]
[InheritanceMapping(Code = ShapeType.Circle, Type = typeof(Circle))]

abstract public class Shape
{
    [Column(IsDiscriminator = true)]
    public ShapeType ShapeType = 0;
}

public class Square : Shape
{
    [Column]
    public int Side = 0;
}
public class Circle : Shape
{
    [Column]
    public int Radius = 0;
}

Public Enum ShapeType As Integer
    Square = 0
    Circle = 1
End Enum

<Table(Name:="Shape")> _
<InheritanceMapping(Code:=ShapeType.Square, Type:=GetType(Square), _
    IsDefault:=True)> _
<InheritanceMapping(Code:=ShapeType.Circle, Type:=GetType(Circle))> _
Public MustInherit Class Shape
    <Column(IsDiscriminator:=True)> _
        Public ShapeType As ShapeType = 0
End Class

Public Class Square
    Inherits Shape
    <Column()> _
    Public Side As Integer = 0
End Class

Public Class Circle
    Inherits Shape
    <Column()> _
    Public Radius As Integer = 0
End Class

O exemplo seguinte mostra a inclusão de classes não mapeadas. Podes colocar classes não mapeadas em qualquer parte da hierarquia.

// Unmapped and not queryable.
class A {  }

// Mapped and queryable.
[Table]
[InheritanceMapping(Code = "B", Type = typeof(B),
IsDefault = true)]
[InheritanceMapping(Code = "D", Type = typeof(D))]
class B: A {  }

// Unmapped and not queryable.
class C: B {  }

// Mapped and queryable.
class D: C {  }

// Unmapped and not queryable.
class E: D {  }

' Unmapped and not queryable.
Class A
End Class

' Mapped and queryable.
<Table()> _
<InheritanceMapping(Code:="B", Type:=GetType(B), _
IsDefault:=True)> _
<InheritanceMapping(Code:="D", Type:=GetType(D))> _
Class B
    Inherits A
End Class

' Unmapped and not queryable.
Class C
    Inherits B
End Class

' Mapped and queryable.
Class D
    Inherits C
End Class

' Unmapped and not queryable.
Class E
    Inherits D
End Class

Observações

Um InheritanceMappingAttribute é especificado por classe mapeada.

Note o seguinte ao mapear hierarquias de herança:

• Todas as classes numa hierarquia devem ser mapeadas para uma única tabela.

• A tabela para uma hierarquia de herança deve ser declarada no tipo mapeado que está no topo da hierarquia. Não pode especificar os atributos da tabela ou do mapeamento numa classe que seja derivado da classe principal.

• Podes usar uma interface numa hierarquia, mas o LINQ não a mapeia.

• Podes saltar uma classe na hierarquia ao mapear classes, mas podes consultar apenas contra classes mapeadas.

Para uma materialização correta, os valores do código discriminador devem ser únicos e corresponder aos valores da base de dados. Uma linha com um valor de código discriminador que não corresponde exatamente (nem mesmo por casing) instancia a classe usando IsDefault definir para true.