Partager via

Implémentation de la logique métier (LINQ to SQL)

Le terme « logique métier » dans cette rubrique fait référence à toutes les règles personnalisées ou tests de validation que vous appliquez aux données avant d’être insérées, mises à jour ou supprimées de la base de données. La logique métier est également parfois appelée « règles métier » ou « logique de domaine ». Dans les applications à plusieurs niveaux, elle est généralement conçue comme couche logique afin qu’elle puisse être modifiée indépendamment de la couche de présentation ou de la couche d’accès aux données. La logique métier peut être appelée par la couche d’accès aux données avant ou après toute mise à jour, insertion ou suppression de données dans la base de données.

La logique métier peut être aussi simple qu’une validation de schéma pour vous assurer que le type du champ est compatible avec le type de la colonne de table. Ou il peut se composer d’un ensemble d’objets qui interagissent de manière arbitrairement complexe. Les règles peuvent être implémentées en tant que procédures stockées sur la base de données ou en tant qu’objets en mémoire. Quelle que soit la manière dont la logique métier est implémentée, LINQ to SQL vous permet d’utiliser des classes partielles et des méthodes partielles pour séparer la logique métier du code d’accès aux données.

Comment LINQ to SQL appelle votre logique métier

Lorsque vous générez une classe d’entité au moment du design, manuellement ou à l’aide du Concepteur relationnel d’objet ou de SQLMetal, elle est définie comme une classe partielle. Cela signifie que, dans un fichier de code distinct, vous pouvez définir une autre partie de la classe d’entité qui contient votre logique métier personnalisée. Au moment de la compilation, les deux parties sont fusionnées en une seule classe. Toutefois, si vous devez régénérer vos classes d’entité à l’aide du Concepteur relationnel d’objet ou de SQLMetal, vous pouvez le faire et votre partie de la classe ne sera pas modifiée.

Les classes partielles qui définissent des entités et le DataContext contiennent des méthodes partielles. Il s’agit des points d’extensibilité que vous pouvez utiliser pour appliquer votre logique métier avant et après toute mise à jour, insertion ou suppression pour une entité ou une propriété d’entité. Les méthodes partielles peuvent être considérées comme des événements au moment de la compilation. Le générateur de code définit une signature de méthode et appelle les méthodes dans les accesseurs de propriété get et set, le constructeur DataContext, et dans certains cas en arrière-plan lorsque SubmitChanges est appelé. Toutefois, si vous n’implémentez pas de méthode partielle particulière, toutes les références à celle-ci et la définition sont supprimées au moment de la compilation.

Dans la définition d’implémentation que vous écrivez dans votre fichier de code distinct, vous pouvez effectuer toute logique personnalisée requise. Vous pouvez utiliser votre classe partielle elle-même comme couche de domaine, ou vous pouvez appeler à partir de votre définition d’implémentation de la méthode partielle dans un objet ou des objets distincts. Dans les deux cas, votre logique métier est distincte de votre code d’accès aux données et de votre code de couche présentation.

Regardez plus près les points d’extensibilité

L’exemple suivant montre une partie du code généré par le Concepteur relationnel d’objet pour la DataContext classe qui a deux tables : Customers et Orders. Notez que les méthodes Insert, Update et Delete sont définies pour chaque table de la classe.

Partial Public Class Northwnd  
    Inherits System.Data.Linq.DataContext  
  
    Private Shared mappingSource As _  
        System.Data.Linq.Mapping.MappingSource = New _  
        AttributeMappingSource  
  
    #Region "Extensibility Method Definitions"  
    Partial Private Sub OnCreated()  
    End Sub  
    Partial Private Sub InsertCustomer(instance As Customer)  
    End Sub  
    Partial Private Sub UpdateCustomer(instance As Customer)  
    End Sub  
    Partial Private Sub DeleteCustomer(instance As Customer)  
    End Sub  
    Partial Private Sub InsertOrder(instance As [Order])  
    End Sub  
    Partial Private Sub UpdateOrder(instance As [Order])  
    End Sub  
    Partial Private Sub DeleteOrder(instance As [Order])  
    End Sub  
    #End Region  

