Implementazione della logica di business (LINQ to SQL)Implementing Business Logic (LINQ to SQL)

Il termine "regola business" in questo argomento si riferisce a qualsiasi regola personalizzata o test di convalida applicato ai dati prima che vengano inseriti, aggiornati o eliminati dal database.The term "business logic" in this topic refers to any custom rules or validation tests that you apply to data before it is inserted, updated or deleted from the database. La regola business viene talvolta definita anche "regola dominio".Business logic is also sometimes referred to as "business rules" or "domain logic." Nelle applicazioni a più livelli viene in genere progettata come livello logico in modo da essere modificata indipendentemente dal livello di presentazione o dal livello di accesso ai dati.In n-tier applications it is typically designed as a logical layer so that it can be modified independently of the presentation layer or data access layer. La logica di business può essere richiamata dal livello di accesso ai dati prima o dopo l'aggiornamento, l'inserimento o l'eliminazione dei dati dal database.The business logic can be invoked by the data access layer before or after any update, insertion, or deletion of data in the database.

La regola business è semplice quanto la convalida di uno schema per assicurarsi che il tipo del campo sia compatibile con il tipo della colonna di tabella.The business logic can be as simple as a schema validation to make sure that the type of the field is compatible with the type of the table column. Oppure può essere costituita da un set di oggetti che interagiscono in modalità arbitrariamente complesse.Or it can consist of a set of objects that interact in arbitrarily complex ways. Le regole possono essere implementate come stored procedure nel database o come oggetti in memoria.The rules may be implemented as stored procedures on the database or as in-memory objects. Tuttavia, viene implementata la logica di business, LINQ to SQLLINQ to SQL consente l'utilizzo delle classi parziali e i metodi parziali per separare la logica di business dal codice di accesso ai dati.However the business logic is implemented, LINQ to SQLLINQ to SQL enables you use partial classes and partial methods to separate the business logic from the data access code.

Richiamo della regola business da LINQ to SQLHow LINQ to SQL Invokes Your Business Logic

Quando in fase di progettazione si genera una classe di entità manualmente oppure usando la Object Relational DesignerObject Relational Designer o SQLMetal, tale processo viene definito classe parziale.When you generate an entity class at design time, either manually or by using the Object Relational DesignerObject Relational Designer or SQLMetal, it is defined as a partial class. Ciò significa che, in un file di codice separato, è possibile definire un'altra parte della classe di entità contenente la regola business personalizzata.This means that, in a separate code file, you can define another part of the entity class that contains your custom business logic. In fase di compilazione le due parti vengono unite in un'unica classe.At compile time, the two parts are merged into a single class. È tuttavia possibile rigenerare le classi di entità utilizzando la Object Relational DesignerObject Relational Designer o SQLMetal, senza modificare la parte personalizzata della classe.But if you have to regenerate your entity classes by using the Object Relational DesignerObject Relational Designer or SQLMetal, you can do so and your part of the class will not be modified.

Le classi parziali che definiscono le entità e DataContext contengono metodi parziali.The partial classes that define entities and the DataContext contain partial methods. Si tratta di punti di estensibilità che è possibile usare per applicare la regola business prima e dopo un aggiornamento, inserimento o eliminazione di un'entità o di una proprietà dell'entità.These are the extensibility points that you can use to apply your business logic before and after any update, insert, or delete for an entity or entity property. È possibile considerare i metodi parziali come eventi in fase di compilazione.Partial methods can be thought of as compile-time events. Il generatore di codice definisce una firma del metodo e chiama i metodi nelle funzioni di accesso alle proprietà get e set nonché il costruttore DataContext, e in alcuni casi automaticamente quando viene chiamato SubmitChanges.The code-generator defines a method signature and calls the methods in the get and set property accessors, the DataContext constructor, and in some cases behind the scenes when SubmitChanges is called. Tuttavia, se non si implementa un particolare metodo parziale, tutti i riferimenti relativi e la definizione verranno rimossi in fase di compilazione.However, if you do not implement a particular partial method, then all the references to it and the definition are removed at compile time.

