Procedura dettagliata: Modello a oggetti e query semplici (C#)

Articolo
12/15/2023

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. In genere, si usa Object Relational Designer per creare il modello di oggetti.

Nota

I nomi o i percorsi visualizzati per alcuni elementi dell'interfaccia utente di Visual Studio nelle istruzioni seguenti potrebbero essere diversi nel computer in uso. La versione di Visual Studio in uso e le impostazioni configurate determinano questi elementi. Per altre informazioni, vedere Personalizzazione dell'IDE.

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

Prerequisiti

Per i file usati nella procedura dettagliata viene usata 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 di database di esempio. 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à si crea una soluzione di Visual Studio contenente 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 fare clic su 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 Posizione verificare il percorso per l'archiviazione dei file di progetto.
Fare clic su OK.

Aggiunta di riferimenti e direttive LINQ

In questa procedura dettagliata vengono usati 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à.

Usare 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é usare 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 usato 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 altre 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 altre informazioni, vedere Introduzione alle query LINQ (C#).

Verrà anche prodotto un output del log per mostrare i comandi SQL generati da LINQ to SQL. Questa funzionalità di registrazione, che usa 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 run-time, vedere la sezione Risoluzione dei problemi di Learning by Walkthroughs.

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.

Passaggi successivi

L'argomento Procedura dettagliata: Esecuzione di query tra relazioni (C#) continua dove termina questa procedura dettagliata. La procedura dettagliata Query tra relazioni illustra in che modo LINQ to SQL può eseguire query tra tabelle, 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.

Vedi anche

Apprendimento tramite procedure dettagliate

Condividi tramite