blogs.ASPItalia.com

PhoneGap e Titanium, esiste davvero il write once run anywhere su mobile?

Marco De Sanctis — Thu, 12 Jan 2012 08:30:00 GMT

Ultimamente si fa davvero un gran parlare di framework che consentono di sviluppare sulle varie piattaforme mobile, senza dover necessariamente scrivere codice nativo. Tra queste, probabilmente la pi� famosa � PhoneGap, ultimamente davvero non passa giorno senza che venga nominata da qualche parte, ma anche Appcelerator Titanium, seppur meno menzionato, recita in un ruolo di protagonista nell'ambito di questo genere di prodotti. Alcune settimane fa, con 5DLabs abbiamo fatto una serie di studi di fattibilit� in merito per conto di un cliente, e ho pensato di riportarvi un po' l'esperienza maturata.

Ma andiamo con ordine e spendiamo qualche parola su PhoneGap e Titanium per capire un po' meglio di cosa stiamo parlando. Iniziamo col dire che ambedue questi servono per sviluppare applicazioni native, pronte cio� a essere distribuite tramite AppStore, Android Market, Marketplace di Window Phone, ecc.ecc.. Entrambi utilizzano Javascript come linguaggio di sviluppo, ma con due filosofie profondamente diverse. In ogni caso, non possono prescindere, ovviamente, dagli SDK nativi per queste piattaforme. Conseguenza: se dovete sviluppare per iOS vi serve comunque un Mac con OSX.

PhoneGap

PhoneGap � un framework di sviluppo ibrido, nel senso che consente di realizzare App native per un gran numero di piattaforme (sono supportate tutte le pi� diffuse, come riportato qui) utilizzando HTML5 + CSS3 + Javascript. Ok, ma come funziona nella pratica? Un'applicazione PhoneGap fondamentalmente � costituita da un'insieme di pagine eseguite all'interno di un controllo browser, pagine il cui codice Javascript sostituisce in tutto e per tutto quello che scriveremmo in Objective-C, Java o C#. Dovete invocare un servizio web? Chiamata AJAX, magari con jQuery. Dovete realizzare una form di input di dati? Vai di styling CSS, o jQuery Mobile o Sencha Touch che dir si voglia.

Ok, ma allora a cosa serve il framework? Beh, PhoneGap, oltre ad una serie di template di progetto per i vari ambienti di sviluppo, fondamentalmente � costituito da una libreria javascript che fa da bridge tra il nostro codice in pagina e le funzionalit� native del telefono, dandoci di fatto la possibilit� di accedere a funzionalit� native del sistema e del dispositivo, come i contatti, il GPS o la fotocamera.

Punti a favore

Sicuramente il fatto che non dobbiamo praticamente imparare nulla, il Javascript � quello che abbiamo sempre usato, i framework anche, stesso discorso per i tool (e scusate se � poco!). Il passo per convertire un'app web in una nativa � davvero brevissimo. Inoltre l'enorme numero di dispositivi supportati, praticamente tutti gli smartphone moderni, � sicuramente un fattore non trascurabile. In buona sostanza, ad un costo quasi zero siamo in grado di sviluppare un'app nativa, anche considerando la natura assolutamente gratuita di questo prodotto. Non male eh? Purtroppo per� non finisce qui.

Svantaggi

Diversi aspetti mi hanno deluso di PhoneGap, che presenta dei limiti davvero pesanti a causa dei quali non mi sono sentito di consigliarne l'adozione. In particolare, in ordine sparso:

Siamo fondamentalmente costretti a reinventare la ruota: possiamo in buona sostanza dimenticarci tutti i controlli nativi per la piattaforma, con il risultato che le applicazioni perdono completamente il look & feel tipico del dispositivo su cui girano. Esistono alcuni plugin che supportano il rendering di 3 o 4 controlli nativi (AFAIK, TabBar, Toolbar, ActionSheet e StatusBar, e solo su iPhone), ma in questo modo si perde la portabilit�. Ne vale davvero la pena, allora?
Conseguenza diretta del punto precedente, � che la nostra app rischia di non essere accettata. Alcuni reviewers sono molto attenti, ad esempio, al rispetto delle guidelines della UX. Fatevi un giro su google e cercate "PhoneGap app rejected" e troverete davvero tanti casi.
Generalmente il funzionamento dell'applicazione � meno responsivo e fluido di una eventuale controparte nativa (ma questo, invero, dipende dalla bont� del browser).
Il codice � interpretato, niente compilazione. Quindi gli unici errori sono a runtime. Gi� cos� non � il massimo, ma, more than worse, ...
..il debug, come modernamente lo intendiamo, � praticamente impossibile. Scordatevi di mettere un breakpoint nel codice e di procedere step by step. Molti consigliano di eseguire l'applicazione su un browser tradizionale e debuggare da l�, ma a me sembra un timido palliativo, il debug lo voglio eseguire dal telefono o dal tablet! Alla fine vi toccher� tornare all'antico, con un sacco di begli alert sparsi qua e l� nel codice.
Per alcune funzionalit� (es. riproduzione video) vi toccher� comunque imparare il codice nativo .
PhoneGap non � Write Once Run Anywhere, semplicemente perch� se volete supportare n dispositivi avrete n progetti, magari ognuno la copia dell'altro, ma sempre n progetti da manutenere.

Appcelerator Titanium

Iniziamo dicendo che Titanium � un prodotto commerciale, si paga una fee mensile per utilizzarlo e sono previsti diversi livelli di abbonamento (tra cui uno "community" gratuito) che si distinguono, oltre che per il supporto, anche in base alle funzionalit� attive. Il linguaggio utilizzato � sempre Javascript, ma l'approccio rispetto a PhoneGap � sensibilmente differente: il codice che scriviamo, infatti, questa volta non ha nulla a che vedere con HTML, CSS o sviluppo Web in generale, bens� si appoggia ad un object model proprietario che wrappa gli oggetti nativi delle varie piattaforme. Il risultato � che il progetto Titanium genera codice nativo, con un layer che ne consente l'invocazione via Javascript.

Punti a favore

Titanium ha un IDE proprietario, basato su Eclipse. Supporta l'autocompletamento del codice e ha un debugger integrato, basato su Firebug. Quando creiamo un nuovo progetto ci viene chiesto quali piattaforme supportare come target, poi in fase di compilazione scegliamo su quale compilare. Corollario: il progetto resta uno solo, non dobbiamo manutenerne n copie, molto pi� vicino all'idea di write once run anywhere.

