Freigeben über

Implementieren von Geschäftslogik (LINQ to SQL)

Der Begriff "Geschäftslogik" in diesem Thema bezieht sich auf alle benutzerdefinierten Regeln oder Überprüfungstests, die Sie auf Daten anwenden, bevor sie in die Datenbank eingefügt, aktualisiert oder gelöscht wird. Geschäftslogik wird manchmal auch als "Geschäftsregeln" oder "Domänenlogik" bezeichnet. In n-Ebenen-Anwendungen ist sie in der Regel als logische Ebene konzipiert, sodass sie unabhängig von der Präsentationsschicht oder datenzugriffsschicht geändert werden kann. Die Geschäftslogik kann von der Datenzugriffsebene vor oder nach einer Aktualisierung, Einfügung oder Löschung von Daten in der Datenbank aufgerufen werden.

Die Geschäftslogik kann so einfach wie eine Schemaüberprüfung sein, um sicherzustellen, dass der Typ des Felds mit dem Typ der Tabellenspalte kompatibel ist. Oder es kann aus einer Gruppe von Objekten bestehen, die beliebig komplex interagieren. Die Regeln können als gespeicherte Prozeduren in der Datenbank oder als In-Memory-Objekte implementiert werden. Ungeachtet dessen, wie die Geschäftslogik implementiert wird, ermöglicht es Ihnen LINQ to SQL, Teilklassen und Teilmethoden zu verwenden, um die Geschäftslogik vom Datenzugriffscode zu trennen.

So ruft LINQ to SQL Ihre Geschäftslogik auf

Wenn Sie zur Entwurfszeit eine Entitätsklasse generieren, entweder manuell oder mithilfe des Objektrelational-Designers oder SQLMetal, wird sie als partielle Klasse definiert. Dies bedeutet, dass Sie in einer separaten Codedatei einen anderen Teil der Entitätsklasse definieren können, der Ihre benutzerdefinierte Geschäftslogik enthält. Zur Kompilierungszeit werden die beiden Teile in einer einzigen Klasse zusammengeführt. Wenn Sie ihre Entitätsklassen jedoch mithilfe des Objektrelational-Designers oder SQLMetal neu generieren müssen, können Sie dies tun, und Ihr Teil der Klasse wird nicht geändert.

Die partiellen Klassen, die Entitäten definieren, und das DataContext enthalten partielle Methoden. Dies sind die Erweiterbarkeitspunkte, die Sie verwenden können, um Ihre Geschäftslogik vor und nach jeder Aktualisierung, einem Einfügen oder Löschen für eine Entitäts- oder Entitätseigenschaft anzuwenden. Partielle Methoden können als Kompilierungszeitereignisse betrachtet werden. Der Code-Generator definiert eine Methodensignatur und ruft die Methoden in den get- und set-Eigenschaftenaccessoren, im DataContext-Konstruktor und in einigen Fällen im Hintergrund auf, sobald SubmitChanges aufgerufen wird. Wenn Sie jedoch eine bestimmte partielle Methode nicht implementieren, werden alle Verweise darauf und die Definition während der Kompilierung entfernt.

In der Implementierungsdefinition, die Sie in Ihre separate Codedatei schreiben, können Sie jede benutzerdefinierte Logik ausführen, die erforderlich ist. Sie können die partielle Klasse selbst als Domänenebene verwenden oder einen Aufruf von der Implementierungsdefinition der partiellen Methode in separate Objekte ausführen. Auf beide Weise wird Ihre Geschäftslogik sauber von Ihrem Datenzugriffscode und Dem Präsentationsebenencode getrennt.

Genauere Betrachtung der Erweiterbarkeitspunkte

Das folgende Beispiel zeigt einen Teil des Codes, der vom Objektrelational-Designer für die DataContext Klasse mit zwei Tabellen generiert wird: Customers und Orders. Beachten Sie, dass die Methoden "Insert", "Update" und "Delete" für jede Tabelle in der Klasse definiert sind.

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

Wenn Sie die Methoden "Insert", "Update" und "Delete" in Ihrer partiellen Klasse implementieren, ruft die LINQ-zu-SQL-Laufzeit diese anstelle der eigenen Standardmethoden auf, wenn SubmitChanges aufgerufen wird. Auf diese Weise können Sie das Standardverhalten für Erstellungs-/Lese-/Aktualisierungs-/Löschvorgänge außer Kraft setzen. Weitere Informationen finden Sie unter Walkthrough: Anpassen des Einfüge-, Aktualisierungs- und Löschverhaltens von Entitätsklassen.

Die OnCreated Methode wird im Klassenkonstruktor aufgerufen.

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

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

Die Entitätsklassen verfügen über drei Methoden, die von linQ to SQL runtime aufgerufen werden, wenn die Entität erstellt, geladen und überprüft wird (wenn SubmitChanges aufgerufen wird). Die Entitätsklassen verfügen auch über zwei partielle Methoden für jede Eigenschaft, eine, die aufgerufen wird, bevor die Eigenschaft festgelegt wird, und eine, die danach aufgerufen wird. Das folgende Codebeispiel zeigt einige der methoden, die für die Customer Klasse generiert wurden:

#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

Die Methoden werden im Eigenschaftensatz-Accessor aufgerufen, wie im folgenden Beispiel für die CustomerID Eigenschaft gezeigt:

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();  
        }  
     }  
}

In Ihrem Teil der Klasse schreiben Sie eine Implementierungsdefinition der Methode. Nachdem Sie in Visual Studio partial eingegeben haben, wird IntelliSense für die Methodendefinitionen im anderen Teil der Klasse angezeigt.

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.  
        }  
    }

Weitere Informationen zum Hinzufügen von Geschäftslogik zu Ihrer Anwendung mithilfe partieller Methoden finden Sie in den folgenden Themen:

So fügen Sie Validierung zu Entitätsklassen hinzu

Exemplarische Vorgehensweise: Anpassen des Einfüge-, Aktualisierungs- und Löschverhaltens von Entitätsklassen

Anleitung: Hinzufügen der Validierung zu Entitätsklassen

Siehe auch