Entity Framework: introduzione e caratteristiche

Entity Framework è il framework ORM (object-relational mapping) messo a disposizione dal .NET Framework: il compito svolto dagli ORM è quello di nasconderci il funzionamento di un database relazionale, permetterci di pensare al nostro modello dei dati come ad un insieme di oggetti.

Entity Framework non è l'unico strumento di questo tipo che troviamo nel mondo .NET, basti pensare a progetti come NHibernate e Castle ActiveRecord, ma è l'ORM ufficiale di Microsoft, il che offre diversi vantaggi soprattutto in termini di integrazione con gli strumenti di sviluppo (Visual studio in primis).

In questo articolo esaminiamo le principali caratteristiche del tool mostrando come costruire una semplice applicazione Web.

Lavorare sul dominio Entity Framework

Entity Framework ci consente quindi di definire un modello per rappresentare il dominio dell'applicazione. Questo modello prende il nome di Conceptual Model o Entity Data Model.

La cosa interessante è che nel definire il modello possiamo quasi ignorare i dettagli sull'immagazzinamento dei dati: interrogheremo semplicemente gli oggetti e sarà Entity Framework a renderli persistenti sul DB trasformando le nostre azioni in query interpretabili dal DBMS.

I vantaggi di questo approccio sono abbastanza chiari:

• possiamo lavorare su un livello di astrazione più alto, definire e manipolare le entità di cui abbiamo bisogno senza entrare nel merito della rappresentazione dei dati fisici
• disaccoppiamento tra applicazione e logica di accesso alle sorgenti di dati, quindi indipendenza dal DBMS: possiamo continuare ad utilizzare lo stesso modello concettuale anche se il modello fisico cambia, ad esempio se la nostra base di dati passasse da SQL Server ad Oracle dovremmo solo chiedere all'Entity Framework di rieffettuare il mapping col modello concettuale esistente

Modello di dominio, modello logico, modello fisico

Prima di iniziare a programmare è utile fare chiarezza sulle differenze tra questi modelli nella terminologia usata nell'Entity Framework:

• il modello di dominio, chiamato Conceptual Model nell'Entity Framework, definisce le entità e le relazioni del sistema che si sta modellando
• il modello logico, chiamato Storage Model nell'Entity Framework, definisce le tabelle e le relazioni tra esse in un database
• il modello fisico specifica le caratteristiche fisiche di un motore dati come la capacità di partizionamento, di indicizzazione dei dati, ecc.

Il modello fisico è maneggiato dai DBA per migliorare le performance del database, i programmatori invece lavorano sul modello logico scrivendo query SQL. Attraverso l'Entity Framework i programmatori possono lavorare direttamente sul modello concettuale poiché il mapping col modello logico è svolto dall'Entity Framework.

Il modello concettuale, il modello logico ed il mapping tra i due sono espressi nell'Entity Framework attraverso schemi XML che prendono il nome di:

• Conceptual Schema Definition Language (CSDL): il CSDL permette di definire l'Entity Data Model
• Store Schema Definition Language (SSDL): lo SSDL definisce il modello logico
• Mapping Specification Language (MSL): definisce il mapping tra il modello concettuale ed il modello logico

Insieme ad Entity Framework abbiamo a disposizione l'Entity Data Model Wizard, un tool per costruire questi schemi in modo automatico.

Il modello logico ed il mapping possono cambiare senza che subisca modifiche il modello concettuale o il codice applicativo. Il modello logico è strettamente legato ad un provider questo fa si che un modello concettuale possa lavorare su diverse sorgente dati.

Per trasformare le operazioni sugli oggetti del modello concettuale in query specifiche della sorgente dati utilizzata, Entity Framework utilizza l'Entity Client Data Provider. Questo provider maneggia le connessioni, traduce le query sulle entità in query sui dati e restituisce i risultati sotto forma di oggetti.

Dalla figura si nota che l'Entity Client Data Provider estende l'ADO.NET data provider consentendoci di astrarre sulle entità del modello concettuale e comporre le query usando il linguaggio Linq to Entities.

Nella seconda parte dell'articolo passeremo dalla teoria alla pratica realizzando una applicazione d'esempio.

La prima applicazione con Entity Framework

Iniziamo finalmente a mettere in pratica quanto abbiamo detto fin'ora. Realizziamo, quindi, una applicazione Web che costruisca un modello concettuale su un database Sql Server e che interroghi tale modello per presentare i dati attraverso un semplice form .

Usiamo un database con una tabella degli Scrittori ed una tabella dei Libri e realizziamo una pagina Web che consente di selezionare uno scrittore da un menu a tendina, popolato con tutti gli scrittori della tabella, e che visualizza in una gridview tutti i libri scritti dallo scrittore selezionato.

Creiamo l'Entity Data Model