Anche qui, comunque, � richiesta la presenza degli SDK ufficiali, quindi se vogliamo sviliuppare su iOS non abbiamo scelta e dobbiamo lavorare su OSX. Il risultato finale, comunque, � davvero notevole, e soprattutto indistinguibile da una qualsiasi app realizzata con XCode o Android SDK + Eclipse. Ovviamente non tutti gli oggetti di Titanium hanno corrispondenti sia su iOS che su Android, e pertanto alle volte � necessario qualche "if (platform == iOS)", ma alla fine non � drammatico.

Problemi

Il limite principale di Titanium � che, al momento, supporta esclusivamente Android e iOS. Niente Windows Phone, pertanto. Per� pu� essere comunque interessante valutarlo se il nostro team � gi� skillato sulla piattaforma Microsoft e vogliamo comunque produrre applicazioni per questi altri due target.

Da un punto di vista dell'utilizzo, il primo ostacolo in cui mi sono imbattuto � l'assenza di un qualsiasi editor grafico, o comunque di un ausilio visuale per lo sviluppo di interfacce. In pratica siamo costretti a fare tutto da codice, istanziando controlli, valorizzandone le propriet�, aggiungendoli ad un controllo contenitore, e cos� via. Sicuramente � un approccio che si adatta non proprio bene a interfacce complesse e che rende molto difficoltosa l'interazione con un grafico.

L'aspetto che per� mi � piaciuto meno, � la scarsa ~~estendibilit�~~ flessibilit� del framework, sicuramente uno dei limiti pi� difficilmente superabili dell'architettura. Nel mio caso, ad esempio, avevo bisogno di una ScrollView (i "pallini" che rappresentano la paginazione della springboard di iOS, per capirci) in direzione verticale; Titanium ne propone solo una orizzontale e sono stato costretto a parecchi hack per ottenerla, sebbene invece sia assolutamente esistente in XCode. In generale questa mancanza di flessibilit� pu� rappresentare un problema non da poco, e dobbiamo essere pronti a rivedere le interfacce in base alle possibilit� del framework.

[EDIT]Come mi segnala Alessandro Ghizzardi, in realt�, � possibile realizzare dei wrapper di funzionalit� native ed esporle tramite Javascript in Titanium. Ovviamente, per�, in questo caso si ha la necessit� di scrivere codice in Objective-C e/o Java (a seconda della piattaforma), quindi le skill dobbiamo averle, per� sicuramente � una feature che eleva di molto il livello del prodotto.

Conclusione

Entrambi i prodotti sono ben lungi dall'essere perfetti. PhoneGap, secondo me, d� come valore aggiunto il riutilizzo delle skill, ma ad un costo non indifferente, ossia tutte le problematiche che ho citato. Pertanto lo vedo magari adatto ad un progetto estemporaneo se non vogliamo investire su una piattaforma nel lungo periodo, per il resto davvero mi lascia molto scettico.

Con Titanium la storia � differente: non nego che, sebbene sulle prime mi abbia lasciato un po' spaesato, l'impressione che ne ho tratto � quella di un buon prodotto, con alcuni limiti oggettivi che lo rendono poco "snello" in progetti di alto livello. Per� davvero non � male, provate a compilare Kitchen Sink per farvi un'idea. Il framework e il modello a oggetti dobbiamo comunque impararlo, per�, quindi non ci sono grandi vantaggi se poi puntiamo ad una sola piattaforma delle due disponibili.

Per quanto mi riguarda, la prima opzione resta la piattaforma nativa, per tutta una serie di ragioni: ottimizzazione e controllo del codice, debug, facilit� nel reperire documentazione, informazioni e componenti di terze parti, e potrei continuare... Sono aspetti che fanno la differenza, e che secondo me gi� nel medio periodo ripagano l'investimento sostenuto per acquisire le skill necessarie, investimento che, da professionisti, probabilmente � uno dei pi� futuribili che oggi possiamo fare.

Tags: HTML5, Javascript, jQuery, Metro, Windows Phone, Windows Phone 7, Windows Phone 7.1

Continua a leggere PhoneGap e Titanium, esiste davvero il write once run anywhere su mobile?.

WPC 2011: Cosa mi/ci/vi aspetta!

Marco De Sanctis — Mon, 14 Nov 2011 07:01:00 GMT

Quest'anno sono davvero orgoglioso di essere riuscito a salire a bordo della pi� importante conference IT italiana: � infatti per me un grande onore essere uno degli speaker di WPC 2011, dove terr� una sessione nella giornata del 23 (poco prima di Ibraaaaaa!!).

Di cosa parler�? Beh, di un argomento che, con il passare degli anni e delle versioni, mi appassiona sempre di pi�, tanto da averci scritto un libro e da non smettere di consigliarlo a varie aziende presso le quali collaboro: ovviamente si tratta di ASP.NET MVC, e in particolare delle possibilit� di estensione e customizzazione che ci offre.

Secondo me, infatti, al di l� delle migliorie sul view engine, i global filters, ecc. ecc., la vera carta vincente di ASP.NET MVC � proprio costituita dalla sua architettura, pluggabile in diversi punti, tanto da riuscire a piegarla alle nostre esigenze particolari davvero con poco sforzo e con risultati sorprendenti, soprattutto dal punto di vista della semplicit� e della pulizia del codice. Certo, si tratta di feature che sicuramente sfuggono ad una prima occhiata, fornendoci quindi l'errata impressione di un framework che, s�, d� controllo assoluto sul markup, ma che allo stesso tempo sembra essere verboso e ripetitivo ("s�, ma dove sono gli user control? e i datasource??).

Eppure, con un approccio diverso, magari giusto un pelo pi� ragionato, e con gli strumenti giusti, possiamo davvero scatenare a tutta forza la potenza di ASP.NET MVC. Se riuscite, fate un salto ad Assago il 23 e ne parleremo insieme! E dopo... Ibrahimovic vs. Messi...

Tags: ASP.NET, .NET Framework, .NET Framework 4.0, Architettura, ASP.NET MVC, Cache, Entity Framework 4.1, jQuery, Pattern

Continua a leggere WPC 2011: Cosa mi/ci/vi aspetta!.

CDays10, the day after: ringraziamenti, precisazioni, tricchettracc e bombamman

Marco De Sanctis — Sat, 18 Dec 2010 12:17:33 GMT

Sto scrivendo queste righe mentre sono su un treno che mi riporta in Abruzzo, dopo che Ryanair ha pensato bene di cancellare il mio volo di ieri sera (insieme a quelli di un altro migliaio di passeggeri). bah.

Anyway, innanzitutto volevo ringraziare tutti i partecipanti ai Community Days 2010, in particolar modo quelli che sono rimasti ad ascoltare la mia sessione e quella di Andrea, nonostante l'incognita della neve e della percorribilit� delle strade. Non ho parole, grazie sul serio, spero che ci� che vi ho mostrato di Web Forms possa in qualche modo esservi utile e serva a ripagare la vostra pazienza!

