Vorgehensweise: Zuordnen von Datenbankbeziehungen (LINQ to SQL)

Sie können in Ihrer Entitätsklasse alle Datenbeziehungen als Eigenschaftenverweise codieren, die stets gleich bleiben. Da Kunden in der Beispieldatenbank Northwind typischerweise Bestellungen übermitteln, besteht im Modell stets eine Beziehung zwischen Kunden und deren Bestellungen.

LINQ to SQL definiert ein AssociationAttribute-Attribut zur Unterstützung der Darstellung solcher Beziehungen. Dieses Attribut wird zusammen mit dem EntitySet<TEntity>-Typ und dem EntityRef<TEntity>-Typ verwendet, um eine Fremdschlüsselbeziehung in einer Datenbank darzustellen. Weitere Informationen finden Sie im Abschnitt zum Association-Attribut unter Attributbasierte Zuordnung (LINQ to SQL).

Hinweis

Bei den "Storage"-Eigenschaftswerten "AssociationAttribute" und "ColumnAttribute" wird die Groß- und Kleinschreibung beachtet.Stellen Sie beispielsweise sicher, dass die im Attribut für die "AssociationAttribute.Storage"-Eigenschaft verwendeten Werte in der Schreibung mit den entsprechenden Eigenschaftsnamen an anderer Stelle im Code übereinstimmen.Dies gilt für alle .NET-Programmiersprachen, auch für diejenigen, bei denen die Groß- und Kleinschreibung nicht beachtet wird, darunter Visual Basic.Weitere Informationen über die "Storage"-Eigenschaft finden Sie unter DataAttribute.Storage.

Die meisten Beziehungen sind 1:n, wie im Beispiel weiter unten in diesem Abschnitt. Sie können auch 1:1- und n:n-Beziehungen wie folgt darstellen:

• 1:1-Beziehung: Stellen Sie diese Art von Beziehung dar, indem Sie EntitySet<TEntity> auf beiden Seiten einschließen.

  Stellen Sie sich beispielsweise eine Customer-SecurityCode-Beziehung vor, die so erstellt wurde, dass der Sicherheitscode des Kunden nicht in der Customer-Tabelle gefunden wird, und die nur von autorisierten Personen genutzt werden kann.

• n:n-Beziehung: Bei Beziehungen dieser Art wird der Primärschlüssel der Verbindungstabelle (wird auch als Verknüpfungstabelle bezeichnet) häufig durch eine Kombination der Fremdschlüssel aus den beiden anderen Tabellen gebildet.

  Gehen Sie zum Beispiel von einer Employee-Project-m:n-Beziehung aus, die mit der Verknüpfungstabelle EmployeeProject erstellt wurde. LINQ to SQL erfordert, dass eine solche Beziehung unter Verwendung von drei Klassen modelliert wird: Employee, Project und EmployeeProject. In diesem Fall kann beim Ändern der Beziehung zwischen einem Employee und einem Project das Update des Primärschlüssels EmployeeProject erfordern. Diese Situation lässt sich jedoch durch Löschen eines vorhandenen EmployeeProject und Erstellen eines neuen EmployeeProject am besten modellieren.

  Hinweis

  Beziehungen in relationalen Datenbanken werden typischerweise als Fremdschlüsselwerte modelliert, die sich auf Fremdschlüssel in anderen Dateien beziehen.Um zwischen ihnen zu navigieren, ordnen Sie die beiden Tabellen explizit zu, indem Sie eine relationale Joinoperation verwenden. Objekte in LINQ to SQL verweisen andererseits aufeinander, indem sie Eigenschaftenverweise oder Verweisauflistungen verwenden, in denen Sie mithilfe der dot-Schreibweise navigieren.

Beispiel

Im folgenden 1:n-Beispiel verfügt die Customer-Klasse über eine Eigenschaft, die die Beziehung zwischen Kunden und deren Bestellungen deklariert. Die Orders-Eigenschaft ist vom Typ EntitySet<TEntity>. Dieser Typ bedeutet, dass diese Beziehung 1:n (ein Kunde zu vielen Bestellungen) ist. Die OtherKey-Eigenschaft wird zur Beschreibung der Zuweisung verwendet, d. h. durch Angeben des Namens der Eigenschaft in der zugehörigen Klasse, die mit dieser verglichen werden soll. In diesem Beispiel wird die CustomerID-Eigenschaft so verglichen, wie ein Datenbankjoin den Spaltenwert vergleicht.

Hinweis
Wenn Sie Visual Studio verwenden, können Sie mit O/R-Designer eine Zuordnung zwischen den Klassen herstellen.

<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

[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); }
    }
}

Sie können die Situation auch umkehren. Anstelle der Verwendung der Customer-Klasse zur Beschreibung der Zuordnung von Kunden und Bestellungen können Sie die Order-Klasse verwenden. Die Order-Klasse verwendet den EntityRef<TEntity>-Typ, um die Beziehung zurück zum Kunden zu beschreiben. Siehe hierzu das folgende Codebeispiel.

Hinweis
Die EntityRef<TEntity>-Klasse unterstützt verzögertes Laden.Weitere Informationen finden Sie unter Verzögertes und unmittelbares Laden (LINQ to SQL).

<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

[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; }
    }
}

Siehe auch

Konzepte

Das LINQ to SQL-Objektmodell

Weitere Ressourcen

Vorgehensweise: Anpassen von Entitätsklassen mithilfe des Code-Editors (LINQ to SQL)