Procedura dettagliata: modello a oggetti e query semplici (C#) (LINQ to SQL)

Articolo
04/27/2011

In questa procedura dettagliata viene descritto uno scenario LINQ to SQL end-to-end di base con minime complessità. Verranno create una classe di entità per la modellazione della tabella Customers nel database Northwind di esempio, quindi una semplice query per elencare i clienti residenti nell'area londinese.

Questa procedura dettagliata è basata sul codice in fase di progettazione per illustrare i concetti di LINQ to SQL. Normalmente per creare il modello a oggetti si utilizza Object Relational Designer. Per ulteriori informazioni, vedere Progettazione relazionale oggetti e Progettazione relazionale oggetti e Progettazione relazionale oggetti.

Nota
Nel computer in uso è possibile che vengano visualizzati nomi o percorsi diversi per alcuni elementi dell'interfaccia utente di Visual Studio nelle istruzioni seguenti. La versione di Visual Studio in uso e le impostazioni configurate determinano questi elementi. Per ulteriori informazioni vedere Impostazioni di Visual Studio.

Questa procedura è stata scritta utilizzando Impostazioni di sviluppo di Visual C#.

Prerequisiti

Per i file utilizzati nella procedura dettagliata viene utilizzata una cartella dedicata ("c:\linqtest5"). Creare la cartella prima di avviare la procedura.
Per questa procedura dettagliata è richiesto il database di esempio Northwind. Se questo database non è disponibile nel computer di sviluppo, è possibile scaricarlo dal sito di download Microsoft. Per istruzioni, vedere Download dei database di esempio (LINQ to SQL). Dopo avere scaricato il database, copiare il file nella cartella c:\linqtest5.

Panoramica

La procedura dettagliata è costituita da sei attività principali:

Creazione di una soluzione LINQ to SQL in Visual Studio.
Mapping di una classe a una tabella del database.
Definizione di proprietà nella classe per rappresentare colonne del database.
Definizione della connessione al database Northwind.
Creazione di una semplice query da eseguire sul database.
Esecuzione della query e analisi dei risultati.

Creazione di una soluzione LINQ to SQL

In questa prima attività verrà creata una soluzione Visual Studio che contiene i riferimenti necessari per compilare ed eseguire un progetto LINQ to SQL.

Per creare una soluzione LINQ to SQL

In Visual Studio scegliere Nuovo dal menu File, quindi Progetto.
Nella finestra di dialogo Nuovo progetto selezionare Visual C# nel riquadro Tipi progetto.
Nel riquadro Modelli fare clic su Applicazione console.
Nella casella Nome digitare LinqConsoleApp.
Nella casella Percorso verificare il percorso per l'archiviazione dei file di progetto.
Scegliere OK.

Aggiunta di riferimenti e direttive LINQ

In questa procedura dettagliata vengono utilizzati assembly che potrebbero non essere installati per impostazione predefinita nel progetto. Se System.Data.Linq non viene elencato come riferimento nel progetto espandendo il nodo Riferimenti in Esplora soluzioni, aggiungerlo come spiegato nella procedura seguente.

Per aggiungere System.Data.Linq

In Esplora soluzioni fare clic con il pulsante destro del mouse su Riferimenti, quindi scegliere Aggiungi riferimento.
Nella finestra di dialogo Aggiungi riferimento fare clic su .NET, fare clic sull'assembly System.Data.Linq, quindi scegliere OK.

L'assembly verrà aggiunto al progetto.

Aggiungere le seguenti direttive all'inizio di Program.cs:

using System.Data.Linq;
using System.Data.Linq.Mapping;

Mapping di una classe a una tabella del database

In questo passaggio verrà creata una classe ed eseguito il mapping della classe a una tabella di database. Tale classe è detta classe di entità. Notare che il mapping viene eseguito semplicemente aggiungendo l'attributo TableAttribute. La proprietà Name consente di specificare il nome della tabella nel database.

Per creare una classe di entità ed eseguire il mapping della classe a una tabella di database

Digitare o incollare il codice seguente in Program.cs immediatamente sopra la dichiarazione della classe Program:
```
[Table(Name = "Customers")]
public class Customer
{
}
```

Definizione di proprietà nella classe per rappresentare colonne del database

In questo passaggio si completeranno diverse attività.

Utilizzare l'attributo ColumnAttribute per definire le proprietà CustomerID e City nella classe di entità in modo che rappresentino colonne nella tabella del database.
Definire la proprietà CustomerID in modo che rappresenti una colonna di chiave primaria nel database.
Definire i campi _CustomerID e _City per l'archiviazione privata. LINQ to SQL sarà quindi in grado di archiviare e recuperare direttamente i valori, anziché utilizzare funzioni di accesso pubbliche che potrebbero includere la logica di business.

Per rappresentare caratteristiche di due colonne del database

Digitare o incollare il codice seguente in Program.cs all'interno delle parentesi graffe della classe Customer:

private string _CustomerID;
[Column(IsPrimaryKey=true, Storage="_CustomerID")]
public string CustomerID
{
    get
    {
        return this._CustomerID;
    }
    set
    {
        this._CustomerID = value;
    }

}

private string _City;
[Column(Storage="_City")]
public string City
{
    get
    {
        return this._City;
    }
    set
    {
        this._City=value;
    }
}

Definizione della connessione al database Northwind

In questo passaggio viene utilizzato un oggetto DataContext per stabilire una connessione tra le strutture di dati basate sul codice e il database stesso. DataContext è il canale principale tramite il quale vengono recuperati oggetti dal database e vengono inviate modifiche.

Viene inoltre dichiarato un oggetto Table<Customer> che fungerà da tabella tipizzata logica per le query sulla tabella Customers nel database. Tali query verranno quindi create ed eseguite nei passaggi successivi.

Per specificare la connessione al database

Digitare o incollare il codice seguente nel metodo Main:

Si presuppone che il file northwnd.mdf si trovi nella cartella linqtest5. Per ulteriori informazioni, vedere la sezione precedente relativa ai prerequisiti.
```
// Use a connection string.
DataContext db = new DataContext
    (@"c:\linqtest5\northwnd.mdf");

// Get a typed table to run queries.
Table<Customer> Customers = db.GetTable<Customer>();
```

Creazione di una query semplice

In questo passaggio viene creata una query per cercare i clienti nella tabella di database Customers residenti nell'area londinese. Il codice della query in questo passaggio descrive semplicemente la query, ma non la esegue. Questo approccio è noto come esecuzione posticipata. Per ulteriori informazioni, vedere Introduzione alle query LINQ (C#).

Verrà inoltre prodotto un output del log per mostrare i comandi SQL generati da LINQ to SQL. Questa funzionalità di registrazione, che utilizza Log, è utile per eseguire il debug e per determinare che i comandi inviati al database rappresentano accuratamente la query.

Per creare una query semplice

Digitare o incollare il codice seguente nel metodo Main dopo la dichiarazione Table<Customer>.

// Attach the log to show generated SQL.
db.Log = Console.Out;

// Query for customers in London.
IQueryable<Customer> custQuery =
    from cust in Customers
    where cust.City == "London"
    select cust;

Esecuzione della query

In questo passaggio verrà effettivamente eseguita la query. Le espressioni di query create nei passaggi precedenti non vengono valutate finché i risultati non saranno necessari. Quando si inizia l'iterazione foreach, viene eseguito un comando SQL sul database e gli oggetti vengono materializzati.

Per eseguire la query

Digitare o incollare il codice seguente alla fine del metodo Main dopo la descrizione della query.

foreach (Customer cust in custQuery)
{
    Console.WriteLine("ID={0}, City={1}", cust.CustomerID,
        cust.City);
}

// Prevent console window from closing.
Console.ReadLine();

‎Premere F5 per eseguire il debug dell'applicazione.

Nota

Se l'applicazione genera un errore di runtime, vedere la sezione relativa alla risoluzione dei problemi di Apprendimento tramite le procedure dettagliate (LINQ to SQL).

I risultati della query nella finestra della console dovrebbero avere il seguente aspetto:

ID=AROUT, City=London

ID=BSBEV, City=London

ID=CONSH, City=London

ID=EASTC, City=London

ID=NORTS, City=London

ID=SEVES, City=London
Premere INVIO nella finestra della console per chiudere l'applicazione.

Nota
Se l'applicazione genera un errore di runtime, vedere la sezione relativa alla risoluzione dei problemi di Apprendimento tramite le procedure dettagliate (LINQ to SQL).

Passaggi successivi

L'argomento Procedura dettagliata: query tra relazioni (C#) (LINQ to SQL) continua dal punto in cui termina questa procedura dettagliata. In tale procedura dettagliata viene dimostrato come sia possibile eseguire una query tra tabelle in LINQ to SQL, in modo analogo ai join in un database relazionale.

Se si desidera eseguire la procedura dettagliata relativa all'esecuzione di query tra relazioni, è indispensabile salvare la soluzione per la procedura dettagliata appena completata.

Vedere anche

Concetti

Apprendimento tramite le procedure dettagliate (LINQ to SQL)

Condividi tramite