Modèle objet LINQ to SQL

Dans LINQ to SQL, un modèle de données exprimé dans le langage de programmation du développeur est mappé au modèle de données d’une base de données relationnelle. Les opérations sur les données sont ensuite effectuées en fonction du modèle objet.

Dans ce scénario, vous ne transmettez pas de commandes de base de données (par exemple, INSERT) à la base de données. Vous modifiez des valeurs et exécutez des méthodes dans votre modèle objet. Lorsque vous souhaitez interroger la base de données ou lui envoyer des modifications, LINQ to SQL traduit vos demandes en commandes SQL appropriées et envoie ces commandes à la base de données.

Le tableau suivant résume les éléments principaux du modèle objet LiNQ to SQL et leur relation avec les éléments du modèle de données relationnel :

Classes d'entité et tables de base de données LINQ to SQL

Dans LINQ to SQL, une table de base de données est représentée par une classe d’entité. Une classe d'entité est similaire aux autres classes si ce n'est que vous pouvez l'annoter en utilisant des informations spéciales qui l'associent à une table de base de données. Pour procéder à cette annotation, ajoutez un attribut personnalisé (TableAttribute) à votre déclaration de classe, comme dans l'exemple suivant :

Exemple

[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

Seules les instances de classes déclarées comme des tables (classes d'entité) peuvent être enregistrées dans la base de données.

Pour plus d’informations, consultez la section TableAttribute de la rubrique Mappage basé sur les attributs.

Membres de classe et colonnes de base de données LINQ to SQL

Vous pouvez non seulement associer des classes à des tables, mais également désigner des champs ou des propriétés pour représenter des colonnes de base de données. À cette fin, LiNQ to SQL définit l’attribut ColumnAttribute, comme dans l’exemple suivant :

Exemple

[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

Seuls les champs et les propriétés mappés à des colonnes sont rendus persistants ou récupérés dans la base de données. Ceux qui ne sont pas déclarés comme des colonnes sont considérés comme des éléments temporaires de votre logique d'application.

L'attribut ColumnAttribute possède diverses propriétés que vous pouvez utiliser pour personnaliser les membres qui représentent des colonnes (par exemple, désigner un membre comme représentant d'une colonne de clé primaire). Pour plus d’informations, consultez la section ColumnAttribute de la rubrique Mappage basé sur les attributs.

Associations et relations de clé étrangère de base de données LINQ to SQL

Dans LINQ to SQL, vous représentez des associations de base de données (telles que les relations de clé étrangère à clé primaire) en appliquant l’attribut AssociationAttribute. Dans le segment de code suivant, la classe Order contient une propriété Customer qui possède un attribut AssociationAttribute. Cette propriété et son attribut fournissent à la classe Order une relation avec la classe Customer.

L'exemple de code suivant présente la propriété Customer de la classe Order.

Exemple

[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

Pour plus d’informations, consultez la section AssociationAttribute de la rubrique Mappage basé sur les attributs.

Méthodes et procédures stockées de base de données LINQ to SQL

LiNQ to SQL prend en charge des procédures stockées et des fonctions définies par l’utilisateur. Dans LINQ to SQL, vous mappez ces abstractions définies par la base de données à des objets représentant un client pour pouvoir y accéder de manière fortement typée à partir du code client. Les signatures de méthode sont aussi semblables que possible aux signatures des procédures et fonctions définies dans la base de données. Vous pouvez utiliser IntelliSense pour découvrir ces méthodes.

Un jeu de résultats retourné par un appel à une procédure mappée est une collection fortement typée.

LINQ to SQL mappe des procédures stockées et des fonctions à des méthodes en utilisant les attributs FunctionAttribute et ParameterAttribute. Les méthodes qui représentent des procédures stockées se distinguent de celles qui représentent des fonctions définies par l'utilisateur par la propriété IsComposable. Si cette propriété a la valeur false (valeur par défaut), la méthode représente une procédure stockée. Si elle a la valeur true, la méthode représente une fonction de base de données.

Exemple

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

Pour plus d’informations, consultez les sections Attribut FunctionAttribute, Attributs relatifs aux procédures stockées et Attribut ParameterAttribute des pages Mappage basé sur les attributs et Procédures stockées.

Voir aussi

• Mappage basé sur les attributs
• Informations générales