asp.net comments edit

Poco più di una settimana fa Scott Hanselman ha annunciato tramite il suo blog alcune delle più importanti novità che riguardano la prossima release di ASP.NET, conosciuta con il codename Project K.

Le novità sono veramente tante: alcune di grande impatto a livello strutturale e di framework, altre che vanno ad impattare sulla scrittura del codice ma in maniera meno invasiva. Ma partiamo con ordine.

La prossima release sarà rilasciata sotto licenza .NET Foundation ed il codice sarà disponibile su Github qui.

Questa release lavorerà side by side con .NET Native (un compiler .NET che promette performance alla c++ ma con la produttività del c#), .NET Compiler Platform ("Roslyn") (compiler-as-a-service) e Nextgen JIT (un JITter ottimizzato per i nuovi processori).

Un'altra importantissima novità riguarda il CLR (Common Language Runtime); la prossima release non avrà più una dipendenza da esso come le precedenti release, ma avrà un runtime tutto suo.

Quest'esigenza nasce dalla voglia di incrementare sensibilmente le performance delle applicazioni. Il CLR del .NET è lo stesso per tutte le applicazioni, siano queste Windows Application, Windows Phone o ASP.NET. Ovviamente questa versatilità ha un costo in termini di memoria e performance, così il vnext utilizzerà il K Runtime fortemente ottimizzato per il web.

Il CLR sarà ottimizzato in base all'environment dove verrà "deployata" l'applicazione (Cloud, Premise, ...) e verrà rilasciato via NuGet. Quest'ultimo assume un ruolo sempre più importante nel mondo Microsoft: inizialmente era rivolto solo alla distribuzione di librerie .NET, successivamente è stato utilizzato anche per il setup di Visual Studio, per arrivare ora al vnext di ASP.NET.

Rimanendo in tema di CLR, va menzionata anche la nuova modalità di compilazione. Le dll ed il compilato delle view Razor non saranno più presenti nella classica folder bin o nella Temporary folder di ASP.NET, bensì in memoria. Anche questo cambiamento è rivolto esclusivamente alle performance, riducendo drasticamente la lettura/scrittura su disco, lavorando così in RAM. Questo apre anche un altro scenario di non poco conto, ossia la possibilità di cambiare il codice on-fly (sfruttando Roslyn per la compilazione), senza dover ricaricare dll sul server.

A completare quest'importante carrellata di novità si aggiunge la compatibilità con Mono e la conseguente possibilità di eseguire le proprie applicazioni ASP.NET vnext anche su sistemi operativi non Microsoft (Linux, Unix e Mac OsX). Questo cambiamento era facilmente intuibile con l'introduzione di OWIN e Katana, che annunciavano la scissione tra IIS e ASP.NET (vedi slides di una mia presentazione qui).

MVC, Web API e SignalR

Tutti e tre i Framework convergeranno in un unico pacchetto chiamato MVC 6, uniformando così namespace e parte di codice. Di fatto Controller, Action, Routing e Model sono più o meno presenti su tutti e tre i Framework, ma su librerie differenti con Namespace differenti.

Ora un Controller, che sia questo un API Controller o un normale Controller MVC, erediterà sempre dalla stessa classe Microsoft.AspNet.Mvc.Controller (precedentemente si aveva System.Web.Mvc.Controller per MVC e System.Http.Controller per le API) ed il codice rimarrà uguale a quello che si è già abituati a scrivere:

Esempio di un controller MVC

using Microsoft.AspNet.Mvc;

public class HomeController : Controller
{
    public ActionResult Index()
    {
        return View();
    }
}

Esempio di un controller WEB API

using Microsoft.AspNet.Mvc;

public class ValuesController : Controller
{
    // GET /values
    public string Get()
    {
        return "Values";
    }

    // GET /values/1
    public string Get(int id)
    {
        return "Value " + id.ToString();
    }

    // POST /values
    public ActionResult Post()
    {
        return new HttpStatusCodeResult(201);
    }
}

Esempio di una serializzazione JSON

using Microsoft.AspNet.Mvc;

public class MoviesController : Controller
{
    public ActionResult Get()
    {
        var movie = new Movie
        {
            Title = "Maximum Payback", Year = 1990, Genre = "Action"
        };
        return Json(movie);
    }
}

È stato introdotto anche il supporto ai POCO (Plain Old C# Object) Controllers, in modo da avere classi "pulite" senza la necessità di ereditare da classi base:

public class HomeController
{
    private IActionResultHelper resultHelper;

    // La dipendenza arriva tramite il container della DI
    public HomeController(IActionResultHelper resultHelper)
    {
        this.resultHelper = resultHelper;
    }

    public ActionResult Index()
    {
        return this.resultHelper.Json(new { message = "That's a 'Poco' controller!" });
    }
}

Quest'ultimo scenario è molto interessante perchè introduce un'altra novità sulla vnext, ossia la Dependency Injection (io ne sono addicted) che si potenzia ancor di più e mette a disposizione un set di librerie che "wrappano" i Framework più comuni come Autofac, Ninject, Structuremap, Unity ed il mio preferito (ed inimitabile) Windsor :smirk: Su github trovate il sorgente di queste librerie.

Rimanendo sulla parte di sviluppo, le Aree di MVC, che nella versione precedente venivano registrate invocando il metodo

AreaRegistration.RegisterAllAreas

ora vanno registrate tramite routing ed un apposito attributo, come mostrato di seguito:

Routing:

//UseMvc è un extension method legato ad OWIN
app.UseMvc(routes =>
{
    routes.MapRoute(
        name: "AreasRoute",
        template: "{area}/{controller}/{action}");

    routes.MapRoute(
        name: "Default",
        template: "{controller}/{action}/{id?}",
        defaults: new { controller = "Home", action = "Index" });
});

Registrazione Area:

namespace MySample.Areas.Controllers
{
    [Area("Books")]
    public class HomeController : Controller
    {
        // Books/Home/Index
        public ActionResult Index()
        {
            return View();
        }
    }
}

Alcune risorse utili

Durante il Tech-ed sono state mostrate alcune di queste funzionalità, come potete vedere nei due video di seguito:

Di seguito invece trovate una serie di link con degli esempi di applicazioni sviluppate con il vnext:

Che dire? Veramente tante novità, bisogna solo trovare il tempo di gioarci un po'. Have fun.

eventi comments edit

image

Per la prima volta quest'anno ho la fortuna ed il piacere di partecipare come speaker al Codemotion Roma. Per chi non lo conoscesse è una delle più importanti conferenze europee (Madrid, Telaviv, Milano, Matrid ed ovviamente Roma) rivolte agli sviluppatori.

Ovviamente non potevo che non parlare di qualcosa riguardante lo sviluppo web ed in questo caso Web API.

Arrivo a questo evento molto carico, con parecchia voglia di condividere un'esperienza che mi ha occupato negli ultimi sei mesi, di cui la gran parte sullo sviluppo di API.

L'agenda è molto ricca e piena di colleghi super bravi e di argomenti super cool, quindi direi che non potete mancare.

Ci si vede a Roma!

web api comments edit

Con la versione 2.0 delle Web API è stato introdotto il supporto alle richieste cross domain, più comunemente chiamate CORS (Cross-Origin Resource Sharing).

Normalmente non è possibile effettuare richieste HTTP via Javascript da un source il cui dominio è differente da quello dell’endpoint chiamato.
Tradotto in soldoni, se il nostro Javascript si trova su http://www.miosito.it/Index.html non è possibile chiedere informazioni al sito http://www.tuosito.it/.

I motivi sono semplicemente di sicurezza, e servono ad impedire che qualcuno possa attingere a informazioni personali tramite un JS “maligno”.

Chiarito il perché di questo blocco, a volte può risultare necessario effettuare questo tipo di chiamate, e le strade possono essere diverse a seconda dei browser che si vogliono supportare.
La prima ed universale soluzione è comunicare via JSONP. Questo approccio è molto facile da utilizzare e tutti i browser lo supportano; l’unico incoveniente è il VERB della chiamata http che può essere solo in GET, con il conseguente limite dei caratteri utilizzabili.

Se, al contrario, vogliamo inviare parecchie informazioni non possiamo utilizzare questo approccio (una soluzione in questo caso è “proxare” lato server le chiamate JS e ribaltarle all’endpoint).

Un'altra soluzione è l’utilizzo del CORS, che da il titolo a questo articolo. In pratica la comunicazione CORS stabilisce, tramite delle recole che vedremo più avanti in questo articolo, che un client può accedere a delle informazioni da un dominio differente a condizione che il server lo consenta. 
Ovviamente per far ciò è necessario che il browser permetta questo tipo di chiamata, cosa che purtroppo non è del tutto scontata.
Internet Explorer in questo è stato fermo per molto tempo e, solo a partire dalla versione 10, ha introdotto il supporto completo a questo meccanismo di comunicazione.

La tabella seguente (http://caniuse.com/cors) mostra il supporto al CORS dai vari browsers

CORS SUPPORT TABLE

ci sono dei workaround che permettono di sfruttare CORS anche con IE 8/9 ma con alcuni limiti sui VERB della chiamata (maggiori info qui )

Ora che abbiamo chiarito cos’è il CORS, è arrivato il momento di configurarlo utilizzando uno tra questi browsers: IE10/11, Chrome (tutte le versioni), Firefox dalla 3.5+ e Safari 4+.

A questo punto abbiamo bisogno di due progetti, uno per il client ed uno per il server, entrambi “hostati” su domini differenti (nel mio esempio ho sfruttato i websites di azure, quindi ho http://imperdemo.azurewebsite.net per la parte server e http://imperclient.azurewebsite.net per la parte client).

Applicazione Server

Una volta creato il nostro progetto, come prima cosa è necessario abilitare il CORS per i domini che riteniamo "trusted", quindi nel mio esempio imperclient.azurewebsite.net, nel Global.asax.cs

Se avete utilizzato il template di default di Visual Studio, il vostro golbal.asax.cs dovrebbe essere più o meno come questo.

public class WebApiApplication : System.Web.HttpApplication
{
    protected void Application_Start()
    {
        AreaRegistration.RegisterAllAreas();
        GlobalConfiguration.Configure(WebApiConfig.Register);
        FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
        RouteConfig.RegisterRoutes(RouteTable.Routes);
        BundleConfig.RegisterBundles(BundleTable.Bundles);
    }
}

Da qui il file da modificare è quello contenente la configurazione delle Web API, quindi "WebApiConfig.cs" contenuto nella folder "App_Start".

N.B.: Prima di moficare il codice è necessario installare il corretto NuGet Packages; di fatto il template di Visual Studio delle Web API "as is" non contiene il package per il CORS, che va quindi installato manualmente.

PM> Install-Package Microsoft.AspNet.WebApi.Cors

Una volta che tutti gli "ingredienti" sono pronti, non ci resta che abilitare il CORS a livello applicativo e specificare per ogni singolo controller i "trusted" domain così:

using System.Web.Http;

namespace imperugo.webapi.cors.server
{
    public static class WebApiConfig
    {
        public static void Register(HttpConfiguration config)
        {
            // Web API configuration and services
            config.EnableCors();

            // Web API routes
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );
        }
    }
}

Mentre il nostro ValueController risulta così:

using System.Collections.Generic;
using System.Web.Http;
using System.Web.Http.Cors;

namespace imperugo.webapi.cors.server.Controllers
{
    [EnableCors(origins: "http://imperclient.azurewebsites.net", headers: "*", methods: "*")]
    public class ValuesController : ApiController
    {
        // GET api/values/5
        public string Get()
        {
            return "This is my controller response";
        }
    }
}

La parte importante di quest'ultimo blocco di codice è l'attributo EnableCors dove viene specificato l'url accettato per la richeista, gli headers ed i vari metodi.

Se non si vuole "aprire" un intero controller a delle chiamate Cross Domain, è possibile utilizzare l'attributo anche solo sulla singola Action oppure lasciare l'attributo sul controller e disabilitare una singola Action tramite l'attributo DisableCors

Applicazione Client

A questo punto, dato che la parte server è stata completata, non ci resta che creare un'altra applicazione con il compito di chiamare le nostre API appena create e deployate sul nostro server.

Il codice sottostante è un semplicissimo codice javascript, quindi può risiedere anche su una semplice pagina .html, senza la necessità di creare un'applicazione server side.

La pagina HTML sarà così composta:

<div class="jumbotron">
    <h2>Test CORS (Cross-origin resource sharing)</h2>
    <p class="lead">
        <a href="#" class="btn btn-primary btn-large" id="testButton">Test it now&raquo;</a></p>
    <p>
    <p id="response">
        NoResponse
    </p>
</div>

con il seguente codice javascript:

<script language="javascript">
    var feedbackArea = $('#response');
    $('#testButton')
        .click(function () {
            $.ajax({
                type: 'GET',
                url: 'http://imperdemo.azurewebsites.net/api/values'
            }).done(function (data) {
                feedbackArea.html(data);
            }).error(function (jqXHR, textStatus, errorThrown) {
                feedbackArea.html(jqXHR.responseText || textStatus);
            });
    });
</script>

Se abbiamo fatto tutto correttamente, non ci resta che deployare l'applicazione server e quella client. Se utilizzate il template di Visual Studio, quest'ultima dovrebbe apparire così:

image

Il tutto dovrebbe dare un risultato tipo il seguente:

image

Al contrario se qualcosa non va, è necessario ricontrollare i punti sopra.

Come funziona

Il funzionamento del CORS è un semplice gioco di HEADERS tra il chiamante ed il server che riceve la risposta.

Il browser (il client) aggiunge nell'header della chimata un'informazione riguardo al dominio corrente (imperclient.azurewebsites.net nel mio caso) con la chiave Origin.

Il server a sua volta verifica che tale valore sia tra quelli trusted e risponde con un'altra informazione (sempre nell'header) con la chiave Access-Control-Allow-Origin

Se i due valori "matchano" allora il browser utilizza la risposta, altrimenti si avrà un errore.

In questo screenshot potete vedere l'header della richiesta e della risposta http, con evidenziati i valori utilizzati per il confronto

image

Di seguito invece il classico errore che restituisce Chrome nel momento in cui il CORS non funziona correttamente

image

Conclusioni

Per me che amo "spezzare" le mie applicazioni con un layer di API tra il front-end ed il backend, il CORS è una gran comodità, peccato purtroppo la non completa compatiblità con tutti i browser.

La demo di questo sito è disponibile qui

various comments edit

Ultimamente ho ritrovato un po’ la passione ed il tempo per lavorare sul blog, specie quello italiano.  Devo ammettere che è passato davvero molto dall’ultima volta che ho scritto, e di cose ne sono successe: un ruolo nuovo a lavoro e un bambino fantastico.

Quindi si riparte, ho aggiornato il blog (nell’aggiornarlo ho cancellato i commenti per sbaglio, sorry) e gli ho dato una  nuova veste grafica. Nelle prossime settimane pubblicherò diversi post sullo sviluppo web, la mia passione da sempre, ma non volevo riaprire il blog italiano subito con qualcosa di tech senza prima “chiacchierare” e, se volete, ripresentarmi.

Quindi, dato che ho già detto cosa mi è successo in questo anno fantastico, ho deciso di cominciare facendo un po’ di “pubblicità” al mio amico Matteo, che ha scritto un libro spaziale sullo sviluppo Windows Phone. Sottolineo la parola spaziale perché è riuscito a far capire ad uno come me, che di sviluppo mobile sa praticamente nulla, come fare un’app su Windows Phone (sinceramente mi ha anche aiutato a capire alcuni aspetti dello sviluppo su Windows 8).

Normalmente non amo i libri di molte pagine, perché a volte una tecnologia diventa obsoleta prima che finisco di leggerlo (ammetto che è un mio limite). Sono pochi i libri di un certo peso (inteso come numero di pagine) che sono riuscito a leggere con costanza e voglia.

Questo sicuramente è uno di quelli (insieme ai libri del mitico Dino Esposito).

Se siete anche solo minimamente interessati al mondo mobile, specie su tecnologia Microsoft, non potete non leggerlo.

Ovviamente lo trovate su Amazon qui.

various comments edit

Anche se non come speravo, ce l’ho fatta. Il mio blog in inglese è ufficialmente online.
Il dominio è alquanto particolare per noi tecnici: override.tostring.it . Lo stile del blog è lo stesso, quindi principalmente web, ma con la speranza di tornare a bloggare con la stessa frequenza di un anno e mezzo fa.

Per chi mi segue, il blog in inglese non sarà una replica di quello italiano, quindi potrete trovare contenuti esclusivi della versione inglese e viceversa.
Purtroppo il tempo non mi permette di scrivere un post in entrambe le lingue, ma di sicuro alcuni post saranno presenti in forme differenti su entrambi i blog.

Purtroppo il blog gira su Wordpress. Dico purtroppo non per parlare male di Wordpress ma perché non sono riuscito a trovare il tempo di creare una build stabile di Dexter.
Spero di trovare il tempo (o i collaboratori) per arrivare ad una buona build e migrare il tutto.

Tornando al blog, le idee sono tante e le scoprirete nei mesi a seguire, quindi…. Stay tuned!

Website: override.tostring.it
Rss: http://feeds.feedburner.com/override/tostring/it

eventi comments edit

Dopo l’annuncio, prima via Twitter e poi tramite il blog di Simone, eccomi qui a “sponsorizzare” la mia prima conferenza da organizzatore e non da speaker.

Se siete appassionati di web e volete vedere/conoscere come il mondo dello sviluppo web si sta evolvendo, non potete mancare.

webnetconftitle_3
Salvo cambiamenti nei prossimi giorni la conferenza si terrà ad ottobre - non abbiamo ancora le date ufficiali per via della location - e al 95% siamo su Milano.
La conferenza è Europea, quindi le sessioni saranno in Inglese, e dovrebbero esserci diversi speaker internazionali.

Giusto per darvi un assaggio di cosa si parlerà, eccovi un estratto:

Advanced JavaScript frameworks, HTML5, REST frameworks, cloud, lightweight http servers, real-time web, low-cerimony web frameworks, and much more...
both on .NET and other technologies

Abbiamo creato una pagina di lancio dove è possibile registrarsi (grazie alle quasi 120 persone che lo hanno già fatto), un account Twitter @webnetconf (l’hashtag è #webnet12) ed una pagina Facebook.
Nei prossimi giorni comunicheremo location e date ufficiali.

Se vi sentite parte del futuro del web, preparate le vostre proposte perché la Call For Paper sta arrivando.

Stay tuned!

various comments edit

Negli ultimi tempi, non essendo riuscito a bloggare con constanza a causa dei molti impegni, non ho avuto modo di comunicare l’esistenza di un’applicazione di tostring.it per Windows Phone.

L’applicazione è nello store da diversi mesi, è ovviamente gratuita e la potete scaricare qui. Quello che offre è piuttosto prevedibile: gli ultimi post e le stupidaggini che scrivo su Twitter J.

L’app è “Mango enabled” ed offre la possibilità di avere le notifiche “tile” e “toast” con un check periodico del feed del blog (ovviamente potete disabilitare il tutto).

Questa applicazione non esisterebbe se non fosse per il buon Matteo, quindi un grazie è d’obbligo.
Cosa curiosa, che ovviamente mi ha fatto molto piacere, è stato scoprire che oggi (quindi ieri per chi legge il post) l’applicazione è tra le feature app del marketplace, come potete vedere dallo screenshot seguente:

photo

Qui alcuni screenshot dell’app:

3f2b9f36-b054-4e4e-974a-f49b3a9558589d943c08-b2dc-4092-96c1-5d86ef04c74ced1bba52-e387-4de2-8f3e-dc6735a783ef82f7ccd0-53d5-4bde-b1a5-fa15f2fb6274

Buon download!

asp.net comments edit

L’ultima release (attualmente in beta) di ASP.NET MVC, di cui abbiamo visto alcune novità qui e qui, introduce veramente molte feature interessanti, una delle quali è rappresentata dai Bundle. Ormai noi tutti conosciamo l’importanza di ridurre al minimo il numero di richieste dal client verso il server. Quando parliamo di riduzione delle richieste, includiamo un po’ tutto: dai fogli di stile, ai javascript, e magari anche i dati tramite l’utilizzo di AJAX.

Per i primi due viene utilizzata la tecnica del “combine” e “minify” di più file in un’unica richiesta. Questo approccio consiste nel raggruppare tutti i files dello stesso tipo in un unico file, e nel rimuovere tutti gli spazi e commenti non necessari.

Tradotto in soldoni, tutte queste richieste che abbiamo nella pagina :

[xml] <script src="/Scripts/jquery-1.6.2.min.js"></script> <script src="/Scripts/jquery-ui-1.8.11.min.js"></script> <script src="/Scripts/jquery.validate.min.js"></script> <script src="/Scripts/jquery.validate.unobtrusive.min.js"></script> <script src="/Scripts/knockout-2.0.0.js"></script> [/xml]

Diventano una sola

<script src="/Scripts/combined.js"></script>

Ovviamente lavorare con un file unico, che sia questo un file javascript o css, risulta un po’ scomodo e, proprio per questo motivo, esistono diversi tool/framework che agevolano la creazione di un unico file a runtime o compile time.

Con ASP.NET MVC 4 effettuare il “combine” e “minify” è veramente semplice: basta utilizzare un apposito metodo ed il gioco è fatto.

Guardiamo il seguente codice:

[xml] <link href="@System.Web.Optimization.BundleTable.Bundles.ResolveBundleUrl("~/Content/css")" rel="stylesheet" type="text/css" /> <script src="@System.Web.Optimization.BundleTable.Bundles.ResolveBundleUrl("~/Scripts/js")"></script>[/xml]

È importante sapere che non tutti i files presenti nella folder specificata saranno inclusi nell’output del file, ma bensì solo quelli registrati nel bundle. In un prossimo post vedremo come creare bundle custom in modo da includere differenti file in differenti folder.

Stay tuned!

web dev comments edit

Questa volta non stiamo parlando di animazioni 3D per il web, bensì per lo sviluppatore e non servono gli occhialini J.

Per molti anni Firebug è stato sicuramente lo strumento più apprezzato dagli sviluppatori front end. Ad oggi tutti i browser integrano un qualcosa di simile e, nell’ultima versione, Firefox ha aggiunto un’interessantissima novità, la visualizzazione 3D della struttura del sito.

Per capire a cosa mi sto riferendo, guardate questo screenshot :

001

Per attivarla basta fare tasto destro sulla pagina, “Inspect Element” e premere il pulsante 3D come da screenshot:

002

Una volta entrati nella modalità 3D è possibile “zoomare”, ruotare e selezionare elementi con il semplice utilizzo del mouse.

Ciauz

.u

asp.net comments edit

Su segnalazione del buon Andrea, ho scoperto che, oltre ai “conditional attributes”, introduce un’altra novità chiamata “Tilde Slash” ossia “~/”.

Il concetto è simile a quello espresso in un mio vecchio post su Spark (vedi qui), con la differenza che in Spark si può specificare un dominio differente (molto comodo se si usa CDN).

In ogni caso l’utilizzo del Razor, con il Tilde Slash, aiuta lo sviluppatore nella scrittura del codice prendendosi in carico l’onere di risolvere automaticamente la url, eliminando così le noiose ripetizioni del ResolveUrl.

Dando un occhio al codice, questo markup

<img src="@Url.Content("~/Content/mylogo.png")" />

con Razor v2 diventa semplicemente questo

<img src="~/Content/mylogo.png" />

Beh comodo no?