Il modello a oggetti LINQ to SQL

In LINQ to SQL viene eseguito il mapping di un modello a oggetti espresso nel linguaggio di programmazione dello sviluppatore al modello dati di un database relazionale. Le operazioni sui dati vengono quindi eseguite in base al modello a oggetti.

In questo scenario non vengono eseguiti comandi di database, ad esempio INSERT, sul database, bensì vengono modificati valori ed eseguiti metodi all'interno del modello a oggetti. Quando si desidera eseguire una query sul database o inviare modifiche al database, LINQ to SQL converte le richieste in comandi SQL corretti che vengono quindi inviati al database.

Nella tabella seguente sono riepilogati gli elementi più importanti nel modello a oggetti di LINQ to SQL e le relative relazioni con gli elementi nel modello dati relazionale:

Modello a oggetti LINQ to SQL	Modello dati relazionale
Classe di entità	Tabella
Membro di classe	Colonna
Associazione	Relazione di chiave esterna
Metodo	Stored procedure o funzione

Nota
Nelle descrizioni seguenti si presuppone una conoscenza di base del modello dati relazionale e delle regole.

Classi di entità LINQ to SQL e tabelle di database

In LINQ to SQL una tabella di database è rappresentata da una classe di entità. Una classe di entità è analoga a qualsiasi altra classe creata dallo sviluppatore, con l'eccezione che per annotare la classe vengono utilizzate informazioni speciali che associano la classe a una tabella di database. Per creare tale annotazione, aggiungere un attributo personalizzato (TableAttribute) alla dichiarazione della classe, come nell'esempio seguente:

Esempio

<Table(Name:="Customers")> _
Public Class Customer
    Public CustomerID As String
    ' ...
    Public City As String
End Class

[Table(Name = "Customers")]
public class Customerzz
{
    public string CustomerID;
    // ...
    public string City;
}

Solo le istanze delle classi dichiarate come tabelle, ovvero le classi di entità, possono essere salvate nel database.

Per ulteriori informazioni, vedere la sezione relativa all'attributo Table di Mapping basato su attributo (LINQ to SQL).

Membri di classe LINQ to SQL e colonne di database

Oltre all'associazione delle classi con le tabelle, è necessario definire i campi o le proprietà per rappresentare le colonne del database. A questo scopo in LINQ to SQL viene definito l'attributo ColumnAttribute, come nell'esempio seguente:

Esempio

<Table(Name:="Customers")> _
Public Class Customer
    <Column(IsPrimaryKey:=True)> _
    Public CustomerID As String

    <Column()> _
    Public City As String
End Class

[Table(Name = "Customers")]
public class Customer
{
    [Column(IsPrimaryKey = true)]
    public string CustomerID;
    [Column]
    public string City;
}

Solo i campi e le proprietà di cui è stato eseguito il mapping alle colonne vengono salvati in modo permanente o recuperati dal database. Quelli non dichiarati come colonne vengono considerati parti temporanee della logica dell'applicazione.

All'attributo ColumnAttribute sono associate diverse proprietà che è possibile utilizzare per personalizzare i membri che rappresentano colonne, ad esempio definendo un membro che rappresenta una colonna di chiave primaria. Per ulteriori informazioni, vedere la sezione relativa all'attributo Column di Mapping basato su attributo (LINQ to SQL).

Associazioni LINQ to SQL e relazioni di chiave esterna del database

In LINQ to SQL per rappresentare associazioni di database, ad esempio relazioni da chiave esterna a chiave primaria, viene applicato l'attributo AssociationAttribute. Nel segmento di codice seguente la classe Order contiene una proprietà Customer con un attributo AssociationAttribute. Questa proprietà e il relativo attributo forniscono la classe Order con una relazione alla classe Customer.

Nell'esempio di codice riportato di seguito viene illustrata la proprietà Customer della classe Order.