Durante la sessione ho notato parecchio interesse, soprattutto attorno alle nuove funzionalit� di Dynamic Data, che secondo me rappresentano una vera rivoluzione nell'ambito di *come* scrivere un'applicazione web forms oggi. Mi fa piacere perch� non nascondo la mia passione per DynData, cercher� di utilizzare questo feedback anche in ottica di tuning degli script per il 2011.

Il medesimo interesse poi l'ho visto nella parte relativa alla cache, peccato che AppFabric abbia fatto le bizze e non mi abbia consentito di eseguire con successo tutte le demo che avevo preparato. Rimedier� con uno screencast al pi� presto, promesso! Quando parlo di "fare le bizze" purtroppo intendo proprio "fare le bizze", nel senso che 10 minuti fa � bastato stoppare e riavviare il servizio perch� tutto funzionasse senza modificare una riga nel codice.. misteri sistemistici, con AppFabric siamo ancora alla versione 1.0 e magari c'� spazio ancora per qualche fix qua e l�. Anyway, indagher� meglio e vi terr� aggiornati

Una risposta volante alla persona che mi ha chiesto della possibilit� di invalidare elementi in cache in dipendenza da SQL Server: confermo che � possibile, la classe si chiama SqlChangeMonitor e non � altro che un wrapper della precedente SqlDependency.

Slide e demo online prestissimo, le sto "impacchettando" or ora per spedirle a Daniele.

Sentitevi liberi di contattarmi per ogni genere di domanda, un saluto e ancora grazie!

Tags: .NET Framework 4.0, ASP.NET, ASP.NET 3.5, ASP.NET 4.0, Cache, Community Days 2010, Databinding, Dynamic Data Control

Continua a leggere CDays10, the day after: ringraziamenti, precisazioni, tricchettracc e bombamman.

ASP.NET Web Forms ai Community Days, nel 2010

Marco De Sanctis — Fri, 10 Dec 2010 10:25:00 GMT

A parte il riferimento temporale, un post con un simile titolo avrebbe potuto tranquillamente essere pubblicato 5 anni fa (se non fosse che allora i Community Days non erano stati ancora inventati :D ). Si sa, � usanza - ed entro certi limiti non c'� niente di male, beninteso - seguire le mode del momento, che vogliono ad esempio in ASP.NET MVC la piattaforma pi� gettonata di cui parlare quando si vuole affrontare l'argomento dello sviluppo per il Web.

E per� esiste tanto ASP.NET Web Forms in giro, ad oggi la piattaforma pi� diffusa per realizzare Web App basate su .NET, e soprattutto, si tratta di una tecnologia estremamente moderna: Routing, Data Template, Data Annotations, controllo del markup, sono concetti che spesso si associano alle View, ai Model e ai Controller, magari portandoci erroneamente a pensare che, se vogliamo avvalercene, ASP.NET MVC sia una scelta obbligata.

Ebbene, non � assolutamente vero, ed � la principale ragione per cui, secondo me, ha veramente tantissimo senso nel 2010 avere una sessione come WebForms.Reload() nell'agenda dei Community Days e, di riflesso, � per me un grandissimo piacere poterne parlare. Visto che poi non ci facciamo mancare niente, toccheremo anche l'argomento Performance, e in particolare quel gioiellino che � AppFabric, su cui ad esempio � basata l'infrastruttura di cache dell'interno network ASPItalia.

Che dire, se ho stuzzicato la vostra curiosit�, ci vediamo a Milano, gioved� e venerd� prossimi.

Ciauz!

Tags: .NET Framework, .NET Framework 4.0, ASP.NET, ASP.NET 3.5, ASP.NET 4.0, Cache, Community Days 2010, Databinding, Dynamic Data Control

Continua a leggere ASP.NET Web Forms ai Community Days, nel 2010.

ASPItalia ti premia con Visual Studio 2010 Ultimate + MSDN Subscription!

Marco De Sanctis — Wed, 01 Sep 2010 09:52:00 GMT

Eh s�, per alleviarvi il triste ritorno dalle vacanze, ci siamo inventati un'iniziativa niente male: se siete appassionati di tecnologia e di sviluppo software, se avete pensato qualche volta che potevate contribuire con le vostre conoscenze a migliorare la community di ASPItalia, se magari in passato avete trovato delle dritte interessanti sui nostri forum e vi va di passare dalla parte di chi i consigli e le soluzioni invece le elargisce... insomma, se un po' vi riconoscete in qualcuno di questi "se", ASPItalia Community Awards 2010 � l� per voi!

In base ai vostri contributi, secondo le modalit� descritte nella pagina dell'evento, stileremo una classifica e coloro che a fine mese si troveranno nelle prime due posizioni si porteranno a casa niente meno che una Visual Studio 2010 Ultimate con MSDN Subscription a testa (quindi in totale, regaliamo ben QUATTRO MSDN a quattro di voi!).

Dai, cosa aspettate? ;-)

Tags: .NET Framework, .NET Framework 4.0, ASP.NET, ASP.NET 4.0, ASPItalia.com, Silverlight, Visual Studio, XAML

Continua a leggere ASPItalia ti premia con Visual Studio 2010 Ultimate + MSDN Subscription!.

Inside ModelVirtualCasting #7: Come ti creo una form MVC in 20 secondi (a dire tanto...)

Marco De Sanctis — Tue, 15 Jun 2010 05:50:00 GMT

Settima puntata per questa serie su ModelVC che, se continua cos�, ci porteremo fin sotto all'ombrellone! Qualche link ai precedenti post prima di iniziare...

Stavolta ci tocca il compito di sfatare un mito, ossia il fatto che con ASP.NET MVC il codice da scrivere � verboso, lungo e, in parole povere, molto meno RAD di Web Forms. Niente di pi� falso, grazie all'introduzione in MVC 2 degli editor e visualizer templates.

Immaginiamo un'ipotetica form di inserimento dati. Mentre in Web Forms il fulcro centrale dell'interfaccia � costituito dall'insieme dei controlli, in MVC invece il ruolo di protagonista � recitato dal model, e dagli oggetti che lo compongono. Si tratta, quindi, di un concetto molto pi� di "business" rispetto al passato, in cui possiamo specificare che un oggetto di tipo DateTime deve essere ovunque rappresentato in un certo modo e modificato in un altro.

Gli editor e visualizer templates non fanno altro che rendere possibile questo livello di astrazione: possiamo immaginarli come delle mini-partial view, che vengono associate ad un particolare tipo di dato grazie al nome e automaticamente iniettate dal framework quando lo si voglia visualizzare o modificare. In ModelVC, ad esempio, ho voluto utilizzare il DatePicker di jQueryUI come editor per tutte le propriet� di tipo DateTime di qualsiasi model delle mie pagine. Per farlo, ho creato un template di nome DateTime.ascx (occhio che il nome � importante) che ho messo nella posizione che vedete in figura.

