Delen via

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.

Schermopname van het Linq-objectmodel.

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
Lid van de klas Rubriek
Vereniging Vreemde-sleutelrelatie
Methode Opgeslagen procedure of functie

Opmerking

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:

Voorbeeld

[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 over Tabelkenmerk van Attribute-Based Toewijzing 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:

Voorbeeld

[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 Attribute-Based Toewijzing voor meer informatie.

LINQ naar SQL-koppelingen en relaties met refererende databases

In LINQ naar SQL vertegenwoordigt u databasekoppelingen (zoals verwijzende-sleutel- en primaire-sleutelrelaties) door het kenmerk AssociationAttribute 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.

Voorbeeld

[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 Attribute-Based Toewijzing voor meer informatie.

LINQ naar SQL-methoden en databaseopslagprocedures

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 resultset die wordt geretourneerd door een oproep naar een gekoppelde 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.

Opmerking

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.

Voorbeeld

// 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

Voor meer informatie, zie de secties Functiekenmerk, Kenmerk van opgeslagen procedure en Parameterkenmerk van Attribute-Based Toewijzing en Opgeslagen procedures.

Zie ook