Nel mondo del web stanno prendendo sempre più piede le Single Page Applications (SPA d'ora in poi). Queste applicazioni prevedono che ci sia una pagina che fa da host e all'interno di questa vengano caricate delle view che rappresentano le nostre form e dei file javascript che gestiscono la view e l'accesso ai dati sul server. Questo caricamento avviene via JavaScript così che l'utente non debba mai vedere postback o refresh della pagina. Poiché queste applicazioni non causano mai postback e refresh, è normale che per accedere ai dati utilizzino AJAX.

Quando partiamo con lo sviluppo di questo tipo di applicazioni, l'utilizzo delle Web API di ASP.NET MVC è una scelta ottimale. In questo caso torna sicuramente utile l'utilizzo del framework BreezeJS che grazie a una libreria JavaScript e ad alcune estensioni lato server apposite per le Web API ci permettono di accedere ai dati in maniera molto semplice, efficace e potente. Una volta finito di leggere questo articolo è consigliabile In questo articolo vedremo come sfruttare la libreria BreezeJS sia lato client che lato server.

Lato Client, BreezeJS è una libreria JavaScript che introduce un simil O/RM sul client. BreezeJS infatti ha il concetto di entity, di contesto, di change tracking, di navigation properties che sono tipiche degli O/RM. Quando BreezeJS recupera una entity tramite un servizio, BreezeJS mantiene l'entity in memoria e, se ne modifichiamo le proprietà, traccia le modifiche. Quando decidiamo di salvare le entity modificate, BreezeJS prende tutte le entity modificate e le invia al servizio. Per rendere il tutto ancora più attraente, BreezeJS supporta il protocollo OData e quindi si può integrare con servizi REST che supportano questo protocollo. Volendo offrire una definizione della libreria client, BreezeJS è una libreria che introduce un O/RM lato client e che utilizza un set di servizi per gestire la persistenza delle entity.

Lato server, la libreria BreezeJS contiene filtri ed estensioni che si integrano con le Web API di ASP.NET MVC per introdurre il parsing OData. Inoltre, BreezeJS introduce una classe che una volta recuperate le query OData o le entity da persistere, si interfaccia con Entity Framework gestendo tutta la fase di aggiornamento per noi. Grazie a queste estensioni, esporre i dati con OData e interfacciarsi con Entity Framework è semplice come non lo è mai stato finora.

Esporre i dati tramite le Web API

Le Web API permettono in maniera molto semplice di esporre i dati. Infatti, tramite queste, non dobbiamo preoccuparci di serializzare i dati in entrata e in uscita quindi dobbiamo occuparci solamente di scrivere il nostro codice di business.

Nel nostro caso, le nostre Web API devono esporre i dati della tabella Customer del database Northwind. Per fare questo dobbiamo creare un modello di Entity Framework e importare la tabella Customes così da ottenere il designer come mostrato nella figura 1.

Una volta generato il modello con Entity Framework, dobbiamo creare le nostre Web API. Per fare questo creiamo un Web API controller nel nostro progetto ASP.NET MVC e lo decoriamo con l'attributo BreezeController. Successivamente istanziamo un oggetto di tipo EFContextProvider visibile a livello di controller. Quest'oggetto rappresenta il bridge tra BreezeJS ed Entity Framework. Quest'oggetto si occupa di trasformare le query OData in query valide per Entity Framework, è anche di trasformare le entity dal formato JSON al formato di Entity Framework quando il client le rinvia al server per il salvataggio. Grazie a quest'oggetto, leggere e persistere dati è estremamente banale.

Il codice del controller fino a questo punto è visibile nel prossimo esempio.

 [BreezeController]
public class NorthwindController : ApiController
{
  readonly EFContextProvider<northwindEntities> _contextProvider =
    new EFContextProvider<northwindEntities>(); 
}

A questo punto abbiamo l'infrastruttura necessaria per cominciare a scrivere i metodi del nostro controller. Il primo metodo che dobbiamo creare è quello per esporre i clienti e il relativo codice è visibile nel frammento successivo.

[HttpGet]
public IQueryable<Customer> Customers()
{
  return _contextProvider.Context.Customers;
}

Ci sono due cose molto importanti da notare in questo metodo. La prima è che il metodo restituisce il DbSet dei clienti esposto da Entity Framework (la proprietà Context del context provider di BreezeJS rappresenta il contesto di Entity Framework). La seconda è che l'oggetto restituito dal metodo non è una lista di oggetti (come normalmente ci si attende da un metodo delle Web API), bensì un oggetto IQueryable che non contiene la lista di tutti i clienti sul database, ma semplicemente una query che rappresenta i clienti. Successivamente tramite i filtri aggiunti dall'attributo BreezeController, le Web API recuperano la query OData passata dal client e la trasformano in una query per EF. Solo alla fine di questo processo viene realmente eseguita la query sul database e i dati vengono restituiti al client. Il vantaggio di questo approccio è che abbiamo a disposizione un solo metodo che espone i dati e il client è libero di eseguire tutte le query che gli servono. Se vogliamo applicare filtri a monte delle query generate con OData (come filtri di sicurezza in base all'utente) possiamo applicare questi filtri nel metodo e ritornare la query filtrata invece che direttamente il DbSet così come mostrato nel prossimo esempio dove viene applicato un filtro che ritorna solo i clienti italiani.

[HttpGet]
public IQueryable<Customer> Customers()
{
  return _contextProvider.Context.Customers.Where(c => c.Country == "Italy");
}

Creare il metodo che espone i dati è solo il primo passo per l'esposizione dei dati. Infatti, oltre a creare il metodo Customers, dobbiamo creare il metodo Metadata che espone i metadati relativi al modello che il client può interrogare. Grazie alla classe EFContextProvider, esporre i metadati è banale in quanto ci basta ritornare il risultato del metodo Metadata che attinge al contesto di Entity Framework per generare i metadati. Il codice del metodo Metadata è visibile nel prossimo esempio.

[HttpGet]
public string Metadata()
{
return _contextProvider.Metadata();
} 

A questo punto le Web API sono pronte per esporre i dati e possiamo passare al client.