Archive

WPF

Siamo alla fase di collaudo finale della nostra nuova applicazione TFC. Questa applicazione è composta da un server J2EE (su WebSphere Application Server) che si interfaccia ad una applicazione gestionale e da un client sconnesso scritto in WPF 4 destinato all’uso su Tablet PC di tipo slate. Una classica applicazione enterprise ma che usa uno strumento “nuovo" (nuovo se tralasciamo il fatto che i Tablet PC esistono da anni).

Una delle macchine papabili per il client è l’Acer Iconia Tab W500. Si tratta di uno slate basato su Windows 7 con un processore AMD, 2GB di RAM, un disco SSD da 32 GB e un touch screen capacitivo a 4 punti molto preciso. In effetti l’interazione è buona e l’uso delle applicazioni tradizionali è assolutamente accettabile (soprattutto se le applicazioni sono in grado di gestire i 120 DPI impostati del monitor). La macchina è anche discretamente veloce. Il peso è di circa 1 Kg. E’ veramente una buona macchina.

Come accennato l’applicazione client è basata su WPF su .NET 4. Con WPF siamo riusciti ad adattare molto bene l’interfaccia utente al touch. E’ evidente a prima vista che non si tratta della solita interfaccia Windows ma di una interfaccia appositamente pensata. In generale questa applicazione ha generato entusiamo tra i clienti ma anche internamente (tanto è vero che stanno nascendo nuove idee commerciali e tecniche).

Ovviamente con questa nostra applicazione WPF, l’Iconia si comporta meravigliosamente. L’applicazione quando è in primo piano si impossessa completamente dello schermo (ma si può sempre switchare su un’altra), gestisce completamente touch e gesture (touch, pan, pinch zoom, ecc.), utilizza icone, comandi e immagini a misura di dita. E lo sviluppo è stato assai più economico che utilizzare iPad. Vedere cosa si può fare utilizzando Windows 7 è notevole. 

Ora aspetto con fiducia che Microsoft faccia una interfaccia alternativa a Windows Explorer. Ma presto per favore.

Ebbene sì! Ho comprato un nuovo Mac! Ci servirà per sviluppare delle applicazioni su iPad. Prima che pensiate che io abbia cambiato bandiera, vi rammento che, come azienda, non lavoriamo solo su Microsoft e preciso anche che stiamo sviluppando alcune di queste applicazioni su tablet PC multitouch con Windows 7.

Tornando al Mac, ho installato xCode e ho cominciato a vedere anche come si sviluppa su OSX. Dopo pochi minuti avevo una sensazione forte di deja-vu… all’inizio pensavo fosse legata alla mia lunga esperienza in Smalltalk ma dopo un po’ mi sono reso conto da dove arrivava: da alcuni esperimenti fatti con NextStep e il suo Interface Builder molti anni fa! Devo dire che la cosa mi è piaciuta… e devo aggiungere che anche OSX mi piace e che lavorarci sopra è divertente ma… Windows 7 (o meglio .NET) è assai meglio. Sicuramente il fascino di OSX sta nella coerenza mentre Windows, per questioni di compatibilità con il passato, soffre un po’ sotto questo aspetto.

Comunque OSX sarà anche il sistema operativo più avanzato al mondo (parole di Apple)ma sinceramente alcune delle sue API sono vecchie! Quando NextStep è uscito era sicuramente un oggetto incredibilmente avanzato ma ora mi sembra che dimostri tutta la sua età. Ad esempio le API e i controlli/widget per lavorare con la GUI sono interessanti ma datate. Su .NET si può lavorare con WPF che permette di ottenere risultati migliori con uno sforzo nettamente minore. E anche gli strumenti di sviluppo sono all’altezza di tale ambiente: VisualStudio 2010 e Blend 4 ti fanno lavorare assai meglio e in minor tempo.

Bah… magari cambierò idea più avanti.

Una delle cose più belle di Vista è il fatto che Microsoft ha praticamente costretto i produttori a mettere nei PC delle schede video decenti con il supporto DirectX. Questo abilita e migliora una serie di funzionalità tra cui WDDM e WPF.

Questo è uno dei fattori che sta facendo fare un salto di qualità all’esperienza dell’utente (tralasciando i driver bacati, ovviamente). E’, secondo me, anche uno dei fattori determinanti che mettono sullo stesso piano Windows 7 e Mac OSX.

Ora si apprende che IE9, come Silverlight, userà l’hardware grafico per accelerare il rendering. Che altro dire se non che è una buona cosa!

Invidiate il NY Times per il loro lettore offline? Volete creare una rivista elettronica aziendale? Aggiornata in modo automatico? Volete fare in modo che le stampe siano di ottima qualità e in stile giornalistico? Oppure semplicemente volete vedere come costruire una applicazione del genere usando WPF?

Allora il Syndicated Client Experiences Starter Kit è quello che ci vuole.