Apriamo Visual Studio, creiamo un nuovo sito Web e aggiungiamo al progetto un nuovo elemento. Quando si apre la finestra per inserire un nuovo elemento scegliamo l'Entity Data Model Template.

Anzitutto diamo un nome al modello, l'estensione del file sarà .edmx. Il secondo passo da compiere è scegliere se creare il modello da zero o da un database esistente. Scegliamo di partire da un database esistente e utilizziamo il database di esempio pubs.mdf (che abbiamo in allegato al progetto).

Le tabelle coinvolte nella nostra applicazione sono: Author, Title e TitleAuthor. Queste tabelle rappresentano rispettivamente autori, testi e la relazione tra gli autori e i loro testi.

Selezioniamo infine le checkbox Rendi plurali o singolari i nomi degli oggetti generati ed Includi colonne di chiavi esterne nel modello. In figura vediamo l'Entity Model generato.

Nella finestra in alto a sinistra (Entity Designer) vediamo le entità corrispondenti alle tre tabelle selezionate. Le entità hanno delle proprietà corrispondenti alle colonne delle tabelle.

L'Entity Framework ha individuato due associazioni "uno a molti" che legano le tre tabelle. Le entità hanno anche delle proprietà di navigazione, ad esempio l'entità titleauthor possiede le proprietà:

• author che la collega all'entità author
• title che la collega all'entità title

Scopriremo tra poco come utilizzare queste proprietà di navigazione.

L'immagine mostra anche una struttura ad albero che prende il nome di Browser modello che rappresenta l'Entity Model in tutte le sue componenti (entità, tabelle, associazioni). Notiamo, infine, una apposita finestra che riporta i dettagli del mapping tra le entità e le tabelle.

L'Entity Data Model viene salvato in un file con estensione .edmx, un file XML che contiene le sezioni CSDL, SSDL e MSL di cui abbiamo parlato in precedenza. Per capire come è composto file .edmx può essere interessante aprirne uno con un semplice editor di testi.

Interrogare le entità con LINQ to Entities

Una volta definito l'Entity Model vediamo come interrogarlo. Cominciamo con il caricare un menu a tendina con la lista di tutti gli autori:

pubsModel.pubsEntities pubs = new pubsModel.pubsEntities();
var AutoriQuery = from a in pubs.authors
orderby a.au_lname
select a;
ddlAutori.DataTextField = "au_lname";
ddlAutori.DataValueField = "au_id";
ddlAutori.DataSource = AutoriQuery;
ddlAutori.DataBind();

Anzitutto creiamo un'istanza dell'entity model. Un entity model eredita dalla classe System.Data.Objects.ObjectContext. Questa classe ha lo scopo di fornire l'accesso alle entità del modello e di effettuare il mapping con la sorgente dati.

Poi, per mezzo di Linq to Entities, facciamo una query sulla entità authors chiedendo la lista degli autori ordinata per cognome.

La variabile AutoriQuery viene valorizzata con la lista di entità authors trovate. Assegniamo quindi la lista al datasource del menu a tendina. Il gioco è fatto; con pochissime righe di codice abbiamo fatto una query e valorizzato il controllo server che deve visualizzare il risultato.

Come secondo esempio vediamo come riempire una gridview con l'elenco dei testi scritti dall'autore selezionato nel menu a tendina precedente:

protected void btnLista_Click(object sender, EventArgs e)
{
pubsModel.pubsEntities pubs = new pubsModel.pubsEntities();
var titoliQuery = from ta in pubs.titleauthors
where ta.au_id == ddlAutori.SelectedValue
select ta.title;
gvLibri.DataSource = titoliQuery;
gvLibri.DataBind();
}

Anche in questo caso la prima cosa da fare è creare un'istanza dell'entity model. Tramite Linq to Entities facciamo una query sull'entità titleauthors chiedendo i testi del'autore scelto nel menu a tendina.

Se avessimo scritto una query SQL avremmo dovuto effettuare una join tra la tabella titleauthors e la tabella title, usando l'entity model invece abbiamo potuto sfruttare la proprietà di navigazione title dell'entità titleauthors. Anche in questo caso con poche righe di codice abbiamo ottenuto una query complessa e popolato il controllo server.

Conclusioni su Entity Framework

Abbiamo visto come ADO.NET Entity Framework permetta di realizzare un modello concettuale e di interrogare direttamente le entità del dominio senza dover realizzare query SQL sul modello logico.

Uno dei punti di forza dell'ORM sono i tool di Visual Studio che forniscono pannelli e percorsi guidati per realizzare il modello concettuale in modo intuitivo.

Infine Linq to Entities consente di scrivere delle query complesse con uno sforzo minimo ed è abbastanza evoluto da consentire mapping avanzati come il table-per-hierarchy ed il table-per-type.