Ma cosa contiene DateTime.ascx?

<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>
<script runat="server">
  private string dateString
  {
    get 
    {
      if (this.Model == null)
        return null;

      return ((DateTime)this.Model).ToShortDateString();
    }
  }
</script>
<%= Html.TextBox("", dateString, new { @class = "dateInput" })%>

Fondamentalmente niente di che, semplicemente una TextBox con una classe CSS particolare (dateInput) che posso utilizzare nella master page per attivare il DatePicker su tutte quelle che ne fanno uso:

<script type="text/javascript">
  $(function () {
    $.datepicker.setDefaults($.datepicker.regional['it']);
    $('.dateInput').datepicker();
  });
</script>

Il risultato dell'aver definito questo template � che basta a questo punto scrivere

<%= Html.EditorFor(m => m.BirthDate) %>

perch� il nostro bell'editor custom venga utilizzato in luogo del normale box di testo, semplicemente perch� BirthDate � di tipo DateTime (in realt� � anche possibile specificare esplicitamente quale editor referenziare tramite le DataAnnotations).

Non male, vero? Ma l'aspetto pi� interessante � che, dato che da che mondo � mondo, in .NET tutto eredita da Object, e nulla mi vieta di realizzare un bel template Object.ascx, che magari cicli per tutte le propriet� di un oggetto e per ognuna di esse renderizzi l'opportuno editor, magari di nuovo di tipo Object. Morale della favola: ho l'oggetto Candidate, che referenzia alcune altre entity e diversi complex type e voglio realizzarne una form di edit; bene, non devo far altro che scrivere

<%= Html.EditorFor(m => m) %>

o ancora meglio

<%= Html.EditorForModel() %>

Come ho fatto? Andate a vederlo sul codice sorgente di ModelVC e nel frattempo, provate anche a vedere se riuscite con Web Forms a realizzare una form altrettanto velocemente ;-)

Ciao!

Tags: .NET Framework 4.0, ASP.NET, ASP.NET 4.0, ASP.NET MVC, Custom Control, jQuery, Model Virtual Casting, User Control

Continua a leggere Inside ModelVirtualCasting #7: Come ti creo una form MVC in 20 secondi (a dire tanto...).

Inside ModelVirtualCasting #4: Come funziona CacheThis?

Marco De Sanctis — Thu, 03 Jun 2010 05:30:00 GMT

Quarto post della serie sugli internals dell'applicazione che abbiamo mostrato nel corso della Real Code Conference 4.0 lo scorso 25 Maggio 2010 i cui sorgenti sono disponibili su Codeplex:

Dell'attributo CacheThis ha gi� parlato un pochino Daniele nello scorso post, qualche giorno prima di RCC mi ha proposto di realizzare questa cosa perch� era una figheria simpatica da far vedere, e allora mi sono convinto e l'ho messa su! Si tratta di un sistema per effettuare caching dei risultati di un metodo in maniera trasparente. Infatti, in maniera dichiarativa, ci basta scrivere:

public interface INewsRepository : IRepository<INewsRepository, News> 
{ 
    [CacheThis("last-news", 60)] 
    List<NewsDTO> GetLastNewsDTO(int number); 
}

ed ecco che, come per incanto, il risultato di GetLastNewsDTO viene prelevato dalla cache, se presente, oppure recuperato tramite una query su DataBase. Ma come funziona tutto questo, visto che, l'implementazione di questo metodo non ha la minima cognizione del concetto di Cache?

public List<NewsDTO> GetLastNewsDTO(int number) 
{ 
    return CurrentObjectSet.AsQueryable() 
        .OrderByDescending(n => n.PublicationDate) 
        .Take(number) 
        .SelectDTO<News, NewsDTO>().ToList(); 
}

CacheThis � un tipico esempio di Aspect Oriented Programming sul quale potremmo scrivere qualche decina di post ma che, in parole povere, consente di iniettare logica in maniera modulare nelle chiamate ai metodi di un oggetto, pi� o meno agendo in questo modo:

In pratica, possiamo fare in modo che Unity, quando chiediamo un'istanza di INewsRepository, non restituisca direttamente NewsRepository, come ci aspetteremmo, bens� un proxy, che implementa per� la stessa interfaccia cos� che il nostro codice non si accorga minimamente che qualcuno sta cambiando le carte in tavola.

Cosa fa questo proxy? Beh, normalmente niente, si limita a girare ogni chiamata a NewsRepository e a restituire il risultato prodotto, tranne quando il metodo invocato sia decorato dal famigerato attributo CacheThis, nel qual caso viene eseguito il nostro bel CacheHandler che, grossomodo, � fatto cos� (in pseudocodice):

public Result Invoke(...) 
{ 
    if (Cache.Contains(key)) 
        return Cache[key]; 
     var result = invokeRealMethod(...);
     Cache.Add(key, result);
     return result; 
}

In parole povere, CacheHandler verifica se il risultato � gi� presente in cache, se viene trovato lo restituisce, altrimenti esegue il repository vero e proprio, mette in cache il risultato e lo ritorna.

Ora.. a dire il vero l'implementazione contenuta in ModelVC soffre di un paio di limitazioni, che sono nella lista della spesa delle feature da metter su per la prossima versione:

supporta esclusivamente l'invalidazione via timeout, mentre sarebbe bello se una Add/Modify/Delete di una news tramite repository invalidasse automaticamente la cache;
come sappiamo, quando realizziamo una query in LINQ to Entities, questa non viene eseguita finch� non se ne esplori il risultato; morale della favola.. dobbiamo forzarne l'esecuzione all'interno di NewsRepository (concreto), ad esempio con un ToList, altrimenti rischiamo di mettere in cache l'expression tree e non i risultati veri e propri.

D'altro canto, per�, CacheThis riesce a mantenere in Cache diversi risultati dello stesso metodo, creando chiavi on-the-fly a seconda dei parametri con cui � stato invocato e, soprattutto, ci mostra come in maniera semplice possiamo sfruttare questa tecnica (che di per s� � invece parecchio avanzata) per iniettare funzionalit� tramite Unity all'interno del nostro codice.

Che dire? Se volete saperne di pi�... i sorgenti di ModelVC non aspettano altro che essere scaricati, e continuate a seguire questa serie di post che io e gli altri ragazzi dello staff continueremo a pubblicare nei prossimi giorni.

Ciauz!

Tags: Architettura, Cache, Entity Framework, Model Virtual Casting, Object Oriented Programming

