Freigeben über

Das LINQ to SQL-Objektmodell

In LINQ to SQL wird ein Objektmodell, das in der Programmiersprache des Entwicklers ausgedrückt wird, dem Datenmodell einer relationalen Datenbank zugeordnet. Vorgänge zu den Daten werden dann nach dem Objektmodell durchgeführt.

In diesem Szenario geben Sie keine Datenbankbefehle (z. B INSERT. ) an die Datenbank aus. Stattdessen ändern Sie Werte und führen Methoden innerhalb des Objektmodells aus. Wenn Sie die Datenbank abfragen oder änderungen senden möchten, übersetzt LINQ to SQL Ihre Anforderungen in die richtigen SQL-Befehle und sendet diese Befehle an die Datenbank.

Screenshot des Linq-Objektmodells.

Die grundlegendsten Elemente im LINQ to SQL-Objektmodell und ihre Beziehung zu Elementen im relationalen Datenmodell werden in der folgenden Tabelle zusammengefasst:

LINQ to SQL-Objektmodell Relationales Datenmodell
Entitätsklasse Tabelle
Klassenmitglied Kolumne
Verein Fremdschlüsselbeziehung
Methode Gespeicherte Prozedur oder Funktion

Hinweis

In den folgenden Beschreibungen wird davon ausgegangen, dass Sie über grundlegende Kenntnisse des relationalen Datenmodells und der relationalen Regeln verfügen.

LINQ zu SQL Entitätsklassen und Datenbanktabellen

In LINQ to SQL wird eine Datenbanktabelle durch eine Entitätsklasse dargestellt. Eine Entitätsklasse ist wie jede andere Klasse, die Sie erstellen können, mit der Ausnahme, dass Sie die Klasse mithilfe spezieller Informationen kommentieren, die die Klasse einer Datenbanktabelle ordnet. Sie erstellen diese Anmerkung, indem Sie ihrer Klassendeklaration wie im folgenden Beispiel ein benutzerdefiniertes Attribut (TableAttribute) hinzufügen:

Beispiel

[Table(Name = "Customers")]
public class Customerzz
{
    public string CustomerID;
    // ...
    public string City;
}

<Table(Name:="Customers")> _
Public Class Customer
    Public CustomerID As String
    ' ...
    Public City As String
End Class

Nur Als Tabellen deklarierte Klasseninstanzen (d. h. Entitätsklassen) können in der Datenbank gespeichert werden.

Weitere Informationen finden Sie im Abschnitt "Table Attribute" von Attribute-Based Mapping.

LINQ to SQL-Klassenmember und Datenbankspalten

Zusätzlich zum Zuordnen von Klassen zu Tabellen legen Sie Felder oder Eigenschaften fest, die Datenbankspalten darstellen sollen. Zu diesem Zweck definiert LINQ to SQL das ColumnAttribute Attribut wie im folgenden Beispiel:

Beispiel

[Table(Name = "Customers")]
public class Customer
{
    [Column(IsPrimaryKey = true)]
    public string CustomerID;
    [Column]
    public string City;
}

<Table(Name:="Customers")> _
Public Class Customer
    <Column(IsPrimaryKey:=True)> _
    Public CustomerID As String

    <Column()> _
    Public City As String
End Class

Nur Felder und Eigenschaften, die Spalten zugeordnet sind, werden beibehalten oder aus der Datenbank abgerufen. Diejenigen, die nicht als Spalten deklariert werden, werden als vorübergehende Teile Ihrer Anwendungslogik betrachtet.

Das ColumnAttribute Attribut verfügt über eine Vielzahl von Eigenschaften, die Sie zum Anpassen dieser Elemente verwenden können, die Spalten darstellen (z. B. das Entwerfen eines Elements als Darstellung einer Primärschlüsselspalte). Weitere Informationen finden Sie im Abschnitt "Column Attribute" von Attribute-Based Mapping.

LINQ zu SQL-Assoziationen und Datenbank-Fremdschlüsselbeziehungen

In LINQ to SQL stellen Sie Datenbankzuordnungen (z. B. Fremdschlüssel zu Primärschlüsselbeziehungen) dar, indem Sie das AssociationAttribute Attribut anwenden. Im folgenden Codesegment enthält die Order Klasse eine Customer Eigenschaft mit einem AssociationAttribute Attribut. Diese Eigenschaft und ihr Attribut stellen die Order Klasse mit einer Beziehung zur Klasse bereit Customer .

Das folgende Codebeispiel zeigt die Customer Eigenschaft aus der Order Klasse.

Beispiel

