Share via

Anvisningar: Mappa databasrelationer

  • Artikel

Du kan koda som egenskapsreferenser i entitetsklassen alla datarelationer som alltid kommer att vara desamma. I Northwind-exempeldatabasen finns det till exempel alltid en relation i modellen mellan kunder och deras beställningar eftersom kunderna vanligtvis gör beställningar.

LINQ till SQL definierar ett AssociationAttribute attribut för att representera sådana relationer. Det här attributet används tillsammans med typerna EntitySet<TEntity> och EntityRef<TEntity> för att representera vad som skulle vara en sekundärnyckelrelation i en databas. Mer information finns i avsnittet Associationsattribut i Attributbaserad mappning.

Kommentar

Egenskapsvärdena AssociationAttribute och ColumnAttribute Storage är skiftlägeskänsliga. Kontrollera till exempel att värden som används i attributet för egenskapen AssociationAttribute.Storage matchar fallet för motsvarande egenskapsnamn som används någon annanstans i koden. Detta gäller för alla .NET-programmeringsspråk, även de som vanligtvis inte är skiftlägeskänsliga, inklusive Visual Basic. Mer information om egenskapen Storage finns i DataAttribute.Storage.

De flesta relationer är en-till-många, som i exemplet senare i det här avsnittet. Du kan också representera en-till-en- och många-till-många-relationer på följande sätt:

  • En-till-en: Representera den här typen av relation genom att inkludera EntitySet<TEntity> på båda sidor.

    Överväg till exempel en Customer-SecurityCode relation som skapats så att kundens säkerhetskod inte hittas i Customer tabellen och endast kan nås av behöriga personer.

  • Många-till-många: I många-till-många-relationer bildas ofta den primära nyckeln i länktabellen (även kallad kopplingstabellen) av en sammansatt av sekundärnycklarna från de andra två tabellerna.

    Överväg till exempel en Employee-Project många-till-många-relation som skapas med hjälp av länktabellen EmployeeProject. LINQ till SQL kräver att en sådan relation modelleras med hjälp av tre klasser: Employee, Projectoch EmployeeProject. I det här fallet kan det verka som om en ändring av relationen mellan en Employee och en Project kräver en uppdatering av primärnyckeln EmployeeProject. Den här situationen modelleras dock bäst som att ta bort en befintlig EmployeeProject och skapa en ny EmployeeProject.

    Kommentar

    Relationer i relationsdatabaser modelleras vanligtvis som sekundärnyckelvärden som refererar till primära nycklar i andra tabeller. Om du vill navigera mellan dem associerar du uttryckligen de två tabellerna med hjälp av en relationskopplingsåtgärd.

    Objekt i LINQ till SQL refererar å andra sidan till varandra med hjälp av egenskapsreferenser eller samlingar med referenser som du navigerar med hjälp av punkt notation.

Exempel 1

I följande exempel Customer har klassen en egenskap som deklarerar relationen mellan kunder och deras beställningar. Egenskapen Orders är av typen EntitySet<TEntity>. Den här typen betyder att den här relationen är en-till-många (en kund till många beställningar). Egenskapen OtherKey används för att beskriva hur den här associationen utförs, nämligen genom att ange namnet på egenskapen i den relaterade klassen som ska jämföras med den här. I det här exemplet jämförs CustomerID egenskapen, precis som en databaskoppling skulle jämföra kolumnvärdet.

Kommentar

Om du använder Visual Studio kan du använda objektrelationsdesignern för att skapa en association mellan klasser.

[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

Exempel 2

Du kan också vända på situationen. I stället för att använda Customer klassen för att beskriva associationen mellan kunder och beställningar kan du använda Order klassen. Klassen Order använder EntityRef<TEntity> typen för att beskriva relationen tillbaka till kunden, som i följande kodexempel.

Kommentar

Klassen EntityRef<TEntity> stöder uppskjuten inläsning. Mer information finns iUppskjuten kontra Omedelbar inläsning.

[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

Se även