Continua a leggere Inside ModelVirtualCasting #4: Come funziona CacheThis?.

Inside ModelVirtualCasting #2: Architettura interna dei repository

Marco De Sanctis — Mon, 31 May 2010 05:30:00 GMT

Secondo post della serie sugli internals di ModelVC che abbiamo presentato a Real Code Day 4.0 prima e successivamente a Real Code Conference 4.0.

Introduzione ai repository
Architettura interna dei repository
more to come...

La volta scorsa abbiamo visto perch� abbiamo scelto di utilizzare i repository all'interno di ModelVC e abbiamo dato una panoramica dell'architettura secondo cui funzionano, che essenzialmente li porta ad essere dei wrapper degli ObjectSet di ADO.NET Entity Framework con qualche funzionalit� in pi�. Semplificando un po', allora, il codice di un repository pu� essere pensato simile al seguente:

public class Repository<T> where T : class 
{ 
    private IObjectSet<T> objectSet; 
 
    public Repository(ObjectContext context) 
    { 
        this.objectSet = context.CreateObjectSet<T>(); 
    } 
 
    internal Repository(IObjectSet<T> objectSet) 
    { 
        this.objectSet = objectSet; 
    } 
 
    public void InsertOnSubmit(T entity) 
    { 
        this.objectSet.AddObject(entity); 
    } 
 
    public void Update(T entity) 
    { 
        this.objectSet.Attach(entity); 
    } 
 
    public IQueryable<T> Where(Expression<Func<T, bool>> predicate) 
    { 
        return this.objectSet.Where(predicate); 
    } 
}

Notiamo un paio di aspetti interessanti, che ci semplificano tanto la vita in fase di test:

Non manteniamo alcun riferimento a tipi concreti di ADO.NET Entity Framework, che � presente solo con l'interfaccia IObjectSet<T>;
E' presente un costruttore internal tramite cui fornire direttamente un IObjectSet, che pu� essere utilizzato per iniettare un mock o un fake.

Ottimo, sarebbe tutto bellissimo se non fosse che purtroppo per le funzionalit� che vogliamo esporre, la sola IObjectSet<T> non basta: esempio? il metodo Include, che vogliamo utilizzare per indicare ad EF quali entity collegate deve caricare, � esposto da ObjectSet<T> (e anche da ObjectQuery, sua classe base) ma non dall'interfaccia. Come fare allora? Io e Stefano ci abbiamo riflettuto un po' e alla fine ne siamo venuti a capo in questo modo:

In pratica abbiamo introdotto le nuove interfacce IObjectQuery<T> e IIncludeObjectSet<T>, che espongono il metodo Include come desiderato; in particolare quest'ultima � referenziata all'interno di Repository<T> al posto di IObjectSet<T>, cos� che finalmente abbiamo a disposizione la funzionalit� richiesta.

In Entity Framework, per�, ObjectSet<T> ovviamente non implementa IIncludeObjectSet<T>, e pertanto siamo stati costretti a realizzarne un wrapper. Si tratta di un giro un po' complicato se vogliamo (tra l'altro la versione che trovate su ModelVC � leggermente pi� complessa) ma che fondamentalmente ci consente di costruire repository senza avere riferimenti a tipi concreti di Entity Framework. A cosa serve? a darci la possibilit� di realizzare un FakeObjectSet, che trovate in ASPItalia.ModelVirtualCasting.MVC.Tests nella cartella Utils, che possiamo utilizzare per verificare che il nostro repository funzioni senza scomodare SQL Server:

var list = new List<User>(); 
list.Add(new User() { Nick = "Cradle"}); 
 
var rep = new UserRepository(new FakeObjectSet<User>(list)); 
Assert.AreEqual(list[0], repo.GetByNickname("Cradle"));

Cool, isn't it? Alla prossima!

Tags: Architettura, ASPItalia.com, Model Virtual Casting, Pattern

Continua a leggere Inside ModelVirtualCasting #2: Architettura interna dei repository.

Inside ModelVirtualCasting #1: Introduzione ai repository

Marco De Sanctis — Thu, 27 May 2010 06:00:00 GMT

Allora, l'avevo promesso, vediamo quanto riesco a mantenere l'impegno preso nel scrivere una serie di post su alcuni aspetti, soprattutto architetturali, che abbiamo scelto di utilizzare in ModelVirtualCasting (ModelVC per gli amici).

L'argomento di cui vorrei parlarvi stasera � il modello di accesso ai dati che abbiamo scelto di utilizzare. Immagino che abbiate capito che ModelVC usi internamente ADO.NET Entity Framework, sebbene questo non sia esposto direttamente agli strati sovrastanti, che invece hanno la possibilit� di accedere alla base dati tramite degli oggetti chiamati Repository.

Cos'� un repository e soprattutto, perch� questa scelta? In due parole, un repository � un oggetto che si frappone tra noi e lo strato di accesso ai dati, comportandosi come se fosse una normale collection .NET, supportando quindi aggiunte e rimozioni di oggetti, e sul quale possiamo eseguire query (ad esempio tramite LINQ) come se i dati si trovassero gi� tutti in memoria. Ottimo, ma allora sono simili agli ObjectSet di Entity Framework, che bisogno abbiamo di scrivere questo codice in pi�? Vediamo un attimo la struttura delle interfacce:

Come vedete, questa architettura mi consente un livello di personalizzazione che con gli ObjectSet non ho, ossia:

Avere a disposizione due interfacce base, IReadOnlyRepository e IRepository, ci consente di forzare in sola lettura alcune entit�, che by design immaginiamo non dovranno mai essere inserite o eliminate;
Possiamo esporre metodi personalizzati per un repository specifico, quando questo pu� risultare comodo, come nel caso di GetByUsername su IUserRepository
Possiamo personalizzare il comportamento in fase di Add, ad esempio effettuando su UserRepository un override del metodo InsertOnSubmit e verificare al suo interno che l'email dell'utente che stiamo inserendo non sia gi� presente nel database.

Il tutto senza rinunciare alle potenzialit� di Linq To Entities, visto che i nostri Repository agiscono come wrapper proprio di ObjectSet e che metodi come Where e GetAll restituiscono una IQueryable<T>, cos� che possiamo tranquillamente scrivere qualcosa tipo

var query = myUserRepository .Where(u => u.Username == u.Password) .Select(u => new { Nick = u.Username, Email = u.Email } );

e star sicuri che l'expression tree generato verr� dato in pasto all'engine di EF e tradotto in una query SQL verso il database.

