Condividi tramite

Modello di 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 di dati di un database relazionale. Le operazioni sui dati vengono quindi eseguite in base al modello a oggetti.

In questo scenario non si eseguono comandi di database ,ad esempio INSERT, al database. Si modificano invece i valori ed eseguono metodi all'interno del modello a oggetti. Quando si desidera eseguire una query sul database o inviargli modifiche, LINQ to SQL converte le richieste nei comandi SQL appropriati e li invia al database.

Screenshot che mostra il modello a oggetti Linq.

Gli elementi più fondamentali nel modello a oggetti LINQ to SQL e la relativa relazione con gli elementi nel modello di dati relazionali sono riepilogati nella tabella seguente:

Modello di oggetti LINQ to SQL Modello di dati relazionali
Classe di entità Tabella
Membro della classe colonna
Associazione Relazione di chiave esterna
Metodo Procedura memorizzata o funzione

Annotazioni

Le descrizioni seguenti presuppongono che si disponga di una conoscenza di base del modello di 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à è come qualsiasi altra classe che è possibile creare, ad eccezione del fatto che si annota la classe usando informazioni speciali che associano la classe a una tabella di database. Per creare questa annotazione, aggiungere un attributo personalizzato (TableAttribute) alla dichiarazione di classe, come nell'esempio seguente:

Esempio

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

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

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

Per ulteriori informazioni, vedere la sezione degli attributi della tabella in Attribute-Based Mapping.

Colonne di database e membri della classe LINQ to SQL

Oltre all'associazione di classi alle tabelle, è possibile designare campi o proprietà per rappresentare le colonne di database. A questo scopo, LINQ to SQL definisce l'attributo ColumnAttribute , come nell'esempio seguente:

Esempio

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

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

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

Solo i campi e le proprietà mappati alle colonne vengono salvati in modo permanente o recuperati dal database. Le colonne non dichiarate sono considerate parti transitorie della logica della tua applicazione.

L'attributo ColumnAttribute ha un'ampia gamma di proprietà che è possibile usare per personalizzare questi membri che rappresentano colonne, ad esempio la progettazione di un membro come colonna chiave primaria. Per altre informazioni, vedere la sezione Attributo colonna di Attribute-Based Mapping.

Associazioni LINQ to SQL e relazioni tra chiavi esterne del database

In LINQ to SQL si rappresentano le associazioni di database, ad esempio la chiave esterna alle relazioni di chiave primaria, applicando l'attributo AssociationAttribute . Nel seguente segmento di codice, la Order classe contiene una Customer proprietà con un AssociationAttribute attributo. Questa proprietà e il relativo attributo forniscono alla Order classe una relazione con la Customer classe .

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

Esempio

[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");
        }
    }
}

<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

Per altre informazioni, vedere la sezione Association Attribute (Attributo di associazione) di Attribute-Based Mapping.

Metodi LINQ to SQL e le stored procedure del database

LINQ to SQL supporta procedure memorizzate e funzioni definite dall'utente. In LINQ to SQL è possibile eseguire 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 simili al più possibile alle firme delle procedure e delle funzioni definite nel database. È possibile usare IntelliSense per individuare questi metodi.

Un set di risultati restituito da una chiamata a una routine mappata è 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 le stored procedure sono distinti da quelli che rappresentano le funzioni definite dall'utente grazie alla proprietà IsComposable. Se questa proprietà è impostata su false (impostazione predefinita), il metodo rappresenta una stored procedure. Se è impostato su true, il metodo rappresenta una funzione di database.

Annotazioni

Se si usa Visual Studio, è possibile usare Progettazione relazionale oggetti per creare metodi mappati 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.
[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));
}

   ' 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

Per ulteriori informazioni, consultare le sezioni Attributo Funzione, Attributo Stored Procedure e Attributo Parametro di Attribute-Based Mapping e Stored Procedures.

Vedere anche

  • Last updated on