public partial class MyNorthWindDataContext : System.Data.Linq.DataContext  
    {  
        private static System.Data.Linq.Mapping.MappingSource mappingSource = new AttributeMappingSource();  
  
        #region Extensibility Method Definitions  
        partial void OnCreated();  
        partial void InsertCustomer(Customer instance);  
        partial void UpdateCustomer(Customer instance);  
        partial void DeleteCustomer(Customer instance);  
        partial void InsertOrder(Order instance);  
        partial void UpdateOrder(Order instance);  
        partial void DeleteOrder(Order instance);  
        #endregion

Si vous implémentez les méthodes Insert, Update et Delete dans votre classe partielle, le runtime LINQ to SQL les appelle au lieu de ses propres méthodes par défaut lorsqu’elle SubmitChanges est appelée. Cela vous permet de remplacer le comportement par défaut pour les opérations de création/lecture/mise à jour/suppression. Pour plus d’informations, consultez Procédure pas à pas : personnalisation du comportement d’insertion, de mise à jour et de suppression des classes d’entité.

La OnCreated méthode est appelée dans le constructeur de classe.

Public Sub New(ByVal connection As String)  
    MyBase.New(connection, mappingSource)  
    OnCreated()  
End Sub  

public MyNorthWindDataContext(string connection) :  
            base(connection, mappingSource)  
        {  
            OnCreated();  
        }

Les classes d’entité ont trois méthodes appelées par le runtime LINQ to SQL lorsque l’entité est créée, chargée et validée (quand SubmitChanges elle est appelée). Les classes d’entité ont également deux méthodes partielles pour chaque propriété, une appelée avant la définition de la propriété et une autre appelée après. L’exemple de code suivant montre certaines des méthodes générées pour la Customer classe :

#Region "Extensibility Method Definitions"  
    Partial Private Sub OnLoaded()  
    End Sub  
    Partial Private Sub OnValidate(action As _  
        System.Data.Linq.ChangeAction)  
    End Sub  
    Partial Private Sub OnCreated()  
    End Sub  
    Partial Private Sub OnCustomerIDChanging(value As String)  
    End Sub  
    Partial Private Sub OnCustomerIDChanged()  
    End Sub  
    Partial Private Sub OnCompanyNameChanging(value As String)  
    End Sub  
    Partial Private Sub OnCompanyNameChanged()  
    End Sub  
' ...Additional Changing/Changed methods for each property.  

#region Extensibility Method Definitions  
    partial void OnLoaded();  
    partial void OnValidate();  
    partial void OnCreated();  
    partial void OnCustomerIDChanging(string value);  
    partial void OnCustomerIDChanged();  
    partial void OnCompanyNameChanging(string value);  
    partial void OnCompanyNameChanged();  
// ...additional Changing/Changed methods for each property

Les méthodes sont appelées dans l’accesseur du jeu de propriétés, comme indiqué dans l’exemple suivant pour la CustomerID propriété :

Public Property CustomerID() As String  
    Set  
        If (String.Equals(Me._CustomerID, value) = False) Then  
            Me.OnCustomerIDChanging(value)  
            Me.SendPropertyChanging()  
            Me._CustomerID = value  
            Me.SendPropertyChanged("CustomerID")  
            Me.OnCustomerIDChanged()  
        End If  
    End Set  
End Property  

public string CustomerID  
{  
    set  
    {  
        if ((this._CustomerID != value))  
        {  
            this.OnCustomerIDChanging(value);  
            this.SendPropertyChanging();  
            this._CustomerID = value;  
            this.SendPropertyChanged("CustomerID");  
            this.OnCustomerIDChanged();  
        }  
     }  
}

Dans votre partie de la classe, vous écrivez une définition d’implémentation de la méthode. Dans Visual Studio, une fois que vous avez tapé partial , IntelliSense s’affiche pour les définitions de méthode dans l’autre partie de la classe.

Partial Public Class Customer  
    Private Sub OnCustomerIDChanging(value As String)  
        ' Perform custom validation logic here.  
    End Sub  
End Class  

partial class Customer
    {  
        partial void OnCustomerIDChanging(string value)  
        {  
            //Perform custom validation logic here.  
        }  
    }

Pour plus d’informations sur l’ajout d’une logique métier à votre application à l’aide de méthodes partielles, consultez les rubriques suivantes :

Guide pratique pour ajouter une validation aux classes d’entité

Procédure pas à pas : personnalisation du comportement d’insertion, de mise à jour et de suppression des classes d’entité

Procédure pas à pas : ajout d’une validation à des classes d’entité

Voir aussi