Nella definizione di implementazione scritta nel file di codice separato, è possibile eseguire la regola personalizzata necessaria.In the implementing definition that you write in your separate code file, you can perform whatever custom logic is required. È possibile usare la classe parziale personalizzata come livello del dominio oppure è possibile chiamare dalla definizione di implementazione del metodo parziale in uno o più oggetti separati.You can use your partial class itself as your domain layer, or you can call from your implementing definition of the partial method into a separate object or objects. In entrambi i casi, la regola business viene nettamente separata dal codice di accesso ai dati e dal codice del livello di presentazione.Either way, your business logic is cleanly separated from both your data access code and your presentation layer code.

Informazioni dettagliate sui punti di estensibilitàA Closer Look at the Extensibility Points

Nell'esempio seguente viene illustrata parte del codice generato dal Object Relational DesignerObject Relational Designer per il DataContext classe che dispone di due tabelle: Customers e Orders.The following example shows part of the code generated by the Object Relational DesignerObject Relational Designer for the DataContext class that has two tables: Customers and Orders. Tenere presente che i metodi di inserimento, aggiornamento ed eliminazione vengono definiti per ogni tabella della classe.Note that Insert, Update, and Delete methods are defined for each table in the class.

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 di inserimento, aggiornamento ed eliminazione nella classe parziale, il runtime LINQ to SQLLINQ to SQL chiamerà tali metodi anziché i metodi predefiniti personalizzati quando viene chiamato SubmitChanges.If you implement the Insert, Update and Delete methods in your partial class, the LINQ to SQLLINQ to SQL runtime will call them instead of its own default methods when SubmitChanges is called. In questo modo è possibile eseguire l'override del comportamento predefinito per le operazioni di creazione, lettura, aggiornamento ed eliminazione.This enables you to override the default behavior for create / read / update / delete operations. Per ulteriori informazioni, vedere procedura dettagliata: personalizzazione di inserimento, aggiornamento ed eliminazione di comportamento delle classi di entità.For more information, see Walkthrough: Customizing the insert, update, and delete behavior of entity classes.

Il metodo OnCreated viene chiamato nel costruttore della classe.The OnCreated method is called in the class constructor.

Public Sub New(ByVal connection As String)  
    MyBase.New(connection, mappingSource)  
    OnCreated()  
End Sub  
public MyNorthWindDataContext(string connection) :  
            base(connection, mappingSource)  
        {  
            OnCreated();  
        }  

Per le classi di entità sono disponibili tre metodi che vengono chiamati dal runtime LINQ to SQLLINQ to SQL quando l'entità viene creata, caricata e convalidata (quando viene chiamato SubmitChanges).The entity classes have three methods that are called by the LINQ to SQLLINQ to SQL runtime when the entity is created, loaded, and validated (when SubmitChanges is called). Le classi di entità hanno anche due metodi parziali per ogni proprietà, che viene chiamato prima che la proprietà è impostata e che viene chiamati dopo.The entity classes also have two partial methods for each property, one that is called before the property is set, and one that is called after. Nell'esempio di codice seguente vengono illustrati alcuni metodi generati per la classe Customer:The following code example shows some of the methods generated for the Customer class:

#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 nella funzione di accesso set della proprietà come illustrato nell'esempio seguente per la proprietà CustomerID:The methods are called in the property set accessor as shown in the following example for the CustomerID property:

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 parte personalizzata della classe, scrivere una definizione di implementazione del metodo.In your part of the class, you write an implementing definition of the method. In Visual Studio, dopo aver digitato partial , verrà visualizzato IntelliSense per le definizioni del metodo in altra parte della classe.In Visual Studio, after you type partial you will see IntelliSense for the method definitions in the other part of the class.

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 la regola business all'applicazione usando i metodi parziali, vedere gli argomenti seguenti:For more information about how to add business logic to your application by using partial methods, see the following topics:

Procedura: Aggiungere la convalida a classi di entitàHow to: Add validation to entity classes

Procedura dettagliata: personalizzazione del comportamento di inserimento, aggiornamento ed eliminazione delle classi di entitàWalkthrough: Customizing the insert, update, and delete behavior of entity classes

Procedura dettagliata: Aggiunta della convalida alle classi di entitàWalkthrough: Adding Validation to Entity Classes

Vedere ancheSee Also

Classi e metodi parzialiPartial Classes and Methods
Metodi parzialiPartial Methods
Strumenti LINQ to SQL in Visual StudioLINQ to SQL Tools in Visual Studio
SqlMetal.exe (strumento per la generazione del codice)SqlMetal.exe (Code Generation Tool)