Implementieren von Geschäftslogik (LINQ to SQL)
Der Begriff "Geschäftslogik" bezieht sich in diesem Thema auf benutzerdefinierte Regeln oder Validierungstests, die auf Daten angewendet werden, bevor diese eingefügt, aktualisiert oder aus der Datenbank gelöscht werden. Geschäftslogik wird manchmal auch als „Geschäftsregeln“ oder „Domänenlogik“ bezeichnet. In n-Schicht-Anwendungen ist sie in der Regel als logische Ebene konzipiert, sodass sie unabhängig von der Präsentations- oder Datenzugriffsebene geändert werden kann. Die Geschäftslogik kann von der Datenzugriffsebene aufgerufen werden, bevor oder nachdem Daten in der Datenbank aktualisiert, eingefügt oder gelöscht werden.
Mit der Geschäftslogik kann genauso einfach wie anhand einer Schemavalidierung festgestellt werden, ob der Typ des Feldes mit dem Typ der Tabellenspalte kompatibel ist. Alternativ kann sie aus einem Satz von Objekten bestehen, die auf beliebig komplexe Weisen interagieren. Die Regeln werden möglicherweise als gespeicherte Prozeduren in der Datenbank oder als Objekte im Arbeitsspeicher implementiert. Wenn jedoch die Geschäftslogik implementiert ist, ermöglicht Ihnen LINQ to SQL die Verwendung von partiellen Klassen und Methoden, um die Geschäftslogik vom Datenzugriffscode zu trennen.
Aufrufen der Geschäftslogik durch LINQ to SQL
Wenn Sie eine Entitätsklasse zur Entwurfszeit entweder manuell oder mithilfe von Objektrelationaler Designer oder SQLMetal generieren, wird sie als partielle Klasse definiert. Dies bedeutet, dass Sie in einer separaten Codedatei einen anderen Teil der Entitätsklasse festlegen können, in der die benutzerdefinierte Geschäftslogik enthalten ist. Zur Kompilierungszeit werden die beiden Teile in eine einzelne Klasse zusammengeführt. Wenn Sie Entitätskassen mithilfe von Objektrelationaler Designer oder SQLMetal regenerieren müssen, können Sie dies tun, ohne dass Ihr Teil der Klasse geändert wird.
Die partiellen Klassen, durch die Entitäten definiert werden, und DataContext enthalten partielle Methoden. Dabei handelt es sich um Erweiterungspunkte, über die Sie die Geschäftslogik anwenden können, bevor und nachdem Sie Updates, Einfügungen oder Löschungen für eine Entität oder Entitätseigenschaft ausführen. Partielle Methoden können als Kompilierzeitereignisse 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 keine bestimmte partielle Methode implementieren, werden alle darauf gerichteten Verweise sowie die Definition während der Kompilierung entfernt.
In der Implementierungsdefinition, die Sie in eine separate Codedatei schreiben, können Sie beliebige benutzerdefinierte Logik aufnehmen. 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. Die Geschäftslogik wird auf beide Weisen klar sowohl vom Datenzugriffscode als auch vom Präsentationsebenencode getrennt.
Genauere Betrachtung der Erweiterungspunkte
Im folgenden Beispiel wird der Teil des Codes veranschaulicht, der vom objektrelationalen Designer für die DataContext-Klasse generiert wird. Diese verfügt über zwei Tabellen: Customers und Orders. Beachten Sie, dass Einfüge-, Update- und Löschmethoden für jede Tabelle in der Klasse definiert werden.
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 Einfüge-, Update- und Löschmethoden in Ihrer partiellen Klasse implementieren, werden sie von der LINQ to SQL-Laufzeit anstelle ihrer eigenen Standardmethoden aufgerufen, sobald SubmitChanges aufgerufen wird. Auf diese Weise können Sie das Standardverhalten für Erstellungs-, Lese-, Update- und Löschoperationen überschreiben. Weitere Informationen finden Sie unter Exemplarische Vorgehensweise: Anpassen des Einfüge-, Update- und Löschverhaltens in 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 der LINQ to SQL-Laufzeit aufgerufen werden, wenn die Entität (beim Aufrufen von SubmitChanges) erstellt, geladen und überprüft wird. Die Entitätsklassen verfügen außerdem über zwei partielle Methoden für jede Eigenschaft, eine davon wird vor dem Festlegen der Eigenschaft und die andere danach aufgerufen. Im folgenden Codebeispiel werden einige der für die Customer-Klasse generierten Methoden veranschaulicht:
#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 set-Accessor der Eigenschaft aufgerufen, wie im folgenden Beispiel für die CustomerID-Eigenschaft veranschaulicht:
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 Ihren 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 darüber, wie Sie Ihrer Anwendung mithilfe von partiellen Methoden Geschäftslogik hinzufügen, finden Sie in den folgenden Themen:
Gewusst wie: Hinzufügen von Validierungen zu Entitätsklassen
Exemplarische Vorgehensweise: Anpassen des Einfüge-, Update- und Löschverhaltens in Entitätsklassen
Exemplarische Vorgehensweise: Hinzufügen einer Validierung zu Entitätsklassen