Modèle objet LINQ to SQL
Mise à jour : November 2007
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 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.
.png)
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 :
Modèle objet LINQ to SQL |
Modèle de données relationnel |
|---|---|
Classe d'entité |
Table |
Membre de classe |
Colonne |
Association |
Relation de clé étrangère |
Méthode |
Procédure stockée ou fonction |
.gif "Remarque") Remarque : |
|---|
Les descriptions suivantes supposent que vous possédez des connaissances de base sur le modèle de données relationnel et ses règles. |
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 Customer
Public CustomerID As String
' ...
Public City As String
End Class
[Table(Name = "Customers")]
public class Customerzz
{
public string CustomerID;
// ...
public string City;
}
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 Attribut TableAttribute de Mappage basé sur les attributs (LINQ to SQL).
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 CustomerID As String
<Column()> _
Public City As String
End Class
[Table(Name = "Customers")]
public class Customer
{
[Column(IsPrimaryKey = true)]
public string CustomerID;
[Column]
public string City;
}
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 Attribut ColumnAttribute de Mappage basé sur les attributs (LINQ to SQL).
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 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
[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");
}
}
}
Pour plus d'informations, consultez la section Attribut AssociationAttribute de Mappage basé sur les attributs (LINQ to SQL).
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.
| Remarque : |
|---|
Si vous utilisez Visual Studio, vous pouvez utiliser le Concepteur Objet/Relationnel pour créer des méthodes mappées à des procédures stockées et des 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.
<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
// 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));
}
Pour plus d'informations, consultez les sections Attribut FunctionAttribute, Attributs relatifs aux procédures stockées et Attribut ParameterAttribute de Mappage basé sur les attributs (LINQ to SQL) et Procédures stockées (LINQ to SQL).
Voir aussi
Référence
Mappage basé sur les attributs (LINQ to SQL)