Come esempio forniscono MSDNReader, un lettore per gli articoli MSDN Magazine.

Cosa hanno in comune con me il compasso, la squadra, i corsi di disegno tecnico, le proiezioni, la trigonometria, Geometria 1 e la mia calcolatrice programmabile preferita?

Hanno in comune il fatto che mi stanno tornando utili, nel bene e nel male, per due scopi: aiutare mia figlia in alcune attività scolastiche e disegnare controlli ed elementi WPF. Tralasciando l’attività più importante (cioè aiutare la figlia), devo dire che il conoscere questi strumenti aiuta molto nella creazione di controlli e componenti riutilizzabili in WPF. Ad esempio a tempo perso sto creando un menu che utilizza dei settori circolari traslati e ruotati: usare concetti di base di trigonometria è assai utile. La calcolatrice, che effettua calcolo matriciale e vettoriale anche simbolico, è molto apprezzabile durante la definizione di trasformazioni.

Serve tutto questo per sviluppare applicazioni WPF? La risposta è no! Utilizzare WPF è molto semplice ma aggiungere la matematica e il disegno tecnico aumenta le possibilità per il programmatore e il relativo divertimento.

E, se mi consentite la digressione, mi sta tornado utile anche la storia della letteratura inglese che ho studiato al liceo per apprezzare ancora di più il romanzo che sto leggendo in questi giorni: Il caso Jane Eyre di Jasper Fforde.

Devo dire che all’inizio LINQ in C# mi lasciava un po’ perplesso. L’idea di complicare il linguaggio di programmazione aggiungendo costrutti mi rende nervoso. Io la chiamo sindrome da PL/I ma l’ho sperimentata con il C++: il linguaggio diviene così complesso che per realizzare un progetto serve un esperto del linguaggio stesso.

LINQ in realtà si integra bene con C# e diviene presto naturale utilizzarlo. Per provarlo ho aggiunto delle funzioni di ricerca relativamente sofisticate ad un mio programma (in realtà è il mio Pet Project che uso per fare esperimenti) utilizzando il binding SQL.

image

Ho creato un piccolo parser utilizzando una serie di if con una serie di espressioni regolari. Ho cablato diverse query utilizzando i risultati di questo piccolo parser. In pratica prelevo il contenuto del TextBox di ricerca e quando soddisfa il match con una espressione regolare simile a questa (ho semplificato il codice)

Regex reAnnoMese = 
   new Regex(@"^([0-9]){4}\s+[a-zA-Z]+$");

eseguo la query corrispondente simile a questa

if (reAnnoMese.Match(searchText).Success)
{
   RicevutaDataContext dcRicevuta
      = new RicevutaDataContext();
   int posSpazio = searchText.IndexOf(" ");
   string anno = searchText.Substring(0, posSpazio);
   string mese = searchText.Substring(posSpazio + 1);
   int numeroMese = GetMonthNumber(mese);
   var queryRicevuta = 
      from ricevuta in dcRicevuta.Ricevutas
      orderby ricevuta.Anno descending,
              ricevuta.Numero descending
      where ricevuta.Anno.Equals(anno)
         && ricevuta.DataEmissione.Value.Month
            == numeroMese
      select ricevuta;
   DataContext = queryRicevuta;
}

RicevutaDataContext è un DataContext creato con un semplice drag&drop della tabella Ricevuta dal mappatore del VS2008. GetMonthNumber è una funzione che restituisce il numero ordinale corrispondente al mese e utilizza al suo interno le funzioni .NET per la localizzazione e che restituiscono i nomi dei mesi. Nell’ultima istruzione effettuo il binding della query con un elemento WPF (una Page contenente una ListView in questo caso).

Se nel TextBox scrivete 2006 giugno (o June: dipende dalle impostazioni) questo codice estrae tutte le ricevute emesse nel giugno 2006. LINQ genere codice SQL del tipo:

SELECT [t0].[IdRicevuta], 
       [t0].[Numero], [t0].[Anno], 
       [t0].[DataEmissione], [t0].[Intestazione], ....
FROM [dbo].[Ricevuta] AS [t0]
WHERE ([t0].[Anno] = @p0) 
AND (DATEPART(Month, [t0].[DataEmissione]) = @p1)
ORDER BY [t0].[Anno] DESC, [t0].[Numero] DESC

Il fatto che il risultato della query LINQ non sia altro che una collezione .NET (per la precisione un IEnumerable su cui è possibile navigare) ne rende l’utilizzo praticamente trasparente.

Il codice non è particolarmente furbo (e neanche elegante) ma è proprio questa la sua bellezza: l’ho scritto senza pensarci troppo e ho ottenuto un buon risultato. Altri meccanismi mi avrebbero costretto a ragionare troppo (Ehi, sono quasi in vacanza!), ad utilizzare classi più complesse, a passare per sofisticati ORM, a scrivere SQL.