Guida: Modello di oggetti semplice e query (C#)

Questa procedura dettagliata fornisce uno scenario LINQ to SQL end-to-end fondamentale con complessità minime. Verrà creata una classe di entità che modella la tabella Customers nel database Northwind di esempio. Si creerà quindi una semplice query per elencare i clienti che si trovano a Londra.

Questa procedura dettagliata è orientata al codice per illustrare i concetti di LINQ to SQL. In genere, si usa Progettazione relazionale oggetti per creare il modello a oggetti.

Annotazioni

Il computer potrebbe visualizzare nomi o percorsi diversi per alcuni degli elementi dell'interfaccia utente di Visual Studio nelle istruzioni seguenti. L'edizione di Visual Studio disponibile e le impostazioni usate determinano questi elementi. Per altre informazioni, vedere Personalizzazione dell'IDE.

Questa procedura dettagliata è stata scritta usando le impostazioni di sviluppo di Visual C#.

Prerequisiti

Questa procedura dettagliata usa una cartella dedicata ("c:\linqtest5") per contenere i file. Creare questa cartella prima di iniziare la procedura dettagliata.
Questa procedura dettagliata richiede il database di esempio Northwind. Se questo database non è disponibile nel computer di sviluppo, è possibile scaricarlo dal sito di download Microsoft. Per istruzioni, consultare Scaricare i database di esempio. Dopo aver scaricato il database, copiare il file nella cartella c:\linqtest5.

Informazioni generali

Questa procedura dettagliata è costituita da sei attività principali:

Creazione di una soluzione LINQ to SQL in Visual Studio.
Mappatura di una classe su una tabella di database.
Attribuire proprietà sulla classe per rappresentare le colonne del database.
Specificare la connessione al database Northwind.
Creazione di una query semplice da eseguire sul database.
Esecuzione della query e osservazione 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

Scegliere Nuovo dal menu File di Visual Studio e quindi fare clic su Progetto.
Nel riquadro Tipi di progetto della finestra di dialogo Nuovo progetto fare clic su Visual C#.
Nel riquadro Modelli fare clic su Applicazione console.
Nella casella Nome digitare LinqConsoleApp.
Nella casella Percorso verificare dove archiviare i file di progetto.
Fare clic su OK.

Aggiunta di riferimenti e direttive LINQ

Questa procedura dettagliata utilizza assembly che potrebbero non essere installati di default nel tuo progetto. Se System.Data.Linq non è elencato come riferimento nel progetto (espandere il nodo Riferimenti in Esplora soluzioni), aggiungerlo, come illustrato nei passaggi seguenti.

Per aggiungere System.Data.Linq

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

Il componente viene aggiunto al progetto.
Aggiungere le direttive seguenti nella parte superiore di Program.cs:
```
using System.Data.Linq;
using System.Data.Linq.Mapping;
```

Mappatura di una classe su una tabella di database

In questo passaggio viene creata una classe e ne viene eseguito il mapping a una tabella di database. Tale classe è definita classe di entità. Si noti che il mapping viene eseguito semplicemente aggiungendo l'attributo TableAttribute . La Name proprietà specifica il nome della tabella nel database.

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

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

Definizione delle proprietà della classe per rappresentare le colonne del database

In questo passaggio vengono eseguite diverse attività.

Usi l'attributo ColumnAttribute per designare le proprietà CustomerID e City nella classe di entità come rappresentanti delle colonne nella tabella del database.
Disegni la proprietà CustomerID per rappresentare una colonna chiave primaria nel database.
Si designano i campi _CustomerID e _City per l'archiviazione privata. LINQ to SQL può quindi archiviare e recuperare i valori direttamente, anziché usare funzioni di accesso pubbliche che potrebbero includere la logica di business.

Per rappresentare le caratteristiche di due colonne di database

Digitare o incollare il codice seguente in Program.cs all'interno delle parentesi graffe per la 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;
    }
}

Specificare la connessione al database Northwind

In questo passaggio si usa un DataContext oggetto per stabilire una connessione tra le strutture di dati basate su codice e il database stesso. DataContext è il canale principale tramite il quale si recuperano oggetti dal database e si inviano modifiche.

Si dichiara anche un oggetto Table<Customer> che funge da tabella logica e tipizzata per le query sulla tabella Clienti nel database. Queste query verranno create ed eseguite nei passaggi successivi.

Per specificare la connessione al database

Digitare o incollare il codice seguente nel Main metodo .

Si noti che si presuppone che il northwnd.mdf file si trova nella cartella linqtest5. Per altre informazioni, vedere la sezione Prerequisiti più indietro in questa procedura dettagliata.
```
// 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 individuare i clienti nella tabella Clienti del database che si trovano a Londra. Il codice della query in questo passaggio descrive semplicemente la query. Non lo esegue. Questo approccio è noto come esecuzione posticipata. Per altre informazioni, vedere Introduzione alle query LINQ (C#).

Verrà inoltre generato un output del log per visualizzare i comandi SQL generati da LINQ to SQL. Questa funzionalità di registrazione (che usa Log) è utile per 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 Main metodo dopo la Table<Customer> dichiarazione.

// 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 si esegue effettivamente la query. Le espressioni di query create nei passaggi precedenti non vengono valutate fino a quando non sono necessari i risultati. 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 Main metodo (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.

Annotazioni

Se l'applicazione genera un errore di runtime, vedere la sezione Risoluzione dei problemi di Learning by Walkthroughs.

I risultati della query nella finestra della console dovrebbero essere visualizzati nel modo seguente:

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#) prosegue da dove termina questa guida. 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.

Per eseguire la procedura dettagliata sulla Query Across Relationships, assicurati di salvare la soluzione per la procedura dettagliata appena completata, poiché è un requisito preliminare.

Vedere anche

Apprendimento tramite Soluzioni Guidate

Last updated on 2025-06-17

Condividi tramite