Share via

Procedure: Databaserelaties toewijzen

  • Artikel

U kunt coderen als eigenschapsverwijzingen in uw entiteitsklasse, alle gegevensrelaties die altijd hetzelfde zijn. In de voorbeelddatabase Northwind, bijvoorbeeld omdat klanten doorgaans orders plaatsen, is er altijd een relatie in het model tussen klanten en hun orders.

LINQ naar SQL definieert een AssociationAttribute kenmerk om dergelijke relaties aan te geven. Dit kenmerk wordt samen met de EntitySet<TEntity> en EntityRef<TEntity> typen gebruikt om aan te geven wat een refererende-sleutelrelatie in een database zou zijn. Zie de sectie Koppelingskenmerk van kenmerktoewijzing op basis van kenmerken voor meer informatie.

Notitie

De eigenschapswaarden AssociationAttribute en ColumnAttribute Storage zijn hoofdlettergevoelig. Zorg er bijvoorbeeld voor dat waarden die worden gebruikt in het kenmerk voor de eigenschap AssociationAttribute.Storage overeenkomen met het geval voor de bijbehorende eigenschapsnamen die elders in de code worden gebruikt. Dit geldt voor alle .NET-programmeertalen, zelfs voor programmeertalen die doorgaans niet hoofdlettergevoelig zijn, waaronder Visual Basic. Zie voor meer informatie over de eigenschap DataAttribute.StorageStorage.

De meeste relaties zijn een-op-veel, zoals in het voorbeeld verderop in dit onderwerp. U kunt ook een-op-een- en veel-op-veel-relaties als volgt vertegenwoordigen:

  • Een-op-een: vertegenwoordig dit soort relatie door aan beide zijden op te geven EntitySet<TEntity> .

    Denk bijvoorbeeld aan een Customer-SecurityCode relatie die is gemaakt, zodat de beveiligingscode van de klant niet in de Customer tabel wordt gevonden en alleen toegankelijk is voor geautoriseerde personen.

  • Veel-op-veel: In veel-op-veel-relaties wordt de primaire sleutel van de koppelingstabel (ook wel de verbindingstabel genoemd) vaak gevormd door een samengestelde van de refererende sleutels uit de andere twee tabellen.

    Denk bijvoorbeeld aan een Employee-Project veel-op-veel-relatie die wordt gevormd met behulp van een koppelingstabel.EmployeeProject LINQ naar SQL vereist dat een dergelijke relatie wordt gemodelleerd met behulp van drie klassen: Employee, Projecten EmployeeProject. In dit geval kan het wijzigen van de relatie tussen een Employee en een Project kan lijken om een update van de primaire sleutel EmployeeProjectte vereisen. Deze situatie is echter het beste gemodelleerd als het verwijderen van een bestaande EmployeeProject en het maken van een nieuwe EmployeeProject.

    Notitie

    Relaties in relationele databases worden doorgaans gemodelleerd als refererende sleutelwaarden die verwijzen naar primaire sleutels in andere tabellen. Als u tussen deze tabellen wilt navigeren, koppelt u de twee tabellen expliciet met behulp van een relationele join-bewerking .

    Objecten in LINQ naar SQL verwijzen daarentegen naar elkaar met behulp van eigenschapsverwijzingen of verzamelingen verwijzingen die u navigeert met behulp van punt notatie.

Voorbeeld 1

In het volgende een-op-veel-voorbeeld heeft de Customer klasse een eigenschap die de relatie tussen klanten en hun orders declareert. De Orders eigenschap is van het type EntitySet<TEntity>. Dit type geeft aan dat deze relatie een-op-veel is (één klant tot veel orders). De OtherKey eigenschap wordt gebruikt om te beschrijven hoe deze koppeling wordt bereikt, namelijk door de naam van de eigenschap in de gerelateerde klasse op te geven die moet worden vergeleken met deze. In dit voorbeeld wordt de CustomerID eigenschap vergeleken, net zoals een databasedeelname die kolomwaarde vergelijkt.

Notitie

Als u Visual Studio gebruikt, kunt u de Object Relational Designer gebruiken om een koppeling tussen klassen te maken.

[Table(Name = "Customers")]
public partial class Customer
{
    [Column(IsPrimaryKey = true)]
    public string CustomerID;
    // ...
    private EntitySet<Order> _Orders;
    [Association(Storage = "_Orders", OtherKey = "CustomerID")]
    public EntitySet<Order> Orders
    {
        get { return this._Orders; }
        set { this._Orders.Assign(value); }
    }
}

<Table(Name:="Customers")> _
Public Class Customer
    <Column(IsPrimaryKey:=True)> _
    Public CustomerID As String
    ' ...
    Private _Orders As EntitySet(Of Order)
    <Association(Storage:="_Orders", OtherKey:="CustomerID")> _
    Public Property Orders() As EntitySet(Of Order)
        Get
            Return Me._Orders
        End Get
        Set(ByVal value As EntitySet(Of Order))
            Me._Orders.Assign(value)
        End Set
    End Property
End Class

Voorbeeld 2

U kunt de situatie ook omkeren. In plaats van de Customer klasse te gebruiken om de koppeling tussen klanten en orders te beschrijven, kunt u de Order klasse gebruiken. De Order klasse gebruikt het EntityRef<TEntity> type om de relatie terug te beschrijven naar de klant, zoals in het volgende codevoorbeeld.

Notitie

De EntityRef<TEntity> klasse ondersteunt uitgestelde laadtijden. Zie Deferred versus Direct laden voor meer informatie.

[Table(Name = "Orders")]
public class Order
{
    [Column(IsPrimaryKey = true)]
    public int OrderID;
    [Column]
    public string CustomerID;
    private EntityRef<Customer> _Customer;
    [Association(Storage = "_Customer", ThisKey = "CustomerID")]
    public Customer Customer
    {
        get { return this._Customer.Entity; }
        set { this._Customer.Entity = value; }
    }
}

<Table(Name:="Orders")> _
Public Class Order
    <Column(IsPrimaryKey:=True)> _
    Public OrderID As Integer
    <Column()> _
    Public CustomerID As String
    Private _Customer As EntityRef(Of Customer)
    <Association(Storage:="Customer", ThisKey:="CustomerID")> _
    Public Property Customer() As Customer
        Get
            Return Me._Customer.Entity
        End Get
        Set(ByVal value As Customer)
            Me._Customer.Entity = value
        End Set
    End Property
End Class

Zie ook