Condividi tramite

Implementazione della logica di business (LINQ to SQL)

Il termine "logica di business" in questo argomento si riferisce a qualsiasi regola personalizzata o test di convalida applicati ai dati prima dell'inserimento, dell'aggiornamento o dell'eliminazione dal database. La logica di business viene talvolta definita anche "regole business" o "logica di dominio". Nelle applicazioni a più livelli viene in genere progettato come livello logico in modo che possa essere modificato indipendentemente dal livello di presentazione o dal livello di accesso ai dati. La logica di business può essere richiamata dal livello di accesso ai dati prima o dopo qualsiasi aggiornamento, inserimento o eliminazione dei dati nel database.

La logica di business può essere semplice come una convalida dello schema per assicurarsi che il tipo del campo sia compatibile con il tipo della colonna della tabella. Oppure può essere costituito da un set di oggetti che interagiscono in modi arbitrariamente complessi. Le regole possono essere implementate come stored procedure nel database o come oggetti in memoria. Tuttavia, qualunque sia il modo in cui viene implementata la logica di business, LINQ to SQL consente di usare classi parziali e metodi parziali per separare la logica di business dal codice di accesso ai dati.

Come LINQ to SQL richiama la logica aziendale

Quando si genera una classe di entità in fase di progettazione, manualmente o tramite Progettazione relazionale oggetti o SQLMetal, viene definita come classe parziale. Ciò significa che, in un file di codice separato, è possibile definire un'altra parte della classe di entità che contiene la logica di business personalizzata. In fase di compilazione, le due parti vengono unite in una singola classe. Tuttavia, se è necessario rigenerare le classi di entità usando Progettazione relazionale oggetti o SQLMetal, è possibile farlo e la parte della classe non verrà modificata.

Le classi parziali che definiscono le entità e il DataContext contengono metodi parziali. Questi sono i punti di estendibilità che è possibile usare per applicare la logica di business prima e dopo qualsiasi aggiornamento, inserimento o eliminazione per un'entità o una proprietà di entità. I metodi parziali possono essere considerati eventi in fase di compilazione. Il generatore di codice definisce una firma di metodo e chiama i metodi nei metodi di accesso alle proprietà get e set, nel DataContext costruttore, e in alcuni casi in background quando SubmitChanges viene chiamato. Tuttavia, se non si implementa un metodo parziale specifico, tutti i riferimenti ad esso e la definizione vengono rimossi in fase di compilazione.

Nella definizione di implementazione scritta nel file di codice separato è possibile eseguire qualsiasi logica personalizzata richiesta. È possibile utilizzare la classe parziale stessa come livello di dominio, oppure è possibile richiamare dalla definizione implementativa del metodo parziale in un oggetto separato o più oggetti separati. In entrambi i casi, la logica di business è separata in modo pulito dal codice di accesso ai dati e dal codice del livello di presentazione.

Un'analisi più attenta dei punti di estendibilità

Nell'esempio seguente viene illustrata parte del codice generato da Progettazione relazionale oggetti per la DataContext classe con due tabelle: Customers e Orders. Si noti che i metodi Insert, Update e Delete sono definiti per ogni tabella della 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

Se si implementano i metodi Insert, Update e Delete nella classe parziale, il runtime LINQ to SQL li chiamerà anziché i propri metodi predefiniti quando SubmitChanges viene chiamato . In questo modo è possibile eseguire l'override del comportamento predefinito per le operazioni di creazione/lettura/aggiornamento/eliminazione. Per altre informazioni, vedere Procedura dettagliata: Personalizzazione del comportamento di inserimento, aggiornamento ed eliminazione delle classi di entità.

Il OnCreated metodo viene chiamato nel costruttore della classe .

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

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

Le classi di entità hanno tre metodi chiamati dal runtime LINQ to SQL quando l'entità viene creata, caricata e convalidata (quando SubmitChanges viene chiamata). Le classi di entità dispongono anche di due metodi parziali per ogni proprietà, una chiamata prima dell'impostazione della proprietà e una chiamata dopo. L'esempio di codice seguente illustra alcuni dei metodi generati per 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

I metodi vengono chiamati nell'accessor del set di proprietà, come illustrato nell'esempio seguente per la proprietà CustomerID:

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

Nella tua sezione della lezione, scrivi una definizione implementativa del metodo. In Visual Studio, dopo aver digitato partial verrà visualizzato IntelliSense per le definizioni dei metodi nell'altra parte della 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.  
        }  
    }

Per altre informazioni su come aggiungere logica di business all'applicazione usando metodi parziali, vedere gli argomenti seguenti:

Procedura: Aggiungere la convalida alle classi di entità

Procedura dettagliata: Personalizzazione del comportamento di inserimento, aggiornamento ed eliminazione delle classi di entità

Procedura dettagliata: Aggiungere la convalida alle classi di entità

Vedere anche

  • Last updated on