Partager via

Modèle objet LINQ to SQL

Dans LINQ to SQL, un modèle objet 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 n’émettez pas de commandes de base de données (par exemple) INSERTà la base de données. Au lieu de cela, vous modifiez les valeurs et exécutez des méthodes dans votre modèle objet. Lorsque vous souhaitez interroger la base de données ou l’envoyer, LINQ to SQL convertit vos requêtes en commandes SQL correctes et envoie ces commandes à la base de données.

Capture d’écran montrant le modèle objet Linq.

Les éléments les plus fondamentaux dans le modèle objet LINQ to SQL et leur relation avec les éléments du modèle de données relationnelles sont résumés dans le tableau suivant :

Modèle objet LINQ to SQL Modèle de données relationnelles
Classe d’entité Tableau
Membre de classe Colonne
Association Relation de clé étrangère
Méthode Procédure stockée ou fonction

Remarque

Les descriptions suivantes supposent que vous avez une connaissance de base du modèle et des règles de données relationnelles.

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

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 semblable à n’importe quelle autre classe que vous pouvez créer, sauf que vous annotez la classe à l’aide d’informations spéciales qui associent la classe à une table de base de données. Vous effectuez cette annotation en ajoutant 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 en tant que tables (autrement dit, les classes d’entité) peuvent être enregistrées dans la base de données.

Pour plus d’informations, consultez la section Table des attributs de Attribute-Based Mapping.

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

En plus d’associer des classes à des tables, vous désignez des champs ou des propriétés pour représenter des colonnes de base de données. À cet effet, 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 aux colonnes sont conservés ou récupérés à partir de la base de données. Ceux qui ne sont pas déclarés en tant que colonnes sont considérés comme des parties temporaires de votre logique d’application.

L’attribut ColumnAttribute a une variété de propriétés que vous pouvez utiliser pour personnaliser ces membres qui représentent des colonnes (par exemple, concevoir un membre comme représentant 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 la clé étrangère aux relations de clé primaire) en appliquant l’attribut AssociationAttribute . Dans le segment de code suivant, la Order classe contient une Customer propriété qui a un AssociationAttribute attribut. Cette propriété et son attribut fournissent à la Order classe une relation avec la Customer classe.

L’exemple de code suivant montre la Customer propriété de la Order classe.

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 les procédures stockées et les fonctions définies par l’utilisateur. Dans LINQ to SQL, vous mappez ces abstractions définies par la base de données aux objets clients afin de pouvoir y accéder de manière fortement typée à partir du code client. Les signatures de méthode ressemblent aussi étroitement 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 les procédures stockées et les fonctions aux méthodes à l’aide des attributs FunctionAttribute et ParameterAttribute. Les méthodes représentant des procédures stockées se distinguent de celles représentant les fonctions définies par l’utilisateur par la IsComposable propriété. Si cette propriété est définie false sur (valeur par défaut), la méthode représente une procédure stockée. Si elle est définie sur true, la méthode représente une fonction dans la base de données.

Remarque

Si vous utilisez Visual Studio, vous pouvez utiliser le Concepteur relationnel objet pour créer des méthodes mappées aux procédures stockées et aux fonctions définies par l’utilisateur.

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 de la fonction, Attribut de procédure stockée et Attribut de paramètre de Attribute-Based mappage et procédures stockées.

Voir aussi

  • Last updated on