[Association(Name="FK_Orders_Customers", Storage="_Customer", ThisKey="CustomerID", IsForeignKey=true)]
public Customer Customer
{
    get
    {
        return this._Customer.Entity;
    }
    set
    {
        Customer previousValue = this._Customer.Entity;
        if (((previousValue != value)
                    || (this._Customer.HasLoadedOrAssignedValue == false)))
        {
            this.SendPropertyChanging();
            if ((previousValue != null))
            {
                this._Customer.Entity = null;
                previousValue.Orders.Remove(this);
            }
            this._Customer.Entity = value;
            if ((value != null))
            {
                value.Orders.Add(this);
                this._CustomerID = value.CustomerID;
            }
            else
            {
                this._CustomerID = default(string);
            }
            this.SendPropertyChanged("Customer");
        }
    }
}

<Association(Name:="FK_Orders_Customers", Storage:="_Customer", ThisKey:="CustomerID", IsForeignKey:=true)>  _
Public Property Customer() As Customer
    Get
        Return Me._Customer.Entity
    End Get
    Set
        Dim previousValue As Customer = Me._Customer.Entity
        If (((previousValue Is value)  _
                    = false)  _
                    OrElse (Me._Customer.HasLoadedOrAssignedValue = false)) Then
            Me.SendPropertyChanging
            If ((previousValue Is Nothing)  _
                        = false) Then
                Me._Customer.Entity = Nothing
                previousValue.Orders.Remove(Me)
            End If
            Me._Customer.Entity = value
            If ((value Is Nothing)  _
                        = false) Then
                value.Orders.Add(Me)
                Me._CustomerID = value.CustomerID
            Else
                Me._CustomerID = CType(Nothing, String)
            End If
            Me.SendPropertyChanged("Customer")
        End If
    End Set
End Property

Weitere Informationen finden Sie im Abschnitt zu Zuordnungsattributen unter Attributbasierte Zuordnung.

LINQ-zu-SQL-Methoden und Datenbank-gespeicherte Prozeduren

LINQ to SQL unterstützt gespeicherte Prozeduren und benutzerdefinierte Funktionen. In LINQ to SQL ordnen Sie diese von der Datenbank definierten Abstraktionen den Clientobjekten zu, sodass Sie über den Clientcode in einer stark typisierten Weise darauf zugreifen können. Die Methodensignaturen ähneln möglichst genau den Signaturen der in der Datenbank definierten Prozeduren und Funktionen. Sie können IntelliSense verwenden, um diese Methoden zu ermitteln.

Ein von einem Aufruf einer zugeordneten Prozedur zurückgegebener Ergebnissatz ist eine Auflistung mit strikter Typzuordnung.

LINQ to SQL ordnet gespeicherte Prozeduren und Funktionen mithilfe der Attribute FunctionAttribute und ParameterAttribute den Methoden zu. Methoden, die gespeicherte Prozeduren darstellen, werden von denen unterschieden, die benutzerdefinierte Funktionen durch die IsComposable Eigenschaft darstellen. Wenn diese Eigenschaft auf false (Standardeinstellung) festgelegt ist, stellt die Methode eine gespeicherte Prozedur dar. Wenn sie auf festgelegt trueist, stellt die Methode eine Datenbankfunktion dar.

Hinweis

Wenn Sie Visual Studio verwenden, können Sie den objektrelationalen Designer verwenden, um Methoden zu erstellen, die gespeicherten Prozeduren und benutzerdefinierten Funktionen zugeordnet sind.

Beispiel

// This is an example of a stored procedure in the Northwind
// sample database. The IsComposable property defaults to false.
[Function(Name="dbo.CustOrderHist")]
public ISingleResult<CustOrderHistResult> CustOrderHist([Parameter(Name="CustomerID", DbType="NChar(5)")] string customerID)
{
    IExecuteResult result = this.ExecuteMethodCall(this, ((MethodInfo)(MethodInfo.GetCurrentMethod())), customerID);
    return ((ISingleResult<CustOrderHistResult>)(result.ReturnValue));
}

   ' This is an example of a stored procedure in the Northwind
   ' sample database. The IsComposable property defaults to false.
   <FunctionAttribute(Name:="dbo.CustOrderHist")> _
Public Function CustOrderHist(<Parameter(Name:="CustomerID", DbType:="NChar(5)")> ByVal customerID As String) As ISingleResult(Of CustOrderHistResult)
       Dim result As IExecuteResult = Me.ExecuteMethodCall(Me, CType(MethodInfo.GetCurrentMethod, MethodInfo), customerID)
       Return CType(result.ReturnValue, ISingleResult(Of CustOrderHistResult))
   End Function

Weitere Informationen finden Sie in den Abschnitten "Function Attribute", "Stored Procedure Attribute" und "Parameter Attribute" von Attribute-Based Mapping and Stored Procedures.

Siehe auch