Het LINQ-naar-SQL-objectmodel
In LINQ naar SQL wordt een objectmodel dat wordt uitgedrukt in de programmeertaal van de ontwikkelaar toegewezen aan het gegevensmodel van een relationele database. Bewerkingen op de gegevens worden vervolgens uitgevoerd volgens het objectmodel.
In dit scenario geeft u geen databaseopdrachten (bijvoorbeeld INSERT) uit aan de database. In plaats daarvan wijzigt u waarden en voert u methoden uit binnen uw objectmodel. Wanneer u een query wilt uitvoeren op de database of deze wijzigingen wilt verzenden, vertaalt LINQ naar SQL uw aanvragen in de juiste SQL-opdrachten en verzendt u deze opdrachten naar de database.
De meest fundamentele elementen in het LINQ-naar-SQL-objectmodel en hun relatie met elementen in het relationele gegevensmodel worden samengevat in de volgende tabel:
| LINQ naar SQL-objectmodel | Relationeel gegevensmodel |
|---|---|
| Entiteitsklasse | Tabel |
| Klaslid | Kolom |
| Koppeling | Relatie met refererende sleutel |
| Wijze | Opgeslagen procedure of functie |
Notitie
In de volgende beschrijvingen wordt ervan uitgegaan dat u basiskennis hebt van het relationele gegevensmodel en de regels.
LINQ naar SQL-entiteitsklassen en databasetabellen
In LINQ naar SQL wordt een databasetabel vertegenwoordigd door een entiteitsklasse. Een entiteitsklasse is net als elke andere klasse die u kunt maken, behalve dat u aantekeningen maakt bij de klasse met behulp van speciale informatie die de klasse koppelt aan een databasetabel. U maakt deze aantekening door een aangepast kenmerk (TableAttribute) toe te voegen aan uw klassedeclaratie, zoals in het volgende voorbeeld:
Opmerking
[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
Alleen exemplaren van klassen die zijn gedeclareerd als tabellen (dat wil gezegd entiteitsklassen) kunnen worden opgeslagen in de database.
Zie de sectie Tabelkenmerk van kenmerktoewijzing op basis van kenmerken voor meer informatie.
LINQ naar SQL-klasseleden en databasekolommen
Naast het koppelen van klassen aan tabellen, wijst u velden of eigenschappen aan die databasekolommen vertegenwoordigen. Voor dit doel definieert LINQ naar SQL het ColumnAttribute kenmerk, zoals in het volgende voorbeeld:
Opmerking
[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
Alleen velden en eigenschappen die zijn toegewezen aan kolommen, worden bewaard naar of opgehaald uit de database. Deze niet gedeclareerd als kolommen worden beschouwd als tijdelijke onderdelen van uw toepassingslogica.
Het ColumnAttribute kenmerk heeft verschillende eigenschappen die u kunt gebruiken om deze leden aan te passen die kolommen vertegenwoordigen (bijvoorbeeld het aanwijzen van een lid als vertegenwoordiger van een primaire-sleutelkolom). Zie de sectie Kolomkenmerk van kenmerktoewijzing op basis van kenmerken voor meer informatie.
LINQ naar SQL-koppelingen en relaties met refererende databases
In LINQ naar SQL vertegenwoordigt u databasekoppelingen (zoals refererende-sleutel- en primaire-sleutelrelaties) door het AssociationAttribute kenmerk toe te passen. In het volgende codesegment bevat de Order klasse een Customer eigenschap met een AssociationAttribute kenmerk. Deze eigenschap en het bijbehorende kenmerk bieden de Order klasse een relatie met de Customer klasse.
In het volgende codevoorbeeld ziet u de Customer eigenschap uit de Order klasse.
Opmerking
[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
Zie de sectie Koppelingskenmerk van kenmerktoewijzing op basis van kenmerken voor meer informatie.
LINQ naar SQL-methoden en opgeslagen databaseprocedures
LINQ naar SQL ondersteunt opgeslagen procedures en door de gebruiker gedefinieerde functies. In LINQ naar SQL wijst u deze door de database gedefinieerde abstracties toe aan clientobjecten, zodat u ze op een sterk getypte manier kunt openen vanuit clientcode. De methodehandtekeningen lijken zo dicht mogelijk op de handtekeningen van de procedures en functies die in de database zijn gedefinieerd. U kunt IntelliSense gebruiken om deze methoden te detecteren.
Een resultatenset die wordt geretourneerd door een aanroep naar een toegewezen procedure, is een sterk getypte verzameling.
LINQ naar SQL wijst opgeslagen procedures en functies toe aan methoden met behulp van de FunctionAttribute en ParameterAttribute kenmerken. Methoden voor opgeslagen procedures worden onderscheiden van methoden die door de gebruiker gedefinieerde functies door de IsComposable eigenschap vertegenwoordigen. Als deze eigenschap is ingesteld op false (de standaardinstelling), vertegenwoordigt de methode een opgeslagen procedure. Als deze optie is ingesteld true, vertegenwoordigt de methode een databasefunctie.
Notitie
Als u Visual Studio gebruikt, kunt u de Object Relational Designer gebruiken om methoden te maken die zijn toegewezen aan opgeslagen procedures en door de gebruiker gedefinieerde functies.
Opmerking
// 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
Zie de secties Functiekenmerk, Kenmerk opgeslagen procedure en Parameterkenmerk van toewijzing op basis van kenmerken en opgeslagen procedures voor meer informatie.