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. Operationen mit den Daten werden dann nach dem Objektmodell durchgeführt.
In diesem Szenario übergeben Sie keine Datenbankbefehle (z. B. INSERT) an die Datenbank. Stattdessen ändern Sie Werte und führen Methoden innerhalb des Objektmodells aus. Wenn Sie die Datenbank abfragen oder Änderungen übergeben möchten, übersetzt LINQ to SQL Ihre Anforderungen in die richtigen SQL-Befehle und sendet diese an die Datenbank.
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 |
| Klassenmember | Spalte |
| Zuordnung | Fremdschlüsselbeziehung |
| Methode | Gespeicherte Prozedur oder Funktion |
Hinweis
Die folgenden Beschreibungen gehen davon aus, dass Sie über Grundkenntnisse des relationalen Datenmodells und der Regeln verfügen.
LINQ to SQL-Entitätsklassen und Datenbanktabellen
In LINQ to SQL wird eine Datenbanktabelle durch eine Entitätsklassedargestellt. Eine Entitätsklasse entspricht jeder anderen Klasse, die Sie erstellen können. Allerdings fügen Sie der Klasse Anmerkungen mit speziellen Informationen hinzu, die diese Klasse einer Datenbanktabelle zuweisen. Sie fügen diese Anmerkungen hinzu, indem Sie Ihrer Klassendeklaration ein benutzerdefiniertes Attribut (TableAttribute) hinzufügen. Siehe hierzu das folgende Beispiel:
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 Tabelle deklarierte Klasseninstanzen (Entitätsklassen) können in der Datenbank gespeichert werden.
Weitere Informationen finden Sie im Abschnitt "Table Attribute" der attributbasierten Zuordnung.
LINQ to SQL-Klassenmember und Datenbankspalten
Neben der Zuordnung von Klassen zu Tabellen legen Sie Felder oder Eigenschaften fest, um Datenbankspalten darzustellen. 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 werden, bleiben in der Datenbank erhalten oder werden aus dieser abgerufen. Alle übrigen Elemente gelten als Übergangsteile Ihrer Anwendungslogik.
Das ColumnAttribute-Attribut weist eine Reihe von Eigenschaften auf, mit denen Sie die Member, die Spalten darstellen, anpassen können (sie können z. B. ein Member für die Darstellung einer Primärschlüsselspalte festlegen). Weitere Informationen finden Sie im Abschnitt "Column Attribute" der attributbasierten Zuordnung.
LINQ to SQL-Zuordnungen 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 Customer-Klasse bereit.
Im folgenden Codebeispiel wird die Customer-Eigenschaft der Order-Klasse gezeigt.
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 to SQL-Methoden und in der Datenbank gespeicherte Prozeduren
LINQ to SQL unterstützt gespeicherte Prozeduren und benutzerdefinierte Funktionen. In LINQ to SQL weisen Sie diese in der Datenbank definierten Abstraktionen den Client-Objekten zu, sodass Sie diese vom Client-Code aus mit strikter Typzuordnung nutzen können. Die Methodensignaturen entsprechen so weit wie möglich den Signaturen der Prozeduren und Funktionen in der Datenbank. 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 den Methoden durch Verwendung des FunctionAttribute-Attribut und des ParameterAttribute-Attribut zu. Methoden, die gespeicherte Prozeduren darstellen, werden von jenen unterschieden, die benutzerdefinierte Funktionen durch die IsComposable-Eigenschaft darstellen. Wenn diese Eigenschaft auf false (Standard) festgelegt wird, stellt die Methode eine gespeicherte Prozedur dar. Wenn sie auf true festgelegt wird, stellt die Methode eine Datenbankfunktion dar.
Hinweis
Wenn Sie Visual Studio verwenden, können Sie die Objektrelationaler 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 im Abschnitt "Function Attribute", "Stored Procedure Attribute" und "Parameter Attribute" der Attributbasierten Zuordnung und gespeicherten Prozeduren.