Ultimo e fondamentale vantaggio, avere questa struttura basata su interfacce ci consente di disaccoppiare gli strati superiori (servizi o UI) da una particolare implementazione, che pu� essere invece scelta a runtime, cos� che l'indomani possiamo realizzare un set di repository basati su una tecnologia completamente diversa (mah.. questa affermazione mi � sempre sembrata un po' fuffosa, sar� sincero con voi :D) o soprattutto:

Semplificarci la vita in fase di test, visto che un IUserRepository � infinitamente pi� facile da mockare rispetto a EntityFrameworkContext.Users (brrr...); questo � un punto a favore importantissimo, dato che IObjectSet<T> gi� esposta da EntityFramework in realt� non espone tutte le logiche necessarie a gestire con efficacia un ObjectSet perch� mancano parecchie robe fondamentali;
Possiamo realizzare dei FakeRepository (li trovate in ASPItalia.ModelVirtualCasting.Fake) per testare la nostra applicazione su dati cablati nel codice, senza scomodare il database, consentendoci quindi a tutti gli effetti di parallelizzare alla grande il lavoro; per esempio, io sono riuscito a sviluppare parte dell'interfaccia utente quando Stefano ancora non aveva sviluppato nessun repository concreto, quindi con lo strato dati praticamante inesistente! E vi assicuro che, quando Stefano ha completato il suo lavoro, non ho dovuto cambiare nulla della UI per adeguarmi, solo una serie di impostazioni sul web.config.

Bene, con questa vi saluto e, sperando che vi interessi, vi do appuntamento ai prossimi post, nei quali ci addentreremo un po' nei meandri di questi oggetti per scoprire pi� nel dettaglio come sono fatti e come riusciamo ad istanziarli!

Ciao!

Tags: Architettura, ASPItalia.com, Entity Framework, Model Virtual Casting, Pattern

Continua a leggere Inside ModelVirtualCasting #1: Introduzione ai repository.

Real Code Conference 4.0: Debriefing...

Marco De Sanctis — Wed, 26 May 2010 14:11:00 GMT

Siete stati tantissimi e vorrei ringraziarvi ad uno ad uno per essere stati con noi, per averci fatto domande e per esservi mostrati cos� interessati a quanto avevamo da dirvi. Mi scuso per le persone che sono state costrette a vedere parte della conference nell'altra sala, ma il numero ha superato le nostre pi� rosee aspettative e ci siamo dovuti adattare un po' tutti.

Per quanto riguarda la mia sessione, devo dire che ho visto diversi volti interessati mentre parlavo; purtroppo in eventi di questo tipo non � possibile approfondire pi� di tanto gli argomenti, la fretta la fa sempre da padrona, ma spero di esser riuscito a fornirvi quantomeno l'idea degli effetti benefici che i test automatici possono portare alle nostre applicazioni e come si pu� approcciare il problema.

Per i dettagli, a breve troverete online la nostra applicazione nella versione che abbiamo mostrato (purtroppo a meno che non vogliate scaricare la trunk, quella attualmente in rilascio su codeplex � ancora relativa al passato RCD 4 dello scorso dicembre). Poi spero di trovare il tempo per scrivere nei prossimi giorni qualche post sul blog che vada un po' pi� a fondo sul tema del testing, non solo in ottica ASP.NET MVC, e magari realizzare qualche piccolo screencast. Non vi prometto nulla, ma ce la metter� tutta.

Ciao!

Tags: .NET Framework, .NET Framework 4.0, ASP.NET MVC

Continua a leggere Real Code Conference 4.0: Debriefing....

Creare un filtro custom per QueryExtender

Marco De Sanctis — Mon, 03 May 2010 13:40:00 GMT

QueryExtender � uno strumento molto comodo per modificare le query generate da una EntityDataSource e ci� che lo rende secondo me parecchio potente � la sua espandibilit�.

Creare filtri personalizzati � infatti parecchio semplice se si ha un po' di dimistichezza con le lambda expression, visto che, in fin dei conti, non dobbiamo far altro che generare l'espressione desiderata e applicarla alla sorgente. Vediamo un po' nel dettaglio come fare, ad esempio, a realizzare un filtro in cui possiamo specificare il tipo di relazione (">", ">=", "<", ecc.) e il termine di comparazione.

Il primo passo � quello di realizzare una classe che erediti da DataSourceExpression o meglio, dato che il nostro filtro dovr� essere parametrico, da ParameterDataSourceExpression, che implementa gi� tutta la logica necessaria a recuperare i valori dei parametri.

L'unico metodo da realizzare � GetQueryable, che riceve in ingresso un oggetto IQueryable e lo restituisce dopo averne eventualmente modificato l'espressione:

public override IQueryable GetQueryable(IQueryable source)
{
  // recupero i parametri grazie alla logica della classe base
  var values = this.Parameters.GetValues(this.Context, this.Owner);
  
  // se non tutti i parametri sono specificati, non faccio nulla
  if (values.Count != 2 || values[0] == null || values[1] == null)
    return null;
    
  // .. qui logica per calcolare il filtro ..
}

L'aspetto, se vogliamo, leggermente complesso, � costruire la LambdaExpression, dato che richiede un po' di conoscenza dell'anatomia di questo tipo di oggetti. Immaginiamo di voler scrivere questo tipo di espressione sull'oggetto Product e cerchiamo di capire come scomporla:

p => p.Amount < 25

Essa contiene:

1) Una costante "25"

var constant = Expression.Constant(25, typeof(int));

2) Un parametro "p" di tipo Product

var parameterExpression = Expression.Parameter(typeof(Product));

3) L'accesso alla propriet� "Amount" di Product

var propertyExpression = Expression.PropertyOrField(parameterExpression, "Amount");

4) Il confronto "<" tra il risultato del punto (3) e quello del punto (1)

var compare = Expression.LessThan(propertyExpression, constant);

Questo oggetto � il body della nostra lambda expression, ossia tutto ci� che � a destra del simbolo "=>". Per ottenere l'espressione completa � sufficiente specificare quali sono i parametri che essa dovr� gestire, ossia i membri a sinistra del simbolo "=>" (nel nostro caso Product, e quindi la stessa parameterExpression del punto 2):

var lambda = Expression.Lambda(compare, new ParameterExpression[] { parameterExpression });

Mettendo tutto insieme, il metodo GetQueryable diviene:

