InheritanceMappingAttribute Classe

Definizione

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

Ereditarietà

Object

Attribute

InheritanceMappingAttribute

Attributi

AttributeUsageAttribute

Esempio

In questo esempio viene illustrato il mapping di ereditarietà per una gerarchia in cui la classe con mapping superiore (Shape) è astratta.

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

Nell'esempio seguente viene illustrata l'inclusione di classi non mappate. È possibile inserire classi non mappate in qualsiasi punto della gerarchia.

// 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

Commenti

Uno InheritanceMappingAttribute viene specificato per ogni classe mappata.

Quando si esegue il mapping delle gerarchie di ereditarietà, tenere presente quanto segue:

• È necessario eseguire il mapping di tutte le classi in una gerarchia a una singola tabella.

• La tabella per una gerarchia di ereditarietà deve essere dichiarata nel tipo mappato che si trova all'inizio della gerarchia. Non è possibile specificare gli attributi di tabella o mapping in una classe derivata dalla classe principale.

• È possibile usare un'interfaccia in una gerarchia, ma LINQ non esegue il mapping.

• È possibile ignorare una classe nella gerarchia quando si esegue il mapping delle classi, ma è possibile eseguire query solo su classi mappate.

Per la materializzazione corretta, i valori del codice discriminatorio devono essere univoci e corrispondere ai valori nel database. Una riga con un valore di codice discriminatorio che non corrisponde esattamente (anche tramite maiuscole/minuscole) crea un'istanza della classe usando IsDefault impostato su true.

Costruttori

Proprietà

Metodi

Implementazioni dell'interfaccia esplicita

Si applica a