Esempio

    <Association(Name:="FK_Orders_Customers", Storage:="_Customer", ThisKey:="CustomerID", IsForeignKey:=true)>  _
    Public Property Customer() As Customer
        Get
            Return Me._Customer.Entity
        End Get
        Set
            Dim previousValue As Customer = Me._Customer.Entity
            If (((previousValue Is value)  _
                        = false)  _
                        OrElse (Me._Customer.HasLoadedOrAssignedValue = false)) Then
                Me.SendPropertyChanging
                If ((previousValue Is Nothing)  _
                            = false) Then
                    Me._Customer.Entity = Nothing
                    previousValue.Orders.Remove(Me)
                End If
                Me._Customer.Entity = value
                If ((value Is Nothing)  _
                            = false) Then
                    value.Orders.Add(Me)
                    Me._CustomerID = value.CustomerID
                Else
                    Me._CustomerID = CType(Nothing, String)
                End If
                Me.SendPropertyChanged("Customer")
            End If
        End Set
    End Property

    [Association(Name="FK_Orders_Customers", Storage="_Customer", ThisKey="CustomerID", IsForeignKey=true)]
    public Customer Customer
    {
        get
        {
            return this._Customer.Entity;
        }
        set
        {
            Customer previousValue = this._Customer.Entity;
            if (((previousValue != value) 
                        || (this._Customer.HasLoadedOrAssignedValue == false)))
            {
                this.SendPropertyChanging();
                if ((previousValue != null))
                {
                    this._Customer.Entity = null;
                    previousValue.Orders.Remove(this);
                }
                this._Customer.Entity = value;
                if ((value != null))
                {
                    value.Orders.Add(this);
                    this._CustomerID = value.CustomerID;
                }
                else
                {
                    this._CustomerID = default(string);
                }
                this.SendPropertyChanged("Customer");
            }
        }
    }

Per ulteriori informazioni, vedere la sezione relativa all'attributo Association di Mapping basato su attributo (LINQ to SQL).

Metodi LINQ to SQL e stored procedure di database

LINQ to SQL supporta stored procedure e funzioni definite dall'utente. In LINQ to SQL viene eseguito il mapping di queste astrazioni definite dal database agli oggetti client in modo che sia possibile accedervi in modo fortemente tipizzato dal codice client. Le firme del metodo sono quanto più possibile simili alle firme delle procedure e delle funzioni definite nel database. Per individuare questi metodi è possibile utilizzare IntelliSense.

Un set di risultati restituito da una chiamata a una procedura con mapping è una raccolta fortemente tipizzata.

LINQ to SQL esegue il mapping di stored procedure e funzioni ai metodi utilizzando gli attributi FunctionAttribute e ParameterAttribute. I metodi che rappresentano stored procedure si differenziano da quelli che rappresentano funzioni definite dall'utente per la proprietà IsComposable. Se questa proprietà è impostata su false, che corrisponde all'impostazione predefinita, il metodo rappresenta una stored procedure. Se è impostata su true, il metodo rappresenta una funzione di database.

Nota
Se si utilizza Visual Studio, è possibile adoperare Object Relational Designer per creare metodi con mapping a stored procedure e funzioni definite dall'utente.

Esempio

   ' This is an example of a stored procedure in the Northwind
   ' sample database. The IsComposable property defaults to false.
   <FunctionAttribute(Name:="dbo.CustOrderHist")> _
Public Function CustOrderHist(<Parameter(Name:="CustomerID", DbType:="NChar(5)")> ByVal customerID As String) As ISingleResult(Of CustOrderHistResult)
       Dim result As IExecuteResult = Me.ExecuteMethodCall(Me, CType(MethodInfo.GetCurrentMethod, MethodInfo), customerID)
       Return CType(result.ReturnValue, ISingleResult(Of CustOrderHistResult))
   End Function

    // This is an example of a stored procedure in the Northwind
    // sample database. The IsComposable property defaults to false.
    [Function(Name="dbo.CustOrderHist")]
    public ISingleResult<CustOrderHistResult> CustOrderHist([Parameter(Name="CustomerID", DbType="NChar(5)")] string customerID)
    {
        IExecuteResult result = this.ExecuteMethodCall(this, ((MethodInfo)(MethodInfo.GetCurrentMethod())), customerID);
        return ((ISingleResult<CustOrderHistResult>)(result.ReturnValue));
    }

Per ulteriori informazioni, vedere le sezioni relative agli attributi per funzioni, stored procedure e parametri di Mapping basato su attributo (LINQ to SQL) e Stored procedure (LINQ to SQL).

Vedere anche

Riferimenti

Mapping basato su attributo (LINQ to SQL)

Altre risorse

Informazioni complementari (LINQ to SQL)