public override IQueryable GetQueryable(IQueryable source)
{
    var values = this.Parameters.GetValues(this.Context, this.Owner);


    if (values.Count != 2 || values[0] == null || values[1] == null)
        return null;

    // recupero la property su cui effettuare il filtro
    var parameterExpression = 
      Expression.Parameter(source.ElementType);
    var propertyExpression = 
      Expression.PropertyOrField(parameterExpression, this.DataField);

    // creo il secondo membro dell'expression in base al valore recuperato
    TypeConverter converter = 
      TypeDescriptor.GetConverter(propertyExpression.Type);
    var constant = 
      Expression.Constant(converter.ConvertFrom(values[1]), propertyExpression.Type);

    // creo l'espressione di confronto
    var comparisonType = getComparisonType((string)values[0]);
    var compare = 
      buildCompareExpression(propertyExpression, comparisonType, constant);

    // genero la lambdaexpression
    var lambda = 
      Expression.Lambda(compare, new ParameterExpression[] { parameterExpression });

    return source.Provider.CreateQuery(
      Expression.Call(
        typeof(Queryable), "Where", 
               new Type[] { source.ElementType }, 
               new Expression[] { source.Expression, Expression.Quote(lambda) }));
}

Alcune cose da notare:

L'uso di un TypeConverter per convertire il parametro nel tipo desiderato da Expression.Constant;
Il metodo buildCompareExpression non fa altro che valutare l'operatore selezionato dall'utente ("<", ">", ecc.) e costruire l'espressione corrispondente ("Expression.LessThan", "Expression.GreaterThan")
L'uso di Expression.Call e di IQueryProvider.CreateQuery per aggiungere una condizione di Where alla IQueryable originale. Questo � necessario perch� l'extension method Where � generico e quindi richiede di specificare il tipo, che per� nel nostro caso non � noto a priori.
Il fatto che abbiamo realizzato un filtro Where � un qualcosa di strettamente correlato alla nostra particolare implementazione, visto che non esistono vincoli infrastrutturali in tal senso. Morale della favola: nulla ci vieta di implementare una DataSourceExpression per realizzare una Group By.

Il codice dell'esempio � scaricabile qui, per farlo funzionare vi basta sostituire la connection string con una che punti al database Northwind.

Ciao!

Tags: .NET Framework 4.0, ASP.NET, ASP.NET 4.0, Databinding, Entity Framework

Continua a leggere Creare un filtro custom per QueryExtender.

ASP.NET MVC 2, ne vale la pena? Secondo me sì!

Marco De Sanctis — Wed, 28 Apr 2010 05:53:00 GMT

Diciamolo chiaramente: per chi oramai sono anni che lavora con WebForms, passare ad ASP.NET MVC sulle prime pu� sembrare un ritorno alle origini (se va bene) o un great pain in the ass (se ci siamo svegliati con la luna storta).

Eppure la versione 2, che � disponibile - vale la pena ricordarlo - sia per Visual Studio 2010 che per Visual Studio 2008, di novit� ne ha portate parecchie, soprattutto dal punto di vista della produttivit�: strano a dirsi, eh? e invece no! ASP.NET MVC 2 adotta un sistema di templating e di validazione mutuato - udite udite - da ASP.NET Dynamic Data Controls, grazie al quale possiamo realizzare interfacce complete e complesse veramente nel giro di pochissimo tempo.

Non ci credete? Beh, � una prima ragione per vederci a Firenze il 25 maggio, non trovate?

"S�", direte voi, "ottimo. Ma *perch�* ASP.NET MVC? Chi me lo fa fare?"

La risposta �, ironia su ironia, un'altra domanda: "Scrivete test automatici per il vostro codice?"

Se s�, magari parliamo di come testate le vostre pagine WebForms, giuro che mi interessa! E comunque valutate ASP.NET MVC, pu� veramente semplificare il vostro lavoro!

Se no, prendete in *seria* considerazione l'idea di iniziare! Magari proprio con ASP.NET MVC 2!

In entrambi i casi, proprio il testing � la seconda ragione per vederci a Firenze il 25 maggio. Perch� secondo me parlare di MVC senza far vedere il testing � come andare a cena al ristorante e pagare il conto senza mangiare.

Morale della favola: ho pensato che alla Real Code Conference 4.0 sarebbe stato interessante far vedere come scrivere un'applicazione real world con ASP.NET MVC 2 e decorarla con una bella suite di test automatici per ognuno dei suoi layer. D'altronde siamo nel 2010 no?

Ciao!

Tags: ASP.NET, ASP.NET MVC

Continua a leggere ASP.NET MVC 2, ne vale la pena? Secondo me sì!.

Ma che figo Reflector Pro di Red Gate

Marco De Sanctis — Thu, 08 Apr 2010 22:47:25 GMT

Come molti di voi sapranno, qualche mese fa Red Gate ha acquistato Reflector, il tool che, dopo Visual Studio, ogni sviluppatore .NET dovrebbe avviare quando si siede davanti al PC.

Da allora, alla versione tradizionale che � rimasta gratuita, si � aggiunto anche Reflector Pro, un'edizione a pagamento che promette cose mirabolanti. Volete un esempio? Sentite un po'.

Ho creato una semplice ConsoleApplication in C#, in cui ho messo questo codice:

List<string> someList = new List<string>(); 
someList.Add("Ciao");

Dopo aver installato Reflector Pro, in Visual Studio appare un nuovo menu, dal quale possiamo selezionare la voce Chose Assemblies to Debug

A questo punto, dalla finestra di Reflector, selezioniamo di voler debuggare mscorlib, ossia l'assembly che contiene la definizione della classe List:

Ci� che accade, � che Reflector inizia la decompilazione dell'assembly; nel nostro caso impiega qualche minuto, visto che si tratta di parecchio codice, ma esiste uno storage interno che funge da cache per queste definizioni, cos� che non sia necessario ripetere l'operazione. Al termine di tutto, mettiamo un breakpoint sulla seconda riga del nostro codice ed avviamo l'applicazione in debug:

Quando l'esecuzione si ferma sulla riga evidenziata, premiamo F11 e...

Notate il nome della classe in alto :-) Siamo andati in Step In dentro al codice del metodo Add di List<T> e possiamo avvalerci di tutte le funzionalit� del debug di Visual Studio, dai watch (come si vede in figura) a che so... il debug multithreading di cui ho parlato ieri, mentre procediamo in step by step all'interno di mscorlib.dll.

Mica male!!

Tags: .NET Framework, Visual Studio

Continua a leggere Ma che figo Reflector Pro di Red Gate.

Multithreading e parallel computing nel .NET Framework 4.0

Marco De Sanctis — Wed, 07 Apr 2010 23:40:41 GMT

Una delle novit� dell'imminente nuova versione del .NET Framework a cui personalmente ho dato parecchia importanza � il notevole supporto per multithreading e parallel computing. Spesso siamo abituati a confondere questi due termini e a usarli quasi come sinonimi, anche se sinonimi veri e propri non sono. Il multithreading � un qualcosa che � sui nostri desktop gi� da diversi anni, supportato dal Framework sin dalle sue prime incarnazioni. Il calcolo parallelo � invece qualcosa di pi�, che sfrutta il multithreading per massimizzare l'uso dei core messi a disposizione dall'hardware, un aspetto fondamentale nel momento in cui anche sui laptop non � raro imbattersi in 4, 6 o 8 core.

