di .NET e di altre amenità

Il ONE-Day è concluso e ora posso dire che si è trattato di un vero successo seguito da un ragguardevole numero di persone, circa 75, che anche a giudicare da un veloce sguardo ai feedback hanno dimostrato di essere soddisfatte di ciò che abbiamo presentato.

Al termine della spendida giornata che si è ormai conclusa, è venuto il momento di tirare le somme e fare i dovuti ringraziamenti.

Innanzitutto devo ringraziare Davide Vernole, che posso dire senza ombra di dubbio sia stato una risorsa indispensabile per la riuscita dell'evento. Il suo lavoro e le sue idee sono state linfa vitale per l'organizzazione, ed è obbligatoriamente a lui che va il mio primissimo grazie per la dedizione e la continuità con cui egli si impegna nelle attività di XeDotNet, lavorando instancabilmente su moltissimi fronti.

Il secondo pensiero va a Davide Senatore, la cui sessione su Silverlight 2.0 e i webgames è stata strepitosa. Ho visto un Davide davvero convincente, che ha miscelato con coscienza la parte ludica e la parte didattica dell'indovinato argomento della sua sessione.

Poi viene Andrea Dottor, che pur avendo iniziato a presentare nei nostri meeting da poco tempo, ha migliorato notevolmente rispetto i suoi primi interventi. La sua sessione è riuscita a mostrare una serie di argomenti che nessuno aveva mai affrontato su AJAX, e questo è un merito indiscutibile.

Ringrazio poi Pietro Brambati, e con lui tutto il DPE di Microsoft Italia  e in particolare Sara Morandini, che ha reso possibile l'evento. Pietro ha proposto una sessione che ha mostrato la vision di Microsoft rispetto la tecnologia web, mostrando tutta una serie di prodotti che sono usciti da poco oppure che dovranno uscire nei prossimi mesi.

Un ringraziamento particolare anche allo staff del Novotel, la cui precisione e puntualità è stata impeccabile. A detta di molti, il buffet che abbiamo gustato è stato di gran lunga il migliore da lungo tempo sia per qualità che per quantità. E con esso vorrei ringraziare anche la persona che nei moduli di feedback ha riportato "Troppa roba da mangiare!". Se i feedback negativi sono questi siamo orgogliosi anche di essi.

Ringrazio i 75 partecipanti, 75 volte a ciascuno, per la presenza, per l'apprezzamento, per i feedback, per la simpatia, e per le domande che ci hanno fatto e alle quali spero abbiamo risposto con completezza.

E poi c'ero anche io. Sul palco, verso la fine della sessione pensavo tra me e me che mi sono sentito un'altra persona. Non è certo compito mio darmi un giudizio, ma credo di aver dato il massimo e spero che questo sforzo che mi ha visto lavorare sul materiale della sessione fin da Natale si sia concretizzato in una sessione che abbia lasciato almeno un piccolo segno nei vostri cuori. Nel mio ha lasciato una profonda soddisfazione.

Stasera ho pubblicato la versione beta del mio editor per Silverlight. Con l'occasione ho anche provveduto a cambiargli il nome da SilverlightPad a Silverlight Playground 1.0. Si tratta - come avevo già anticipato in un mio precedente post - di un editor che consente la lavorazione di scene Silverlight mediante l'integrazione di un webserver embedded all'interno dell'applicazione stessa.

Grazie a ciò è possibile vedere la preview funzionante del codice appena scritto, direttamente nella form di editing, avvantaggiandosi anche della colorazione della sintassi per il codice da scrivere.

Ho pensato di introdurre un paradigma simile al codebehind di ASP.NET. Infatti ad ogni scena sarà sempre disponibile anche un file JS nel quale gestire gli eventi generati dall'interazione con l'interfaccia utente. Inoltre è possibile scrivere del codice in file separati e vederlo incluso al momento del runtime.

Trovate il progetto su codeplex: http://www.codeplex.com/silverlight