Ho avuto modo di occuparmi di questi aspetti durante la stesura di uno dei capitoli dei nostri libri di prossima uscita interamente dedicato alle tematiche di multithreading e parallel computer, e penso francamente che il .NET Framework 4.0, il nuovo CLR e Visual Studio 2010 portino l'esperienza di sviluppo di applicazioni parallele a livelli assolutamente ineguagliati al giorno d'oggi.

Ma quali sono sostanzialmente queste novit�? Beh. innanzitutto direi la presenza di PLINQ e della classe ParallelQuery, grazie alla quale � possibile integrare con grandissima facilit� il calcolo parallelo all'interno delle nostre query LINQ; basta usare infatti l'extension method AsParallel() per far s� che una query del tipo

var query = from i in list.AsParallel() 
            where someCondition(i) 
            select someResult(i)

venga eseguita sfruttando al massimo i core presenti nel sistema.

Per il codice "di tutti i giorni", invece, sono state introdotte le classi Task e TaskFactory, che rendono possibile creare task asincroni, gestirne le notifiche, accodarne di altri, ecc.. in una sintassi estremamente concisa e intuitiva, che ci risparmia un bel po' di lavoro manuale che eravamo costretti a svolgere usando il ThreadPool.

Ma pi� thread contemporaneamente in esecuzione vuol dire anche gestire problematiche di concorrenza e di thread safety. Chi ha lavorato in quest'ambito in passato, sa che ad esempio avere a che fare con collection condivise tra pi� thread non era assolutamente banale. Il .NET Framework 4.0 espone un nuovo namespace, dal nome fin troppo indicativo: System.Collections.Concurrent. Esso contiene un gran numero di collection, tutte rigorosamente thread safe, che risparmiano parecchie grane quando utilizzate in scenari paralleli e i cui internals (basta dare un'occhiata con Reflector) sono tutt'altro che banali e scontati, con lo scopo di minimizzare i lock, che notoriamente vanno a braccetto con decadimenti prestazionali.

E la ciliegina su questa torta non poteva che essere lui, Visual Studio 2010, e il suo supporto al debug di applicazioni multithreaded. Provate a dare un'occhiata a queste due immagini in basso per capire di cosa sto parlando, valgono pi� di mille parole:

Che dire. ci aspettano non solo mesi di articoli e succose novit�, ma anche mesi in cui potremo sfruttare strumenti innovativi, in grado di darci una grande mano nel lavoro di tutti i giorni e, perch� no, anche vantaggi sostanziali nelle potenzialit� delle nostre applicazioni!

Ci vediamo su queste pagine!

Tags: .NET Framework, .NET Framework 4.0, C# 4 Guida completa, Visual Basic 2010 Guida completa, Visual Studio

Continua a leggere Multithreading e parallel computing nel .NET Framework 4.0.

Rilasciato ASP.NET MVC 2 Beta

Marco De Sanctis — Tue, 17 Nov 2009 23:58:01 GMT

I primi effetti di PDC iniziano a farsi vedere: � stata rilasciata oggi, infatti, la beta di ASP.NET MVC 2 (solo per VS2008) che introduce alcune novit� rispetto alla Preview 2 presente in Visual Studio 2010 Beta 2. Cerchiamo di vedere cosa cambia e quali sono le nuove funzionalit� disponibili con questa nuova versione:

Validazione Client-side

La Preview 2 gi� aveva introdotto un supporto built-in per la validazione client-side, utilizzando un opportuno plugin per jQuery. Nella versione Beta, invece, questa funzionalit� � compresa all'interno delle librerie Javascript di Microsoft, pertanto � sufficiente includere

MicrosoftAjax.js
MicrosoftMVCAjax.js

e richiamare il metodo

<% Html.EnableClientValidation(); %>

dalla View, affinch� tutto funzioni.

Add Area

Il men� contestuale di un progetto MVC all'interno del solution explorer consente adesso di aggiungere in maniera guidata una nuova area all'interno dell'applicazione. Ricordiamo che le Area altro non sono che una suddivisione logica del progetto stesso in pi� sottocartelle, una per ogni "modulo", all'interno delle quali trova posto la struttura di cartelle standard di MVC (Views, Controllers, Models)

Modifiche al funzionamento dei TempData

TempData, come gi� abbiamo indicato nello script #989, consente di mantenere momentaneamente in uno storage (per default la session di ASP.NET) alcuni dati, che vengono poi automaticamente rimossi al ciclo di request response successivo. In MVC 2 Beta, invece, questi dati restano memorizzati fino al loro effettivo utilizzo, dopo di che vengono automaticamente marcati per l'eliminazione. Il metodo Keep consente comunque di conservarli anche se sono stati utilizzati.

Strong typed UI Helpers

Gi� nelle preview 2 erano presenti i primi 3 esempi di UI Helpers (Editor, Label e Display) che, sfruttando le lambda expression, rendevano possibile la creazione di elementi di interfaccia collegati a propriet� del model in maniera strong typed e con il supporto di Intellisense e Refactoring di Visual Studio. Grazie ad essi, ad esempio, si pu� generare un elemento Input per una propriet� Descrizione del model tramite la sintassi

<%= Html.EditorFor(m => m.Descrizione) %>

In questa nuova versione sono stati aggiunti anche

ValidationMessageFor
TextAreaFor
TextBoxFor
HiddenFor
DropDownListFor

Esecuzione asincrona delle action tramite un AsyncController

ASP.NET MVC 2 Beta introduce ufficialmente una interessantissima caratteristica che, fino ad oggi, � stata parte del progetto sperimentale ASP.NET MVC Futures. Tramite la classe base AsyncController, infatti, � ora possibile realizzare Action in grado di invocare metodi asincroni, la cui esecuzione viene presa in carico da un worker thread esterno a quello utilizzato da ASP.NET.

Download

Il download di questa nuova versione di ASP.NET MVC 2 � disponibile a questo link, dove trovate anche le note di rilascio. Un'ultima nota riguarda la compatibilit� con le versioni di Visual Studio. E' supportato il solo Visual Studio 2008 SP1, quindi niente versione 2010 per il momento. Tra l'altro, visto che 2008 e 2010 condividono alcune componenti, l'installazione anche sul solo 2008 non � supportata se risulta installata anche la versione 2010 Beta 2.

Enjoy!

Tags: .NET Framework, .NET Framework 4.0, ASP.NET 4.0, ASP.NET MVC, Visual Studio, ASP.NET

Continua a leggere Rilasciato ASP.NET MVC 2 Beta.