Durante l'ultimo meeting di XeDotNet, ho presentato un piccolo esempio, che è piaciuto molto, che dimostra abbastanza bene alcuni aspetti del DataBinding in Windows Presentation Foundation. Quando per la prima volta mi sono addentrato nell'argomento, sono rimasto molto incuriosito di una peculiarità che riguarda poco il DataBinding tradizionale, ma che regala a WPF una marcia in più rispetto a Windows Forms.

Mi riferisco alla possibilità di collegare tra loro mediante DataBinding gli elementi che compongono una interfaccia e di conseguenza in qualche modo coordinarne movimenti, dimensioni, stili, contenuti e quant'altro. L'esempio più banale, che tipicamente introduce le presentazioni su WPF - comprese le mie - è quello di uno slider che modifica le dimensioni di un oggetto dell'interfaccia. Un esempio di questo tipo, anche se un po' banale però rivela bene e con semplicità la potenza di questo meccanismo. Tuttavia nell'ultimo meeting ho voluto trovare un esempio un po' più di impatto, e che includesse anche qualcosa in più rispetto alla pura e semplice dimostrazione.

Nello screencast cast che potete scaricare in coda a questo post è spiegato passo passo come realizzare l'esempio ritratto nell'immagine. Il giocattolo è costituito da tre ruote dentate, forgiate con Microsoft Expression Designer. Esse sono collegate tra loro mediante DataBinding:

1 <Path.RenderTransform>
2   <RotateTransform 
3       x:Name="ruota2Anim" 
4       Angle="{Binding ElementName=ruota1Anim, 
5               Path=Angle, 
6               Converter={StaticResource angleConverter},       
7               ConverterParameter=-2.0}" />
8 </Path.RenderTransform>

Lo spezzone di codice mostra il punto cruciale dell'esempio. Si tratta di una trasformazione di rotazione, applicata al Path che costituisce una ruota. In particolare in questo caso si tratta della ruota gialla che è collegata a quella arancione. La proprietà Angle, cioè quella che determina l'angolo di rotazione applicato alla ruota, mostra l'applicazione del DataBinding mediante la Markup Extension "Binding". Al suo interno troviamo:

ElementName: Definisce il nome dell'elemento che funge da sorgente dati per la proprietà bindata. Nel nostro caso il riferimento è alla traformazione analoga applicata alla ruota arancione

Path: il nome della proprietà dell'elemento collegato dalla quale attingere. Per questo esempio ci colleghiamo alla stess proprietà Angle dell'elemento riferito.

Converter: Convertitore da utilizzare per calcolare il valore della proprietà. Utilizziamo una Markup Extension ancora una volta per riferire unìistanza di AngleConverter inserita nelle risorse della Window. Questo convertitore non fa altro che applicare un rapporto di demoltiplicazione all'angolo.

ConverterParameter: Parametro generico da passare al convertitore. Il parametro in questo caso sarà il fattore di demoltiplicazione da applicare alla ruota precedente.

 1 <Canvas.Triggers>
 2   <EventTrigger RoutedEvent="Canvas.Loaded">
 3     <EventTrigger.Actions>
 4       <BeginStoryboard>
 5         <Storyboard Name="animation">
 6           <DoubleAnimation 
 7                 Duration="0:0:3.0" 
 8                 To="360" 
 9                 RepeatBehavior="Forever" 
10                 Storyboard.TargetName="ruota1Anim" 
11                 Storyboard.TargetProperty="Angle" />
12         </Storyboard>
13       </BeginStoryboard>
14     </EventTrigger.Actions>
15   </EventTrigger>
16 </Canvas.Triggers>

A Completare l'esempio, viene applicata una animazione alla ruota arancione. Per capire il risultato, che comunque è spiegato nella sua completezza nel video, bisogna pensare a come i dati vengono propagati. L'animazione si occupa di applicare una rotazione da 0 a 360 gradi alla ruota arancione. Mediante DataBinding questo valore, opportunamente demoltiplicato passa alla ruota gialla. Il rapporto di conversione è negativo perchè in questo modo la ruota girerà alla rovescia. Infine un analogo Binding avviene tra la ruota gialla e quella viola. Ancora una volta la conversione sarà negativa per far ruotare l'ingranaggio al contrario rispetto alla sua fonte.

Date un'occhiata al risultato e creto che rimarrete affascinati dalla precisione con cui le ruote si ingranano le une con le altre senza alcuna sovrapposizione e senza il minimo errore. Personalmente la cosa che mi alletta di più è pensare che grazie al DataBinding la simulazione del movimento si svolge proprio come si svolgerebbe nella realtà in cui ogni ruota applica una forza alla successiva trasferendole il movimento.

Con questo post inizia una nuova categoria nel mio weblog che ho deciso di chiamare XAML Playground. Letteralmente, per i pochi che non siano avvezzi all'inglese, il parco dei divertimenti di XAML. Ho scelto questo nome perchè l'obbiettivo dei post che daranno vita, spero con continuità a questa serie, è di spiegare Windows Presentation Foundation per mezzo di una serie di "giocattoli" realizzati appositamente per chiarire il funzionamento e le caratteristiche di questa piattaforma.

In questa prima puntata affronteremo una delle componenti più importanti di WPF e cioè il Dependency Property System. Questo sistema - alla base del funzionamento di pressochè qualunque cosa in WPF, dal DataBinding, alle Animazioni - è stato creato per rispondere ad una esigenza importante. La natura dichiarativa di XAML, ha portato gli sviluppatori che hanno realizzato Windows Presentation Foundation a privilegiare le proprietà degli oggetti rispetto ai metodi, arrivando a rappresentare con esse anche i comportamenti e gli eventi. Per questo motivo, a supporto delle proprietà è stato creato il Dependency Property System, che ha l'onere di conferire a dei particolari tipi di proprietà, denominate DependencyProperty, una serie di caratteristiche quali Notifica, Validazione, Coercizione, Ereditarietà, etc. In particolare nel sorgente scaricabile in coda a questo post, è presente un esempio di come creare una dependency property che supporti l'ereditarietà.

I passi per creare la DependencyPropery sono quattro:

Creare un identificatore della proprietà

Il sistema di Dependency Property richiede che le proprietà cui viene conferito questo incarico dispongano di un identificatore sotto forma di un campo statico di tipo DependencyProperty esposto pubblicamente dalla classe cui appartiene. Questo campo dovrà essere usato ogni qualvolta ci si riferisca in qualche modo alla DependencyProperty, ad esempio per associarla ad una animazione oppure ad una trasformazione.

Registrazione

La fase di registrazione consente di stabilire le caratteristiche della proprietà. Nel nostro caso ad esempio associeremo ad essa un metadata che informerà il runtime che la proprietà supporta l'ereditarietà. Questi metadata regolano svariati aspetti della DP, ad esempio relativamente le animazioni, il DataBinding, il layout. Inoltre ad essa è possibile associare uno o più eventi relativi il cambio di valore, la validazione, la coercizione etc. Infine durante la registrazione si da alla proprietà il nome, il tipo e il valore di default.

Creazione del Wrapper

La Dependency Property a questo punto viene esposta per mezzo di una normale proprietà della classe, che utilizza i metodi SetValue() e GetValue() ereditati dall'oggetto DependencyObject, per assegnare e  leggere il valore.

Gestione degli Eventi

Durante la vita dell'oggetto è nostro compito gestire gli eventi che sono generati dal runtime in svariate occasioni. La gestione degli eventi consente ad esempio di conferire alla proprietà la caratteristica di influire sul comportamento della classe cui essa appartiene. Nel codice allegato a questo articolo ad esempio, il valore della proprietà distance viene utilizzato per impostare il margine attorno ad un rettangolo.

Al compimento di questi semplici passi, la nostra DependencyProperty e' pronta all'uso. Per capire meglio quanto descritto è opportuno osservare l'esempio che viene illustrato dal video. In questo screencast, viene appunto dimostrata la creazione di una proprietà Distance, applicata ad una classe che eredita da Border. Scopo di questa proprietà è quello di definire la distanza tra due bordi annidati. Grazie all'ereditarietà il valore della proprietà si propaga ai bordi annidati ottenendo un simpatico effetto tunnel del tutto simile a quello visibile nell'immagine che accompagna l'articolo.