Code Tailor

FTToolkit: Intervista sul blog Fotolia

2012-01-24T15:00:00.001+01:00

Vi segnalo una mia intervista pubblicata sul blog di Fotolia all’indirizzo:

http://blog.fotolia.com/it/2012/01/23/intervista-a-massimo-bonanni/

relativa al mio progetto open-source FTToolkit (http://fttk.codeplex.com).

Sono veramente contento di questo apprezzamento da parte di una piattaforma di servizi (quella di Fotolia) orientata all’open source non-Microsoft.

Prossimamente nuovi aggiornamenti sul toolkit e sui samples.

Guest post su MSDN per Translation Machine

2012-01-16T12:40:00.001+01:00

Vi segnalo il mio Guest Post su MSDN relativo alla Machine Translation di Microsoft:

http://blogs.msdn.com/b/italy/archive/2012/01/16/guest-post-microsoft-translator-traduzioni-automatiche-o-quasi-semplici.aspx

Tag di Technorati: MSDN,guest post,machine translation,translation,bing

Rilasciata la versione 1.1 di FTTK

2012-01-04T12:57:00.001+01:00

E' stata rilasciata la versione 1.1 di FTTK (FT Toolkit), il progetto open source per l'integrazione con la piattaforma Fotolia.

Il toolkit esegue un wrapping delle API (sia in formato REST che XmlRPC) esposte da Fotolia (documentazione).

Il toolkit è composto da tre assembly distinti:

FTTK.Core: contiene le interfacce e le entità dell'Object Model Fotolia.

scaricare tramite Nuget
scaricare tramite CodePlex

FTTK.Rest: contiene l'implementazione dei servizi di accesso alla piattaforma Fotolia tramite protocollo REST.

scaricare tramite Nuget
scaricare tramite CodePlex

FTTK.XmlRpc: fornisce l'implementazione dei servizi di accesso alla piattaforma Fotolia tramite protocollo XmlRpc. Questa libreria diventerà obsoleta con i prossimi rilasci poiché i servizi esposti da Fotolia stessa in XmlRpc verranno abbandonati.

scaricare tramite Nuget
scaricare tramite CodePlex

Le novità più importanti, oltre alla pubblicazione della versione REST, è il supporto per Silverlight 4.0 e Windows Phone 7 (mango) (attualmente solo per FTTK.Core).

Prossimamente verrà rilasciato anche FTTK.Rest per WP7 e dei progetti di esempio sull'utilizzo.

Il sito ufficiale del progetto è http://fttk.codeplex.com.

Tag di Technorati: fotolia toolkit,fotolia,fotolia API,api rest,api xmlrpc,ft toolkit,fttk

MVP: two in a row!!!!

2012-01-02T09:29:00.001+01:00

Sono onorato di aver ricevuto anche quest’anno l'MVP Award da parte di Microsoft.

Se possibile, la seconda volta è più emozionante della prima (che, in ogni caso, rimane indimenticabile).

Un anno da MVP in cui ho conosciuto persone nuove, dato volti a nomi che avevo solo letto su internet e potuto condividere esperienze altrimenti impossibili (vedi l’MVP Summit a Seattle).

Debbo ringraziare DomusDotNet senza la quale, difficilmente, sarei riuscito ad ottenere tutto questo e i ragazzi che la compongono (che mi sopportano)!!!

Un particolare ringraziamento va a tutti coloro che hanno creduto in me (non c’è la necessità di fare nomi) e che provvederò a ringraziare di persona.

Diventare MVP è un onore: dissi lo scorso anno che è come andare a giocare in Nazionale, ma essere confermato è veramente fantastico.

E’ come una droga, una volta che sei MVP, fai del tutto per essere riconfermato!!!

Veramente una grande FAMIGGHIA!!!!

Grazie!!!

Tag di Technorati: mvp,mvp award,mvp 2012

Deserializzazione JSON e costruttori: OnDeserialized e OnDeserializing

2011-12-19T08:00:00.000+01:00

In questo post vorrei illustrarvi l’utilizzo degli attributi OnDeserializingAttribute e OnDeserializedAttribute contenuti nel namespace System.Runtime.Serialization.

Il loro scopo è quello di decorare dei metodi che verranno richiamati, rispettivamente, prima (OnDeserializing) e dopo (OnDeserialized) la deserializzazione di un oggetto tramite determinati serializzatori che vedremo più avanti.

Vediamo il loro possibile utilizzo in caso di deserializzazione JSON.

Supponiamo di avere il seguente JSON:

 {"nome":"Giuseppe","cognome":"Verdi"}
 

una possibile classe che permette la deserializzazione di tale JSON potrebbe essere:

 Imports System.Xml.Serialization
Imports System.Runtime.Serialization
 
<DataContract()>
Public Class Persona
 
    Public Sub New()
 
    End Sub
 
    <DataMember(Name:="nome")>
    Public Property Nome As String
    <DataMember(Name:="cognome")>
    Public Property Cognome As String
 
    Private _DataCreazione As DateTime = DateTime.Now
    Public ReadOnly Property DataCreazione As DateTime
        Get
            Return Me._DataCreazione
        End Get
    End Property
 
End Class
 

Ho inserito la proprietà che contiene la data di creazione dell’oggetto per dimostrare una cosa che vedremo tra poco.

Prendiamo il seguente metodo che deserializza il JSON di cui sopra:

 Imports System.Xml.Serialization
Imports System.IO
Imports System.Runtime.Serialization.Json
Imports System.Text
 
Module Module1
 
    Sub Main()
        Dim persona As Persona
        Dim serializer = New DataContractJsonSerializer(GetType(Persona))
        Using memStream = New MemoryStream(Encoding.Default.GetBytes(GetJSON()))
            persona = CType(serializer.ReadObject(memStream), Persona)
        End Using
    End Sub
    
    Private Function GetJSON() As String
        Return "{""nome"":""Giuseppe"",""cognome"":""Verdi""}"
    End Function
 
End Module
 

Se eseguiamo il metodo e ci fermiamo immediatamente dopo la deserializzazione (metodo ReadObject della classe DataContractJsonSerializer), otteniamo:

cioè la data di creazione non è stata impostata.

Questo accade perché il serializzatore DataContractJsonSerializer (ma non è l’unico in quanto avviene anche con il DataContractSerializer, il NetDataContractSerializer e il BinaryFormatter) non richiama il costruttore.

Quindi, se abbiamo dei valori di default da impostare o dei valori da assegnare alla creazione dell’oggetto, con la deserializzazione siamo fregati.

E’ in questo scenario che ci vengono in aiuto i due attributi OnDeserializing e OnDeserialized:

 Imports System.Xml.Serialization
Imports System.Runtime.Serialization
 
<DataContract()>
Public Class Persona
 
    Public Sub New()
 
    End Sub
 
    <DataMember(Name:="nome")>
    Public Property Nome As String
    <DataMember(Name:="cognome")>
    Public Property Cognome As String
 
    Private _DataCreazione As DateTime = DateTime.Now
    Public ReadOnly Property DataCreazione As DateTime
        Get
            Return Me._DataCreazione
        End Get
    End Property
 
    <OnDeserialized()>
    Public Sub OnDeserialized(context As StreamingContext)
 
    End Sub
 
    <OnDeserializing()>
    Public Sub OnDeserializing(context As StreamingContext)
        Me._DataCreazione = DateTime.Now
    End Sub
End Class
 

Il metodo decorato con Ondeserializing viene richiamato immediatamente prima della deserializzazione, mentre quello decorato con OnDeserialized immediatamente dopo.

In questo modo, se rieseguiamo il metodo di prima in cui deserializziamo il JSON:

la data è effettivamente valorizzata.

I metodi decorati con questi attributi debbono avere come argomento un oggetto di tipo StreamingContext e possono essere utilizzati per controllare la deserializzazione dei nostri oggetti:

Ad esempio il seguente metodo solleva un’eccezione quando si tenta di serializzare oggetti in orari con minuti pari :

 <OnDeserializing()>
Public Sub OnDeserializing(context As StreamingContext)
    If DateTime.Now.Minute Mod 2 = 0 Then
        Throw New Exception()
    End If
    Me._DataCreazione = DateTime.Now
End Sub
 

Esistono dei corrispettivi attributi OnSerializing e OnSerialized per le operazioni di serializzazione.

Tag di Technorati: json,deserializzazione,costruttori,datacontractjsonserializer,Oonserializedattribute,onserializingattribute,ondeserializedattribute,ondeserializingattribute

Community Days 2012 - Milano, 16 e 17 febbraio 2012

2011-12-16T09:21:00.001+01:00

DomusDotNet presenta, in collaborazione con le altre community ed user group italiani,
il maggior evento community dell'anno: 12 track spalmate su 2 giorni interamente dedicati alle ultime tecnologie, 4 lab ed i migliori speaker italiani.

Windows 8, Windows Phone, Entity Framework, ASP.NET, .NET Framework 4.5 e Visual Studio 2011, applicazioni mobili, HTML 5 e tanto, tanto altro ancora!

La partecipazione, come sempre, è totalmente gratuita. Le iscrizioni sono aperte e l'agenda è
disponibile sul sito. ISCRIVITI SUBITO!

Tag di Technorati: community days,evento,community

Uguaglianza tra tipi in VB.NET

2011-12-12T12:28:00.001+01:00

Se abbiamo due istanze della classe Type e vogliamo verificare che tali istanze rappresentino effettivamente lo stesso tipo, possiamo procedere in due modi

Siano Type1 e Type2 le due istanze di Type da controllare.

Un primo modo è utilizzare l’operatore Is:

 If Type1 Is Type2 Then
    ' i tipi sono uguali
Else
    ' i tipi non sono uguali
End If
 

In alternativa possiamo utilizzare il metodo statico (shared) Equals:

 If Type.Equals(type1, type2) Then
    ' i tipi sono uguali
Else
    ' i tipi non sono uguali
End If
 

In quest’ultimo caso, in realtà, stiamo utilizzando il metodo Equals (shared) di Object, la cui definizione è:

Tag di Technorati: Type,vb.net,Equals

Aprire un file xml in un’applicazione LightSwitch

2011-11-28T13:22:00.001+01:00

Da qualche giorno sto lavorando con LightSwitch (ed il buon Alessandro sa quanto apprezzo il prodotto!!!) e la logica con cui si approccia alla soluzione di un problema, anche banale, di programmazione è piuttosto differente da chi proviene dalle applicazioni desktop classico.

Ricordatevi sempre che stiamo parlando di Silverlight, quindi, già per questo, non date per scontato che possiate fare quello che volete, in più sotto LightSwitch.

Per questo motivo, ogni volta che mi scontrerò con un problema da “desktoppiano” classico e riuscirò a venirne a capo, cercherò di postarlo qui. Probabilmente la soluzione sarà banale e puerile, ma magari potrà servire ad altri!!

Detto questo, supponendo di voler aprire un file Xml e creare un oggetto XDocument utilizzando il metodo statico Load(String), normalmente scriveremmo

 Dim xmlTemplate As XDocument
xmlTemplate = XDocument.Load(fullFileName)
 

dove fullFileName è il nome completo (con tanto di path) del file xml da aprire.

Questo funziona benissimo nelle nostre applicazioni desktop classiche ma non in LightSwitch che ci restituirà l’errore:

Per risolvere il problema è sufficiente utilizzare il metodo Load(Stream, LoadOptions):

 Dim xmlTemplate As XDocument
Using fileStream = New FileStream(fileFullName, FileMode.Open)
    xmlTemplate = XDocument.Load(fileStream)
End Using
 

In questo modo non otteniamo l’errore precedente e riusciamo a creare il nostro XDocument (a patto, ovviamente che il file sia ben formato).

Tag di Technorati: lightswitch,xmlrpc,aprire xml,xdocument,xdocument.load

Rilasciata la versione 3 di Async CTP

2011-11-16T08:59:00.001+01:00

In attesa di avere, “di serie”, la programmazione asincrona a task all’interno di Visual Studio e del framework (sarà presente in Dev11), è stata rilasciata la versione 3 di Async CTP.

Async CTP è un pacchetto che introduce la programmazione asincrona a task (che semplifica di molto la scrittura del codice multithread) all’interno di Visual Studio 2010.

Async CTP, di fatto, introduce nuove parole chiave e tutta l’infrastruttura che permette al compilatore di gestirle.

Per maggiori info sulla programmazione asincrona a task, vi consiglio il link: http://msdn.microsoft.com/en-us/vstudio/gg316360

Per il download del pacchetto di installazione di Async CTP 3, potete utilizzare il link: http://www.microsoft.com/download/en/details.aspx?id=9983

La versione 3 di Async CTP è compatibile con le installazioni non in lingua inglese di VS, Silverlight 5 e Roslyn ed include una EULA (http://it.wikipedia.org/wiki/EULA) che ne permette (ma non incoraggia) l’utilizzo della stessa in produzione.

Tag di Technorati: async ctp,async,visual studio

FT Toolkit v.1.0 is out!!

2011-11-13T19:20:00.001+01:00

Finalmente sono orgoglioso di comunicarvi che la prima release di FT Toolkit è out!!

Cosa è FT Toolkit?

FT Toolkit è un insieme di classi che consentono di accedere in maniera semplice ai servizi di Fotolia.

Per chi non la conoscesse, Fotolia è una delle maggiori agenzie on-line per stock-foto con circa 14 milioni di immagini a disposizione dei propri clienti.
Fotolia mette a disposizione degli sviluppatori una serie di servizi (inizialmente con protocollo XmlRpc e adesso anche in Rest) per accedere alle funzionalità della piattaforma (come ad esempio eseguire ricerche sulla banca dati immagini, creare gallerie, gestire il proprio account e così via).

Per maggiori info sulle API esposte fare riferimento al link http://it.fotolia.com/Services/API/Introduction

Fino ad ora (almeno che io sappia e avendo ricevuto conferma dal gruppo si sviluppo interno a Fotolia stessa) non esisteva un toolkit che permettesse facilmente, a chi sviluppa con linguaggi .NET, di accedere ai servizi (lo si poteva fare ma implementando le interfacce XmlRpc).

FT Toolkit nasce proprio per questo, fornire un Object Model e dei servizi per wrappare le chiamate ai servizi della piattaforma Fotolia.

Attualmente ci sono solamente due moduli:

FTTK.Core (che contiene le entità dell’object model e le interfacce dei servizi)
FTTK.XmlRpc (che contiene le implementazioni delle interfacce contenute nel Core e che accedono ai servizi XmlRpc).

Entrambi sono pensati per il framework .NET 4.0 e funzionano per applicazioni Desktop o server (no silverlight o wp7).

Prossimamente saranno rilasciati i moduli per Silverlight e WP7 , nonchè le implementazioni per il protocollo REST.

Il sito ufficiale di FTTK è http://fttk.codeplex.com ma i moduli sono disponibili anche su NuGet:

FTTK.Core : http://www.nuget.org/List/Packages/FTTK.Core

FTTK.XmlRpc: http://www.nuget.org/List/Packages/FTTK.XmlRpc

Se siete interessati restate connessi, perhè prossimamente pubblicherò altri post al riguardo!!!!

Tag di Technorati: fotolia,fttk,fotolia toolkit,ft toolkit,xmlrpc,stock agency

Nuova release dell’SDK per Kinect

2011-11-05T17:21:00.001+01:00

Dopo una settimana intensa dal punto di vista lavorativo e non (evento ALM Revolutions da sovraintendere), eccomi qui a postare qualcosa (come non mi capita più spesso nell’ultimo periodo ).

Questa volta si tratta della nuova versione del Kinect SDK per Windows rilasciata il 1 Novembre.

Cominciamo dal nuovo sito ridisegnato (http://www.kinectforwindows.org/):

Nel sito trovate documentazione, risorse e il link per il download del nuovo SDK (sia nella versione 32bit che 64 bit).

Le novità presenti in questa release (che tengo a precisare non è ancora una versione commercial la quale sarà disponibile “early 2012”) sono, fondamentalmente :

Miglioramenti e ottimizzazioni del motore di skeletal tracking. Viene dichiarato un 20% di incremento delle performance rispetto alla precedente versione e un miglioramento nell’accuratezza e tracciatura dei joint dello scheletro;
E’ possibile attaccare e staccare a caldo il Kinect senza avere problemi con la classe Runtime di gestione dello stesso;
Supporto per Windows 8 Developer Preview.

Nei prossimi giorni vedrò di analizzare l’SDK nuovo e segnalarvi eventuali differenze (non dovrebbero esserci) in termini di classi o utilizzo, rispetto alla precedente versione.

Per ora, il consiglio che vi posso dare è di guardarvi i seguenti video:

Kinect Effect Video

Shape game image

Tag di Technorati: kinect sdk,kinect for windows,sdk,xbox

Rilasciata EF 4.2

2011-11-02T09:31:00.001+01:00

E’ di ieri l’annuncio del rilascio di EF 4.2.

Maggiori informazioni potete trovarle sul post del blog di ADO.NET all’indirizzo: http://blogs.msdn.com/b/adonet/archive/2011/11/01/ef-4-2-released.aspx

Tag di Technorati: entity framework,ef,entity framework 4.2,ef 4.2,code first,database first

Windows Phone 7.5 Developer Day/Lab a Roma

2011-10-21T09:09:00.001+02:00

Vi segnalo due eventi (che si svolgeranno in contemporanea)organizzati da Microsoft in collaborazione con Nokia per il 15 Novembre 2011 presso la sede Microsoft di Roma (Viale Avignone 10).

Windows Phone 7.5 Developer Day – una giornata dedicata allo sviluppo per Windows Phone 7.5, dove si parlerà del Windows Phone Runtime, delle novità della versione 7.5 (Fast Application Switching, Tombstoning, Multitasking, Live Tiles e Push Notification, etc…), di come costruire un’applicazione completa, del marketplace e di come monetizzare le proprie applicazioni. Gli speaker saranno Daniele Bochicchio e Cristian Civera, che hanno realizzato alcune tra le più importanti e conosciute applicazioni italiane per Windows Phone 7 e 7.5.
Per iscrivervi potete andare qui.
Windows Phone 7.5 Developer Lab – un laboratorio pratico dedicato a Windows Phone 7.5, dove provare sul campo lo sviluppo di applicazioni per Windows Phone 7.5. Affiancati da me e da altre persone molto competenti sullo sviluppo Phone, potrete anche testare le applicazioni su telefoni reali anche dotati di giroscopio, bussola, etc..
Durante il laboratorio sarà possibile avere assistenza anche nella migrazione delle proprie applicazioni da altre piattaforme mobili.
Per partecipare al laboratorio bisogna portare il proprio portatile con il Windows Phone SDK e lo Zune Client installati. Per iscrivervi potete andare qui.

In entrambi gli eventi se avete delle applicazioni pronte, in sviluppo o appena rilasciate sul Marketplace portatele e fatecele vedere, riceverete una sorpresa!

Tag di Technorati: WP/,Windows Phone 7,lab,nokia,microsoft,evento

Rilasciata la versione CTP di Roslyn

2011-10-20T09:37:00.001+02:00

Ieri sera (da noi) è stata rilasciata la versione CTP di Roslyn.

Roslyn, in poche parole (insufficienti e parziali), è un progetto che nasce con lo scopo di “aprire” la scatola nera Compilatore in modo da permettere una personalizzazione dello stesso.

Il download della CTP e risorse per poter approfondire il discorso sono disponibili all’indirizzo http://msdn.microsoft.com/it-it/roslyn

Tag di Technorati: Roslyn,compilatore,ctp

MSDN Blog: Umbraco su Windows Azure. Come e Perchè (1 Parte)

2011-10-18T13:23:00.001+02:00

Vi segnalo la prima parte di una interessante serie di articoli di Roberto Freato sul blog MSDN di Mario Fontana:

http://blogs.msdn.com/b/mariofontana/archive/2011/10/18/umbraco-su-windows-azure-come-e-perch-232-1-parte.aspx

Tag di Technorati: azure,windows azure,cms,umbraco,cloud

Alcuni web cast su Denali in BEIT

2011-10-17T17:04:00.001+02:00

Vi segnalo che sono stati pubblicati alcuni Web Cast su BEIT relativi a Denali la nuova versione di SQL Server.

L’indirizzo a cui potete trovare il materiale è:

http://www.microsoft.com/italy/beit/Msdn.aspx?search=denali&type=-1&audience=2&userlevel=-1&product=-1&authorName=-1

Buona visione!!

Tag di Technorati: denali,webcast,beit

Visual Studio 11 – Impostare il target framework e la CPU

2011-10-17T14:56:00.001+02:00

Visual Studio 11, come il suo predecessore Visual Studio 2010, consente di selezionare per quale versione del framework compilare il nostro progetto solo che permette di farlo in maniera più semplice.

Se vogliamo impostare il framework di compilazione in Visual Studio 2010, dobbiamo andare nelle proprietà del progetto, selezionare la scheda “Compile”

e il bottone “Advanced Compile Option” in modo da aprire la finestra delle impostazioni avanzate di compilazione:

In questa finestra troviamo la casella a discesa che ci consente di selezionare il framework di destinazione.

In VS11 la procedura è stata semplificata e la combo di scelta è stata inserita direttamente nella scheda “Application”:

Possiamo osservare, inoltre, che la scelta della CPU di destinazione, che nel VS2010 è contenuta sempre nella finestra delle impostazioni avanzate di compilazione, è stata spostata all’interno della scheda delle impostazioni di compilazione:

Da notare la presenza del flag “Prefer 32-bit” (utilizzabile solo se si è scelta l’opzione “Any CPU”) che consente di compilare in modo che l’applicazione verrà eseguita in modalità 32-bit ove è possibile.

Tag di Technorati: visual studio 11,dev11,target cpu,target framework,application property

WPC2011 sta per arrivare!!!

2011-10-13T10:22:00.001+02:00

WPC è il più importante evento italiano di formazione: 3 giorni di sessioni di ottimo livello con ottimi speaker!! Che aspettate!!!!

Fate un giro sul sito ufficiale (http://www.wpc2011.it), guardate l’agenda e non potrete non iscrivervi!!!!

Tag di Technorati: wpc,wpc2011,evento,formazione

ALM Revolutions e FREE Web Workshop

2011-10-11T08:53:00.001+02:00

Siete interessati all’ALM (Application LIfecycle Management)?

Se si vi segnalo due interessanti appuntamenti.

Il primo è un pomeriggio, organizzato da DomusDotNet, con 4 sessioni tutte incentrate, appunto, su ALM.

L’evento si terrà il giorno 3 Novembre 2011 presso la sede Microsoft di Roma e l’agenda è la seguente:

14:00-14:30 Registrazione

14:30-14:45 Keynote di benvenuto

14:45-15:30 Non si vive di solo check-out e check-in
(Gian Maria Ricci, MVP Visual Studio ALM e fondatore DotNetMarche)
Il source control è lo strumento fondamentale per la gestione dei propri progetti e spesso purtroppo anche il meno conosciuto. Troppo spesso i team utilizzano solamente le funzionalità più base di un VCS senza usufruire a pieno di tutte le sue potenzialità. In questa sessione vedremo alcune best practice da adottare per la gestione del codice basandoci sul source control di TFS e parleremo quindi di branch, shelvest, integration platform ed altro.

15:30-16:15 Real World Team Foundation Server
(Matteo Emili, MVP Visual Studio ALM e fondatore DomusDotNet)
Tips and tricks per l'amministratore "casuale". Avete installato in test Team Foundation Server e siete diventati de facto amministratori di uno dei sistemi più importanti per il team di sviluppo? Avete ereditato l'installazione da qualcun'altro e vi state chiedendo come è potuto succedere? In questa sessione vedremo una serie di cose che avreste voluto sapere prima di diventare "casualmente" amministratori di Team Foundation Server.

16:15-16:30 Pausa

16:30-17:15 TFS Team process template customization
(Gian Maria Ricci, MVP Visual Studio ALM e fondatore DotNetMarche)
Team Foundation Server garantisce una estrema flessibilità nella personalizzazione dei Work Item, permettendovi di adattarlo al vostro processo di sviluppo. In questa sessione vedremo come modificare la definizione di Work Item aggiungendo campi, regole ed andando a modificare il workflow che regola la gestione degli stati.

17:15-18:00 What's new on Visual Studio ALM 11?
(Matteo Emili, MVP Visual Studio ALM e fondatore DomusDotNet)
In questa sessione per la prima volta inizieremo a vedere cosa Microsoft sta preparando per la prossima release di Visual Studio ALM.
Local Workspaces, Team Foundation Service, Feedback Manager e Storyboarding sono solo alcune delle novità che verranno affrontate.
Da non perdere per non farsi cogliere impreparati "dall'onda".

18:00 Conclusioni

Per maggiori info, dettagli logistici ed iscrizioni, trovate la pagina dell’evento all’indirizzo http://www.domusdotnet.org/eventi/alm-revolutions.aspx

Vi segnalo, infine, una serie di Workshop organizzati da Microsoft e segnalati nel seguente post di Lorenzo Barbieri: http://blogs.msdn.com/b/italy/archive/2011/10/10/free-web-workshop-microsoft-visual-studio-2010-alm-tools.aspx

Ora non avete più scuse per non approfondire il discorso su ALM!!!!

Tag di Technorati: alm,application lifestyle management,agile,web cast,domusdotnet,evento

Comunicando: History Tech Day

2011-09-19T09:47:00.001+02:00

Vi segnalo l’evento Comunicando - da strumenti di calcolo a strumenti di comunicazione- che si terrà il prossimo 24 Settembre 2011.
L’evento è dedicato all'evoluzione delle piattaforme di sviluppo, e si terrà ad Avellino, presso il Carcere Borbonico di Avellino sito in Corso Vittorio Emanuele II, dalle 9.00 alle 17.30.

Purtroppo i posti sono limitati quindi affrettatevi a registrarvi.

Tag di Technorati: comunicando,evento

Webinar LightSwitch DevExpress

2011-09-14T12:44:00.001+02:00

Vi segnalo un interessante webinar (un americanismo per chiamare una sessione on-line) interamente dedicato a LightSwitch e tenuto da Alessandro Del Sole.

Il webinar è a cura di DevExpress e si terrà il giorno 4 Ottobre 2011 alle ore 19:00 (il link del webinar è http://www.devexpress.com/Support/Webinars/details.xml?id=IntroLightSwitchDelSole.

Maggiori informazioni sul post di Alessandro.

Se volete cominciare a capire cosa è LightSwitch e se fa al caso vostro, non perdete l’occasione!!!

Tag di Technorati: devexpress,webinar,lightswitch

Windows 8 @ BUILD : arrivato!!!!

2011-09-14T08:37:00.001+02:00

Ieri, durante la keynote di BUILD tenutasi ad Anaheim in California, Steven Sinofsky mostrato alcune delle potenzialità del nuovo Windows 8.

Per vedere la Keynote potete collegarvi all'indirizzo: http://www.microsoft.com/presspass/events/build/

Da questa mattina presto è stata rilasciata la preview di Windows 8 e degli strumenti di sviluppo. Per scaricare le ISO usate l'indirizzo http://msdn.microsoft.com/en-us/windows/home/

Le sessioni dell'evento BUILD sono disponibili all'indirizzo: http://channel9.msdn.com/Events/BUILD/BUILD2011?sort=sequential&direction=desc&term=

A questo punto non ci resta che “giocare”!!!!

Tag di Technorati: windows 8,windows 8 developer preview,build,build keynote,win8

DomusDotNet : Pomeriggio Entity Framework

2011-09-09T09:36:00.001+02:00

DomusDotNet, in collaborazione con Microsoft, EF Profiler by Hibernating Rhinos, Edizioni FAG, O’Reilly, organizza l’evento Pomeriggio Entity Framework. Un pomeriggio dedicato all’ORM di casa Microsoft.

Se avete dubbi, perplessità, domande o semplicemente volete conoscere EF, potrebbe essere il caso di investire un pomeriggio e venire a seguirci!!!

Tag di Technorati: entity framework,evento,pomeriggio entity framework,code first,db first,model first,wp7,sql compact edition,domusdotnet

Alla scoperta del Kinect : utilizzo del Kinect in modalità polling

2011-09-07T08:00:00.000+02:00

Nei precedenti post abbiamo visto che il Kinect ci mette a disposizione una serie di eventi che ci permettono di recuperare i frame video, di profondità o gli skeleton data.

Possiamo utilizzare le potenzialità del Kinect anche senza fare ricorso alla gestione di tali eventi ma utilizzando una tecnica di polling sugli streams.

Partiamo dall’inizio: la classe Runtime (già vista in precedenza) ci mette a disposizione 3 proprietà utilissime in questo contesto e che contengono proprio gli stream di cui sopra.

VideoStream : è un’istanza di ImageStream che incapsula lo stream video;
DepthStream : è un’istanza di ImageStream che incapsula lo stream dei dati di profondità;
SkeletonEngine : è il motore di skeletal Tracking che permette l’accesso ai frem di skeleton data.

In particolare osserviamo la presenza, in tutte le classi in gioco, del metodo GetNextFrame il cui risultato è un oggetto di tipo ImageFrame per il VideoStream e per il DepthStream e SkeletonFrame per lo SkeletonEngine.

ImageFrame e SkeletonFrame sono esattamente le istanze che ci vengono restituite all’interno degli eventi della classe Runtime utilizzati in precedenza.

Per questo motivo possiamo utilizzare questo metodo per accedere allo stream e recuperare il frame che ci interessa.

L’applicazione allegata a questo post altro non fa che visualizzare lo stream video e depth utilizzando un polling.

In particolare vengono utilizzati due Task che si occupano di eseguire il “polling” accedendo ai differenti stream.

 Private Nui As Runtime
 
Private VideoWorkTask As Task
Private DepthWorkTask As Task
Private WorkTaskTokenSource As CancellationTokenSource
 
Private Sub MainWindow_Loaded(sender As Object, e As System.Windows.RoutedEventArgs) Handles Me.Loaded
    Try
        Nui = New Runtime
        Nui.Initialize(RuntimeOptions.UseColor Or RuntimeOptions.UseDepthAndPlayerIndex)
        Nui.VideoStream.Open(ImageStreamType.Video, 2, ImageResolution.Resolution640x480, ImageType.Color)
        Nui.DepthStream.Open(ImageStreamType.Depth, 2, ImageResolution.Resolution320x240, ImageType.DepthAndPlayerIndex)
 
        WorkTaskTokenSource = New CancellationTokenSource()
 
        Dim cancellationToken = WorkTaskTokenSource.Token
        VideoWorkTask = New Task(New Action(Of Object)(AddressOf VideoWorkTaskCode), Nui, cancellationToken)
        VideoWorkTask.Start()
 
        cancellationToken = WorkTaskTokenSource.Token
        DepthWorkTask = New Task(New Action(Of Object)(AddressOf DepthWorkTaskCode), Nui, cancellationToken)
        DepthWorkTask.Start()
    Catch ex As Exception
 
    End Try
End Sub
 

Viene inizializzata l’istanza di Runtime e gli stream Video e Depth, non vengono agganciati i gestori di evento ma vengono avviati due task che si occupano di recuperare i frame:

 Private Sub VideoWorkTaskCode(obj As Object)
    Dim nui = CType(obj, Runtime)
    While Not WorkTaskTokenSource.IsCancellationRequested
        If nui IsNot Nothing AndAlso nui.VideoStream IsNot Nothing Then
            Dim frame = nui.VideoStream.GetNextFrame(0)
            If frame IsNot Nothing Then
                Dispatcher.BeginInvoke(Sub()
                                           Me.VideoImage.Source = frame.ToBitmapSource()
                                       End Sub)
            End If
        End If
        System.Threading.Thread.Sleep(100)
    End While
End Sub
 

 Private Sub DepthWorkTaskCode(obj As Object)
    Dim nui = CType(obj, Runtime)
    While Not WorkTaskTokenSource.IsCancellationRequested
        If nui IsNot Nothing AndAlso nui.DepthStream IsNot Nothing Then
            Dim frame = nui.DepthStream.GetNextFrame(0)
            If frame IsNot Nothing Then
                Dispatcher.BeginInvoke(Sub()
                                           Me.DepthImage.Source = frame.ToBitmapSource()
                                       End Sub)
            End If
        End If
        System.Threading.Thread.Sleep(100)
    End While
End Sub
 

A differenza della gestione degli eventi vista nei precedenti post, in questo caso i task vengono eseguiti in threads differenti dal principale ed è, quindi, necessario l’utilizzo del Dispatcher per aggiornare l’interfaccia.

Il metodo GetNextFrame prevede un parametro che indica quanti millisecondi attendere prima di restituire il frame.

Il valore di ritorno di GetFrame può anche essere nothing (nel caso che il frame non sia ancora pronto).

Questa tecnica è un “pelino” più complicata di quella Event-Driven e deve essere utilizzata quando l’applicazione lo richiede (ad esempio abbiamo la necessità di recuperare un frame ogni x secondi).

Tag di Technorati: kinect,kinect sdk,polling,video stream,depth stream

Alla scoperta del Kinect: gli smooth parameters

2011-09-05T08:00:00.000+02:00

Abbiamo accennato in questo post come sia possibile eseguire un filtro sui dati grezzi provenienti dal Kinect per “smussare” e correggere le fluttuazioni.

In questo post vorrei cercare di capire (per primo io) quale è il significato dei vari parametri utilizzabili.

Riprendiamo il discorso dall’inizializzazione della classi Runtime e l’impostazione dei parametri di smoothing:

 Try
    _Nui = New Runtime
    _Nui.Initialize(RuntimeOptions.UseSkeletalTracking)
    AddHandler _Nui.SkeletonFrameReady, AddressOf SkeletonFrameReadyHandler
 
    _Nui.SkeletonEngine.TransformSmooth = True
    Dim parameters = New TransformSmoothParameters() With {.Smoothing = 1.0F,
                                                        .Correction = 0.1F,
                                                        .Prediction = 0.1F,
                                                        .JitterRadius = 0.05F,
                                                        .MaxDeviationRadius = 0.05F}
    _Nui.SkeletonEngine.SmoothParameters = parameters
Catch ex As Exception
 
End Try
 

La classe TransformSmoothParameters, come possiamo vedere, ha 5 proprietà che dovrebbero consentire il filtraggio delle imprecisioni e dei rumori che i sensori del Kinect introducono nei dati grezzi.

Smooting : lo smoothing (il termine italiano più vicino è “pulizia”), in elaborazione delle immagini, consiste nell’applicare una funzione di filtro il cui scopo è quello di mettere in evidenza la parte del segnale “buona” cercando di sopprimere l’eventuale rumore dovuto da cause di diversa natura che, comunque, sporcano il segnale stesso. Nel nostro caso, piccoli movimenti del corpo umano, possono determinare del rumore che rende la tracciatura dello stesso poco affidabile. La proprietà Smoothing (che accetta il range [0,1]) permette di impostare la quantità di smoothing da applicare. Il valore 0 indica che non viene applicato alcun smoothing mentre l’effetto smoothing aumenta all’avvicinarsi al valore 1. Aumentare il valore di questa proprietà aumenta la latenza del segnale.

Correction : la proprietà permette di impostare la correzione

Prediction : permette di impostare il numero di frame predetti dal motore.

Jitter Radius : il jitter è la variazione di una o più grandezze caratteristiche di un segnale che possono minare l’integrità del segnale stesso. La proprietà JitterRadius consente di impostare il raggio di riduzione del jitter (espresso in metri). Qualsiasi jitter che superi il raggio impostato viene normalizzato al raggio stesso.

Maximum Deviation Radius : permette di specificare il massimo scostamento (in metri) dei dati filtrati rispetto ai dati grezzi. I valori filtrati che superano la distanza impostata rispetto ai dati grezzi, vengono normalizzati a questa distanza (rispetto al valore filtrato).

Non esistono dei valori “buoni” per qualsiasi applicazione ma è necessario procedere sperimentando i migliori valori di smoothing. L’apporto di tali correzioni dipende dall’ambiente circostante e, quindi, anche a parità di applicazione possono variare in base a dove il Kinect è posizionato.

Per chi fosse interessato ad approfondire, è necessario sapere che il filtro attualmente utilizzato nell’SDK del Kinect si basa sul metodo a doppio esponenziale di Holt (link).

Tag di Technorati: kinect,kinect sdk,smooth parameters,correction,smoothing,skeletal engine,skeletal data,jitter

Alla scoperta del Kinect : gli scheletri e l’uomo vitruviano

2011-08-29T08:00:00.000+02:00

Cosa c’entra Leonardo e il suo Uomo Vitruviano, gli scheletri ed il Kinect?

Apparentemente nulla, ma leggendo questo post scoprirete che, invece, un legame c’è.

Abbiamo visto in precedenti post che l’infernale aggeggio (il Kinect) ci permette di ottenere, in maniera molto facile, le immagini video e le immagini di profondità. Già con questi due insiemi di informazioni potremmo realizzare una sorta di interazione tra i player ed il nostro applicativo.

L’SDK del Kinect, però, fa molto di più perché è in grado di fornirci gli “scheletri” dei player disposti davanti ad esso.

Vediamo come procedere per ricavare ciò.

La classe Runtime (di cui abbiamo parlato in questo post) prevede un evento chiamato SkeletonFrameReady che viene sollevato quando SDK ha a disposizione un oggetto di tipo SkeletonFrame pronto per essere elaborato.

L’istanza di questo oggetto è passata come proprietà dell’argomento dell’evento SkeletonFrameReady:

La classe SkeletonFrame, come possiamo vedere, espone una serie di proprietà decisamente interessanti:

FloorClipPlane : l’oggetto Vector contenuto in questa proprietà ci fornisce i coefficienti dell’equazione del piano di terra (pavimento) stimata dall’SDK. L’equazione ha la forma:

Ax+By+Cz+D=0

dove:

A = FloorClipPlane.X

B = FloorClipPlane.Y

C = FloorClipPlane.Z

D = FloorClipPlane.W

L’equazione del piano è normalizzata, quindi D rappresenta, di fatto, l’altezza della camera rispetto al pavimento. Nella versione Beta dell’SDK il vettore è sempre nullo;

NormalToGravity : consente di avere informazioni sul vettore di gravità. Nella versione Beta dell’SDK il vettore è sempre nullo.;
FrameNumber : è il numero del frame in esame;
TimeStamp : timestamp del frame (in maniera analoga a quanto visto per il video e la profondità);
Quality : indica la qualità del frame;
Skeletons : contiene un array di “scheletri” dei giocatori tracciati.

Il Kinect è in grado di tracciare fino a 6 giocatori contemporaneamente anche se:

solo 2 giocatori possono essere tracciati “attivamente”. Di questi si conoscono tantissime info all’interno della struttura SkeletonData;
fino a 4 giocatori possono essere tracciati “passivamente”. L’SDK mantiene solo alcune informazioni di questi giocatori.

La classe SkeletonData contiene, per ogni giocatore, i dati relativi alla posizione dello stesso nello spazio:

Lo scheletro è individuato da una collezione di punti del corpo umano, denominati Joint, e memorizzati nell’array Joints. Ogni Joint è individuato da un Id (di tipo JointID) e, allo stato attuale, possiamo contare su ben 20 punti mostrati nella seguente figura (ecco l’uomo vitruviano del titolo):

Ogni Joint fornisce la propria posizione nello spazio (proprietà Position) e lo stato di tracciamento (proprietà TrackingState). La posizione è identificata dalle tre coordinate spaziali secondo il seguente schema:

X e Y variano in un intervallo [-1,1] mentre Z esprime la distanza (in metri) dal sensore. Il valore di W, secondo quanto riportato dalla documentazione ufficiale dovrebbe variare tra 0 e 1 e identificare la precisione della posizione (1 posizione affidabile, 0 posizione totalmente inaffidabile) ma, allo stato attuale, il valore di W è sempre pari a 1.

La proprietà TrackingState della classe SkeletonData ci fornisce informazioni relative al tipo di tracciamento a cui è sottoposto lo scheletro e cioè se si tratta di un giocatore attivo (Tracked), passivo (PositionOnly) oppure se non è tracciato (NotTracked).

La proprietà Quality ci dice se lo scheletro è stato “tagliato”. Se, ad esempio, il Kinect riesce ad individuare lo scheletro dalle ginocchia in su (ad esempio perché caviglie e piedi sono nascosti), allora nella proprietà Quality avremo il valore ClippedBottom ad indicare che lo scheletro è stato “tagliato” in basso.

Interessante la proprietà Position di SkeletonData che contiene la posizione (approssimata) del centro di massa dello scheletro.

L’applicazione pratica che vi vorrei proporre a corollario di questo post è la realizzazione di una semplice applicazione che mostra, in tempo reale, la posizione dei venti punti dell’uomo vitruviano di cui sopra.

Cominciamo con il mostrare cosa vogliamo ottenere:

In pratica abbiamo, istantaneamente, la posizione di tutti i Joints disponibili del primo SkeletonData tracciato e, per ogni Joint, abbiamo un diverso colore di sfondo in base al loro stato di tracciamento.

In più visualizziamo il centro di massa (la TextBox in posizione “equivoca”),la qualità dello SkeletonFrame, il vettore NormalToGravity, il vettore FloorClipPlane (questi ultimi due sempre nulli).

L’applicazione è un’applicazione WPF in cui ho deciso di adottare il pattern MVVM, quindi, per spiegare il funzionamento, ci occuperemo, innanzitutto del ViewModel per poi usare il motore di binding di WPF per agganciare la UI.

Nel costruttore del View Model (MainWindowViewModel) avviamo l’istanza della classe Runtime dell’SDK del Kinect:

 Public Sub New()
    If Not DesignerProperties.GetIsInDesignMode(New DependencyObject()) Then
        Try
            Nui = New Runtime
            AddHandler Nui.DepthFrameReady, AddressOf DepthFrameReadyHandler
            AddHandler Nui.SkeletonFrameReady, AddressOf SkeletonFrameHandler
            Nui.Initialize(RuntimeOptions.UseDepthAndPlayerIndex Or RuntimeOptions.UseSkeletalTracking)
            Nui.DepthStream.Open(ImageStreamType.Depth, 2, ImageResolution.Resolution320x240, ImageType.DepthAndPlayerIndex)
            Catch ex As Exception
 
        End Try
    End If
End Sub
 

Se non ci troviamo in design mode (primo if) eseguiamo i seguenti passi:

creiamo l’istanza di Runtime;
agganciamo il gestore dell’evento DepthFrameReady che ci servirà esclusivamente per mostrare l’immagine di profondità a video;
agganciamo il gestore dell’evento SkeletonFrameReady che ci servirà per elaborare gli scheletri che il Kinect ci fornirà nel tempo;
inizializziamo la Runtime selezionando lo stream di profondità e di Skeletal tracking;
apriamo lo stream di profondità decidendo una risoluzione di 320x240 (per la profondità abbiamo solamente 320x240 e 80x60).

Tralasciamo il gestore di evento per le immagini di profondità (che abbiamo già visto nel precedente post) e ci dedichiamo a quello dello Skeletal Tracking:

 Private Sub SkeletonFrameHandler(sender As Object, e As SkeletonFrameReadyEventArgs)
    Me.NormalToGravity = e.SkeletonFrame.NormalToGravity
    Me.FloorClipPlane = e.SkeletonFrame.FloorClipPlane
    Me.Quality = e.SkeletonFrame.Quality.ToString()
    Dim skeleton = (From s In e.SkeletonFrame.Skeletons
                  Where s.TrackingState = SkeletonTrackingState.Tracked
                  Select s).FirstOrDefault()
 
    If skeleton IsNot Nothing Then
        Me.CenterPosition = skeleton.Position
        Me.Joints = skeleton.Joints.OfType(Of Joint)()
    Else
        Me.Joints = Nothing
        Me.CenterPosition = New Vector()
    End If
End Sub
 

Le prime tre istruzioni non fanno altro che recuperare, rispettivamente, NormalToGravity, FloorClipPlane e Quality e valorizzare le relative proprietà del View Model (che andranno in binding con opportuni controlli di visualizzazione).

Tramite la query LINQ seguente andiamo a selezionare, tra tutti gli scheletri forniti nell’argomento dell’evento, il primo che abbia stato di tracciamento pari a Tracked.
Se ne esiste almeno uno (abbiamo, quindi, una istanza valida di SkeletonData), andiamo a valorizzare le proprietà del View Model che ci consentono di visualizzare il valore del centro di massa (proprietà CenterPosition) e il valore di ogni singolo Joint dello scheletro (proprietà Joints).

A questo punto abbiamo due tipologie di proprietà nel nostro View Model: quelle di tipo Vector (NormalToGravity, FloorClipPlane e CenterPosition) e la collezione di Joint esposta dalla Joints.

Tutte queste proprietà verranno visualizzate tramite TextBox e utilizzeremo degli appositi Converter per formattare opportunamente le stesse.

Per le proprietà di tipo Vector creiamo il converter:

 Public Class VectorToStringConverter
    Implements IValueConverter
 
    Public Function Convert(value As Object,
                            targetType As System.Type,
                            parameter As Object,
                            culture As System.Globalization.CultureInfo) As Object Implements System.Windows.Data.IValueConverter.Convert
        If TypeOf value Is Vector Then
            Dim vector = CType(value, Vector)
            Dim strFormat = "{0:0.000} {1:0.000} {2:0.000} [{3:0.000}]"
            If parameter IsNot Nothing Then
                strFormat = parameter.ToString()
            End If
            Dim str = String.Format(strFormat, vector.X, vector.Y, vector.Z, vector.W)
            Return str
        Else
            Return Nothing
        End If
    End Function
 
    Public Function ConvertBack(value As Object,
                                targetType As System.Type,
                                parameter As Object,
                                culture As System.Globalization.CultureInfo) As Object Implements System.Windows.Data.IValueConverter.ConvertBack
        Throw New NotImplementedException
    End Function
End Class
 

In sostanza, prendiamo il valore da convertire e se è di tipo Vector e eseguiamo il metodo String.Format utilizzando la stringa di formato passata come parametro (o quella di default se il parametro non è impostato) e i valori di X, Y, Z e W del vettore.
Grazie all’utilizzo di questo converter possiamo visualizzare il centro di massa con il seguente XAML:

 <TextBox Text="{Binding Path=CenterPosition, Converter={StaticResource VectorToStringConverter}, ConverterParameter=\\cf1 {0:0.000\\cf1 } \\cf1 {1:0.000\\cf1 } \\cf1 {2:0.000\\cf1 } }"
         Canvas.Left="448" Canvas.Top="460" Style="{StaticResource PosizionTextBox}" 
         Background="LightSteelBlue"  Foreground="White"/>
 

Più interessante è sicuramente il converter che ci permetterà di visualizzare i dati di posizione del singolo Joint all’interno dei 20 TextBox che circondano l’uomo vitruviano.
In questo caso il converter accetta come parametri la stringa identificante l’id del Joint (as esempio “HandRight” per la mano destra) e la stringa di formattazione (questa è opzionale) separati dal carattere “|”.
Il codice del converter è il seguente:

 Public Class SkeletonJointPositionToStringConverter
    Implements IValueConverter
 
    Public Function Convert(value As Object,
                            targetType As System.Type,
                            parameter As Object,
                            culture As System.Globalization.CultureInfo) As Object Implements System.Windows.Data.IValueConverter.Convert
        If TypeOf value Is IEnumerable(Of Joint) Then
            Dim joints = CType(value, IEnumerable(Of Joint))
            Dim parameters = parameter.ToString.Split("|"c)
            If parameters.Count > 0 Then
                Dim jointId = parameters(0)
                Dim jointQuery = From j In joints
                                Where j.ID = CType([Enum].Parse(GetType(JointID), jointId), JointID)
                                Select j
                If jointQuery.Any() Then
                    Dim joint = jointQuery.First()
                    Dim strFormat = "{0:0.000} {1:0.000} {2:0.000}"
                    If parameters.Count > 1 Then
                        strFormat = parameters(1)
                    End If
                    Dim str = String.Format(strFormat, joint.Position.X, joint.Position.Y, joint.Position.Z)
                    Return str
                Else
                    Return Nothing
                End If
            Else
                Return Nothing
            End If
            Else
                Return Nothing
            End If
    End Function
 
    Public Function ConvertBack(value As Object,
                                targetType As System.Type,
                                parameter As Object,
                                culture As System.Globalization.CultureInfo) As Object Implements System.Windows.Data.IValueConverter.ConvertBack
        Throw New NotImplementedException
    End Function
End Class
 

In questo caso, se il valore che stiamo convertendo è di tipo IEnumerable(Of Joint) (come la proprietà Joints del ViewModel), andiamo a ricercare, tramite una query LINQ, il Joint che ha id passato come parametro (notare la chiamata al metodo Split di String per ricavare i due argomenti separati da “|”). Se la query LINQ restituisce un joint valido (se la stringa di ID passata per argomento è uno dei valori ammessi), allora creiamo la stringa da visualizzare utilizzando la posizione del joint stesso e la restituiamo al chiamante.

Grazie a questo converter possiamo utilizzare il binding per visualizzare tutti e 20 i punti dell’uomo vitruviano senza dover creare 20 differenti proprietà nel view model. Ad esempio la visualizzazione della posizione della testa (Head) è la seguente:

 <TextBox Canvas.Left="470" Canvas.Top="70" Style="{StaticResource PosizionTextBox}" 
         Text="{Binding Path=Joints, Converter={StaticResource SkeletonJointPositionToStringConverter1}, ConverterParameter=Head|\\cf1 {0:0.000\\cf1 } \\cf1 {1:0.000\\cf1 } \\cf1 {2:0.000\\cf1 }}" 
         Background="{Binding Path=Joints, Converter={StaticResource SkeletonJointTrackingStateToSolidColorBrushConverter}, ConverterParameter=Head|LightGreen|LightYellow|LightCoral}" />
 

Osservando lo XAML, possiamo notare l’utilizzo di un binding anche sul background del TextBox e, questo, per fare in modo che in base allo stato di tracciamento del joint, si abbia un differente colore di sfondo. Anche in questo caso ricorriamo ad un converter:

 Public Class SkeletonJointTrackingStateToSolidColorBrushConverter
    Implements IValueConverter
 
    Public Function Convert(value As Object,
                            targetType As System.Type,
                            parameter As Object,
                            culture As System.Globalization.CultureInfo) As Object Implements System.Windows.Data.IValueConverter.Convert
        If TypeOf value Is IEnumerable(Of Joint) Then
            Dim joints = CType(value, IEnumerable(Of Joint))
            Dim parameters = parameter.ToString.Split("|"c)
            If parameters.Count > 0 Then
                Dim jointId = parameters(0)
                Dim jointQuery = From j In joints
                                Where j.ID = CType([Enum].Parse(GetType(JointID), jointId), JointID)
                                Select j
 
                If jointQuery.Any() Then
                    Dim joint = jointQuery.First()
                    Dim color As Color?
                    Select Case joint.TrackingState
                        Case JointTrackingState.Tracked
                            color = If(parameters.Count() < 1, Colors.LightGreen, ColorUtility.GetColorFromName(parameters(1)))
                        Case JointTrackingState.Inferred
                            color = If(parameters.Count() < 2, Colors.LightYellow, ColorUtility.GetColorFromName(parameters(2)))
                        Case Else
                            color = If(parameters.Count() < 3, Colors.LightCoral, ColorUtility.GetColorFromName(parameters(3)))
                    End Select
                    If color.HasValue Then
                        Dim brush = New SolidColorBrush(color.Value)
                        Return brush
                    Else
                        Return Nothing
                    End If
                Else
                    Return Nothing
                End If
            Else
                Return Nothing
            End If
            Else
                Return Nothing
            End If
    End Function
 
    Public Function ConvertBack(value As Object,
                                targetType As System.Type,
                                parameter As Object,
                                culture As System.Globalization.CultureInfo) As Object Implements System.Windows.Data.IValueConverter.ConvertBack
        Throw New NotImplementedException
    End Function
End Class
 

Il converter è del tutto analogo al precedente con la differenza che utilizza i parametri per ricevere la stringa identificante l’id del joint da analizzare e la terna di colori da utilizzare per gli stati Tracked, Inferred e NotTracked.

Ultima cosa prima di chiudere il post riguarda la possibilità di affinare la precisione dello skeletal tracking.

Se provate ad utilizzare lo skeletal tracking, infatti, vi renderete conto che anche rimanendo immobili, i valori di posizione oscillano.

E’ possibile intervenire su questo fenomeno di jittering impostando alcune proprietà del motore di skeletal tracking. La classe SkeletonEngine esposta dalla classe Runtime tramite la proprietà omonima, consente di impostare i parametri di Smooth Transform.

Questi parametri permettono il controllo della precisione del rilevamento dello scheletro da parte del KInect e la loro disamina accurata sarà oggetto di un altro post.

Nel nostro caso potremmo modificare il costruttore nel seguente modo:

 Public Sub New()
    If Not DesignerProperties.GetIsInDesignMode(New DependencyObject()) Then
        Try
            Nui = New Runtime
            AddHandler Nui.DepthFrameReady, AddressOf DepthFrameReadyHandler
            AddHandler Nui.SkeletonFrameReady, AddressOf SkeletonFrameHandler
            Nui.Initialize(RuntimeOptions.UseDepthAndPlayerIndex Or RuntimeOptions.UseSkeletalTracking)
 
            Nui.SkeletonEngine.TransformSmooth = True
            Dim parameters = New TransformSmoothParameters With {.Smoothing = 0.75F,
                                                                .Correction = 0.0F,
                                                                .Prediction = 0.0F,
                                                                .JitterRadius = 0.05F,
                                                                .MaxDeviationRadius = 0.04F}
            Nui.SkeletonEngine.SmoothParameters = parameters
 
            Nui.DepthStream.Open(ImageStreamType.Depth, 2, ImageResolution.Resolution320x240, ImageType.DepthAndPlayerIndex)
        Catch ex As Exception
 
        End Try
    End If
End Sub
 

A seguito dell’initialize attiviamo la gestione dello smoothing (TransformSmooth=true), istanziamo un oggetto di classe TransformSmoothParameters e impostiamo la proprietà SmoothParameters dello SkeletonEngine.

La classe TransformSmoothParameters è poco documentata e per questo motivo cercheremo di approfondire il suo utilizzo in un ulteriore post.

Tag di Technorati: kinect sdk,kinect,uomo vitruviano,skeletal tracking,skeletondata,scheletro,runtime class,skeletal,nui

Alla scoperta del Kinect: video e depth insieme per eliminare lo sfondo

2011-08-22T08:00:00.000+02:00

Nel precedenti post (qui e qui) abbiamo visto singolarmente come utilizzare lo stream video e i dati di “distanza” che provengono dal nostro Kinect.

In questo post cercheremo di utilizzare contemporaneamente i due stream in modo da utilizzare le informazioni di distanza per modificare l’immagine video.

In particolare vedremo come (in maniera molto rozza e, sicuramente, ottimizzabile) riuscire a modificare l’immagine proveniente dallo stream video per lasciare visibili i player uniformando lo sfondo con un colore a nostra scelta.

Quello che faremo è prendere le singole immagini video e depth fornite dagli eventi del Runtime del Kinect, scandire l’immagine di depth e, ogni volta che si ha un player index pari a 0, colorare il corrispondente pixel dell’immagine video con il colore da noi scelto.

Uno dei problemi che si pongono immediatamente è che la risoluzione dell’immagine video sia diversa dalla risoluzione dell’immagine depth.

Ad esempio nel seguente pezzo di codice l’immagine video è 640x480 mentre l’immagine depth è 320x240.

 Try
    Nui = New Runtime
 
    AddHandler Nui.VideoFrameReady, AddressOf VideoFrameHandler
    AddHandler Nui.DepthFrameReady, AddressOf DepthFrameReadyHandler
 
    Nui.Initialize(RuntimeOptions.UseDepthAndPlayerIndex Or RuntimeOptions.UseColor)
 
    Nui.VideoStream.Open(ImageStreamType.Video, 2, ImageResolution.Resolution640x480, ImageType.Color)
    Nui.DepthStream.Open(ImageStreamType.Depth, 2, ImageResolution.Resolution320x240, ImageType.DepthAndPlayerIndex)
 
Catch ex As Exception
 
End Try
 

In alcuni casi non si può avere uguaglianza di risoluzione anche forzando i parametri del metodo Open degli stream.

Ad esempio nel mio pc non è ammesso avere 320x240 per entrambe le sorgenti (ottengo una eccezione in fase di open).

Nel caso mostrato nel codice precedente dobbiamo trovare qualche modo per correlare un pixel dell’immagine depth con uno o più pixel dell’immagine video.

L’SDK del Kinect ci mette a disposizione il metodo GetColorPixelCoordinatesFromDepthPixel della classe NuiCamera che consente di ottenere le coordinate x,y del punto video a partire dalle coordinate x,y del punto depth.

Nel nostro caso non utilizzeremo questa funzione perché andremo a calcolarci da soli i punti corrispondenti sull’immagine video.

In maniera molto grossolana (ci manterremo sul semplice essendo questo post didattico), ogni punto dell’immagine depth corrisponde a 4 punti dell’immagine video (visto che la risoluzione della video è 4 volte quella della depth).

Per questo dovremo ricavare le coordinate del punto in alto a sinistra di questo quadrato e prendere i 3 punti adiacenti.

Se indichiamo con x_d e y_d le coordinate di un punto dell’immagine depth, e con x_v e y_v le coordinate del punto in alto a sinistra dell’immagine video, potremmo considerare:

e, di conseguenza dovremmo elaborare i 4 punti:

L’algoritmo che utilizzeremo sarà quindi:

per ogni x, y dell’immagine depth (con x compreso tra 0 e 319 e y compreso tra 0 e 239)
recupereremo il player index come visto nel precedente post;
se il player index è zero, andremo ad impostare i bytes dell’immagine video corrispondenti ai 4 punti di cui sopra con i valori corrispondenti al colore di sfondo desiderato.

Il codice che implementa ciò è il seguente:

 Private Sub ElaborateImage(videoFrame As ImageFrame, depthFrame As ImageFrame)
    Dim depthIndex = 0
    Dim videoIndex = 0
    For x = 0 To depthFrame.Image.Width - 1
        For y = 0 To depthFrame.Image.Height - 1
            depthIndex = (y * depthFrame.Image.Width + x) * depthFrame.Image.BytesPerPixel
            Dim playerIndex = depthFrame.Image.Bits(depthIndex) And 7
            If playerIndex = 0 Then
                Dim x1 = 2 * x
                Dim x2 = 2 * x + 1
                Dim y1 = 2 * y
                Dim y2 = 2 * y + 1
 
                SetPixelValue(videoFrame, x1, y1, Colors.Red)
                SetPixelValue(videoFrame, x1, y2, Colors.Red)
                SetPixelValue(videoFrame, x2, y1, Colors.Red)
                SetPixelValue(videoFrame, x2, y2, Colors.Red)
            End If
        Next
    Next
 
    Me.ElaboratedImage.Source = videoFrame.ToBitmapSource()
End Sub
 

dove il metodo SetPixelValue altro non fa che impostare i 4 bytes del pixel video con le componenti del colore scelto:

 Private Sub SetPixelValue(imageFrame As ImageFrame, x As Integer, y As Integer, color As Color)
    Dim index = (y * imageFrame.Image.Width + x) * imageFrame.Image.BytesPerPixel
    imageFrame.Image.Bits(index) = color.B
    imageFrame.Image.Bits(index + 1) = color.G
    imageFrame.Image.Bits(index + 2) = color.R
    imageFrame.Image.Bits(index + 3) = color.A 
End Sub
 

Il risultato che otteniamo è un’immagine rossa che vedrà apparire le figure dei player nel momento in cui il KInect le “aggancia”.

Il bordo che si forma attorno alla figura è dovuto all’algoritmo di recupero dei punti video molto semplicistico e al fatto che le immagini che andiamo a prendere potrebbero non essere sincronizzate tra loro. Nel nostro semplice esempio non andiamo assolutamente a controllare il timestamp delle due immagini e, poichè i due stream potrebbero avere frame rate differente, le immagini potrebbero non coincidere e creare la fastidiosa scia.

Inoltre teniamo presente che i sensori video e di profondità che monta il Kinect sono posizionati in due differenti punti dell’”aggeggio” e, quindi, soffrono dell’errore di parallasse che fa si che le due immagini non possono mai essere sovrapponibili senza errore.

Tag di Technorati: kinect sdk,kinect,depth stream,video stream,vb.net,elaborazione immagini,runtime class

Alla scoperta del Kinect : questione di profondità

2011-08-08T08:00:00.000+02:00

Nei due precedenti post (link e link) abbiamo fatto conoscenza con “l’aggeggio” kinect e visto come sia possibile, in maniera molto semplice, gestire lo stream video proveniente dalla camera.

In questo post diamo un’occhiata alla capacità che ha il Kinect di fornire frame in cui l’immagine non è la rappresentazione fedele della realtà che ci circonda ma la rappresentazione bidimensionale della distanza degli oggetti dai sensori di profondità.

L’aggeggio, infatti, dispone di un sensore di profondità che è in grado di fornirci la distanza dei punti inquadrati da se stesso e, in più, è in grado di dirci a quale “player” fa riferimento ogni singolo pixel.

Ma andiamo con ordine.

Per abilitare la ricezione del depth stream è necessario:

Istanziare la classe Runtime;
Agganciare il gestore dell’evento DepthFrameReady;
Inizializzare l’istanza della Runtime scegliendo una delle opzioni che abilitano il sensore di profondità;
Aprire lo stream dei dati relativi alla profondità.

A livello di codice (abbiamo già visto nei precedenti post) significa:

 Nui = New Runtime
AddHandler Nui.DepthFrameReady, AddressOf DepthFrameHandler
Nui.Initialize(RuntimeOptions.UseDepthAndPlayerIndex)
Nui.DepthStream.Open(ImageStreamType.Depth, 2, ImageResolution.Resolution320x240, ImageType.DepthAndPlayerIndex)
 

dove Nui è una variabile di tipo Runtime.

Per quanto riguarda le RuntimeOptions, abbiamo la possibilità di scegliere di ricevere i soli dati di profondità (RuntimeOptions.UseDepth) o i dati di profondità e il numero del player (RuntimeOptions.UseDepthAndPlayerIndex).

La differenza tra le due opzioni si manifesta nella differenza della struttura dei dati che ci arrivano all’interno dell’evento DepthFrameReady.

In questo evento, come già visto nei precedenti post, riceviamo l’array dei bytes costuenti l’immagine recuperata dai sensori del Kinect.

L’array è contenuto nella proprietà Image (di tipo PlanarImage) dell’istanza di ImageFrame contenuta all’interno dell’argomento dell’evento DepthFrameReady:

Per le immagini fornite dal sensore di profondità, ogni pixel è descritto da 2 Bytes (totale 16 bits), la struttura dei quali cambia in base al fatto che stiamo chiedendo il player index o meno.

In entrambi i casi, l’array contiene la distanza (in mm) per ogni punto dell’immagine, e questa varia da un minimo di 800/850 mm ad un massimo di circa 4000 mm. Se “l’aggeggio” non riesce a recuperare la distanza (ad esempio per una fonte di luce forte alle spalle del soggetto inquadrato) la profondità restituita sarà 0.

La dimensione dell’array è, quindi, pari al prodotto delle dimensioni dell’immagine (ad esempio 320x240) per 2 ed è strutturato per righe a partire dall’angolo in alto a sinistra.

Se stiamo utilizzando RuntimeOptions.UseDepth, i due bytes contengono esattamente la distanza (espressa in mm) dal sensore) con il primo byte che contiene la parte meno significativa, mentre il secondo la più significativa:

In questo caso, dati i due bytes dell’array, la distanza è calcolabile nel seguente modo:

 depth = CLng(frame.Image.Bits(arrayIndex)) + (CLng(frame.Image.Bits(arrayIndex + 1)) << 8)
 

La conversione a CLng è opportuna in quanto l’operazione di shift (<<) farebbe perdere i bit più significativi.

Se stiamo utilizzando RuntimeOptions.UseDepthAndPlayerIndex, invece, i primi tre bit del byte meno significativo (il primo dei due) sono utilizzati per contenere l’indice del player a cui fa riferimento il dato di profondità (se non c’è un player o Kinect non ha agganciato un player abbiamo il valore 0):

In questo caso la distanza si calcola nel seguente modo:

 depth = (CLng(frame.Image.Bits(arrayIndex)) >> 3) + (CLng(frame.Image.Bits(arrayIndex + 1)) << 5)
 

Per fare un esempio concreto, supponiamo di voler calcolare la distanza e il player index del punto (160,120) dell’immagine.

In questo caso i due bytes interessati sono il 160*320+120=51320 e 51321:

Nell’esempio abbiamo come player index il valore 2 (010 binario) mentre la profondità è 2009 (0011111011001 in binario).

Nella solution che allego al post è presente un semplice programma che ci consente di selezionare, tramite il mouse, un punto sull’immagine (identificato da un pallino giallo) e di avere in tempo reale le informazioni di player index e profondità:

Tag di Technorati: kinect,kinect sdk,depth,player index,runtime,vb.net

Alla scoperta del Kinect: calcoliamo l’FPS degli stream video.

2011-08-04T08:00:00.000+02:00

Abbiamo visto nel precedente post della serie come poter utilizzare il nostro Kinect per catturare gli stream Video e Depth e visualizzarli.

Il questo post vogliamo vedere due possibili modi per calcolare l’effettivo FPS di tali stream, ovvero quanti frame nell’unità di tempo ci arrivano.

Questa funzione non esiste out-of-the-box tra le funzionalità esposte dall’SDK, ma è molto semplice calcolare tale numero basandoci sulle istanze della classe ImageFrame che ci arrivano nei gestori degli eventi DepthFrameReady e VideoFrameReady.

Per chi avesse perso il precedente post, la classe Runtime (fulcro dell’SDK di Kinect) solleva uno dei precedenti eventi ogni volta che è disponibile una immagine video o depth.

Possiamo gestire il flusso delle immagini tramite dei gestori di evento:

 Private Sub DepthFrameHandler(sender As Object, e As ImageFrameReadyEventArgs)
    .
    .
    .
End Sub
 
Private Sub VideoFrameHandler(sender As Object, e As ImageFrameReadyEventArgs)
    .
    .
    .
End Sub
 

L’argomento degli eventi ci fornisce un’istanza della classe ImageFrame che contiene informazioni molto importanti che ci possono permettere di calcolare il Frame rate del filmato.

La classe ImageFrameReadyEventArgs ha la seguente struttura:

Nel codice di seguito useremo l’attributo Timestamp della classe ImageFrame per il calcolo dell’Fps.

Cominciamo definendo l’interfaccia che deve implementare quello che noi definiremo “Calcolatore di FPS”:

 Imports Microsoft.Research.Kinect.Nui
Imports System.Diagnostics.Contracts
 
<ContractClass(GetType(ContractIFpsCalculator))>
Public Interface IFpsCalculator
 
    ReadOnly Property CurrentFps As Integer
 
    Sub SetCurrentImageFrame(image As ImageFrame)
 
End Interface
 
<ContractClassFor(GetType(IFpsCalculator))>
Public Class ContractIFpsCalculator
    Implements IFpsCalculator
 
 
    Public ReadOnly Property CurrentFps() As Integer Implements IFpsCalculator.CurrentFps
        Get
            Throw New NotImplementedException()
        End Get
    End Property
 
    Public Sub SetCurrentImageFrame(ByVal image As ImageFrame) Implements IFpsCalculator.SetCurrentImageFrame
        Contract.Requires(Of ArgumentNullException)(image IsNot Nothing, "Image must be not null")
        Throw New NotImplementedException()
    End Sub
End Class
 

L’interfaccia IFpsCalculator espone una proprietà CurrentFps che restituisce, istante per istante, l’FPS dello streaming e un metodo SetCurrentImageFrame che utilizziamo per comunicare al calcolatore quale è l’ImageFrame che stiamo elaborando.

Su questa interfaccia ho definito dei contratti in modo da garantirmi che il metodo SetCurrentImageFrame non possa essere mai chiamato (pena la sollevazione di un eccezione ArgumentNullException) con un parametro Nothing.

La prima implementazione di FpsCalculator si basa sul calcolo “istantaneo” del frame rate: di fatto, dato l’intervallo di tempo (in millisecondi) tra le ultime due immagini, viene calcolato il frame rate con la seguente formula:

dove:

FPS_n è il framerate (calcolato) tra l’n-esimo e l’(n-1)-esimo frame;
ts_n è il timestamp (in millisecondi) dell’n-esimo frame;
ts_n-1 è il timestamp dell’(n-1)-esimo frame.

Evidentemente il framerate calcolato è un numero decimale che, per convenienza, approssimeremo ad un intero.

La classe che implementa questo algoritmo è la seguente:

 Public Class FpsCalculator
    Implements IFpsCalculator
 
    Private _LastTimestampVideo As Long? = Nothing
    Private _SecondLastTimestampVideo As Long? = Nothing
 
    Public ReadOnly Property Fps As Integer Implements IFpsCalculator.CurrentFps
        Get
            Return CalculateFps()
        End Get
    End Property
 
    Private Function CalculateFps() As Integer
        Dim fps As Integer = 0
        If _LastTimestampVideo.HasValue And _SecondLastTimestampVideo.HasValue Then
            Dim deltaMillisec = _LastTimestampVideo.Value - _SecondLastTimestampVideo.Value
            fps = CInt(Math.Floor(1000.0 / CDbl(deltaMillisec)))
        End If
        Return fps
    End Function
 
    Public Sub SetCurrentImageFrame(ByVal image As ImageFrame) Implements IFpsCalculator.SetCurrentImageFrame
        Me._SecondLastTimestampVideo = Me._LastTimestampVideo
        Me._LastTimestampVideo = image.Timestamp
    End Sub
End Class
 

Per il calcolo effettivo tramite la precedente formula, memorizziamo gli ultimi due timestamp e, solo quando li abbiamo tutti e due, procediamo al calcolo (CalculateFps()).

Un altro modo per poter calcolare il framerate è quello di conteggiare quanti frame vengono elaborati nell’unità di tempo.

Per fare questo è sufficiente memorizzare il timestamp iniziale e, ad ogni frame elabrorato (metodo Set CurrentImageFrame()) verificare che il timestamp di tale frame non si discosti per più di un secondo da quello di partenza. Se lo scostamento è minore di un secondo viene incrementato il contatore di frame nell’unità di tempo mentre se lo scostamento è maggiore di un secondo (1000 millisecondi) viene valorizzata la proprietà CurrentFps con il valore del contatore.

La classe che implementa questo algoritmo è la seguente:

 Imports Microsoft.Research.Kinect.Nui
 
Public Class FpsCalculator2
    Implements IFpsCalculator
 
    Private _StartTimeStamp As Long? = Nothing
    Private _FrameCount As Integer = 0
 
    Private _CurrentFps As Integer = 0
    Public ReadOnly Property CurrentFps As Integer Implements IFpsCalculator.CurrentFps
        Get
            Return _CurrentFps
        End Get
    End Property
 
    Public Sub SetCurrentImageFrame(ByVal image As ImageFrame) Implements IFpsCalculator.SetCurrentImageFrame
        If _StartTimeStamp.HasValue Then
            If image.Timestamp - _StartTimeStamp.Value > 1000 Then
                _CurrentFps = _FrameCount
                _StartTimeStamp = image.Timestamp
                _FrameCount = 0
            Else
                _FrameCount += 1
            End If
        Else
            _StartTimeStamp = image.Timestamp
        End If
    End Sub
End Class
 

Il primo algoritmo aggiorna l’FPS ad ogni frame e genera, quindi una variazione costante dello stesso. Il secondo, invece, fornisce un valore nuovo di FPS ogni secondo dando luogo ad una rilevazione più stabile.

La classe ImageFrame mette a disposizione, come possiamo vedere dalla precedente immagine, la proprietà FrameNumber che contiene il numero di frame corrispondente all’immagine. Nella refresh dell’SDk appena uscita (scaricabile da qui) questo numero rappresenta realmente il numero del frame dello stream. Per questo, in teoria, possiamo utilizzare questo numero per calcolare l’FPS. In questo caso memorizziamo il numero del frame da cui partiamo, ragioniamo sui timestamp in maniera analoga a quanto fatto nell’FtpCalculator2 e facciamo la differenza tra il numero di frame:

 Imports Microsoft.Research.Kinect.Nui
 
Public Class FpsCalculator3
    Implements IFpsCalculator
 
    Private _StartTimeStamp As Long? = Nothing
    Private _FrameNumberStart As Integer = 0
 
    Private _CurrentFps As Integer = 0
    Public ReadOnly Property CurrentFps As Integer Implements IFpsCalculator.CurrentFps
        Get
            Return _CurrentFps
        End Get
    End Property
 
 
    Public Sub SetCurrentImageFrame(ByVal image As ImageFrame) Implements IFpsCalculator.SetCurrentImageFrame
        If _StartTimeStamp.HasValue Then
            If image.Timestamp - _StartTimeStamp.Value > 1000 Then
                _CurrentFps = image.FrameNumber - _FrameNumberStart
                _StartTimeStamp = image.Timestamp
                _FrameNumberStart = image.FrameNumber
            End If
        Else
            _StartTimeStamp = image.Timestamp
            _FrameNumberStart = image.FrameNumber
        End If
    End Sub
End Class
 

Tag di Technorati: fps,kinect sdk,kinect,vb.net,video stream,depth stream,imageframe

Alla scoperta del Kinect: la classe Runtime

2011-08-01T08:00:00.000+02:00

La classe Runtime (del namespace Microsoft.Research.KInect.Nui e contenuta nell’assemlby Microsoft.Research.Kinect) è per la nostra avventura come lo specchio per Alice: la porta peser entrare in un altro mondo……quello del Kinect!!!

A parte gli scherzi, la classe Runtime è fondamentale perché espone tutte le funzionalità che possiamo utilizzare del Kinect per quel che riguarda la parte delle gesture.

Di fatto un’istanza della classe Runtime gestisce un device connesso e la sua struttura è mostrata nella seguente immagine:

Per poter accedere alle funzionalità del sensore video, di profondità e allo skeleton engine (il “robo” che fa si che il Kinect individui la struttura di un corpo umano che si agita come un forsennato davanti a lui) è sufficiente creare un’istanza della classe Runtime.

Ma procediamo con ordine, innanzitutto per avere visibilità sulla classe Runtime è necessario referenziare la libreria Microsoft.Research.Kinect e lo facciamo, come accade usualmente, utilizzando l’opzione di Visual Studio (menù Add Reference che si ottiene con il tasto destro):

A questo punto possiamo istanziare la classe:

 Dim nui = New Runtime
 

Istanziare la classe Runtime non è sufficiente per poter accedere ai sensori, è necessario inizializzare la classe con il metodo Initialize():

 Dim nui = New Runtime
nui.Initialize(RuntimeOptions.UseColor or  RuntimeOptions.UseDepth)
 

In questo caso ho richiesto alla Runtime l’utilizzo dello stream video e di quello della profondità.

Prima di procedere analizziamo a fondo cosa ci mette a disposizione la Runtime a livello di proprietà, metodi ed eventi.

Le proprietà della Runtime

InstanceIndex : è un intero che identifica il numero di istanza della Runtime. Ogni device connesso al pc ha la sua Runtime e questo numero ci permette di identificare il singolo device;
NuiCamera : è la proprietà che ci consente di accedere all’oggetto Camera per poter, ad esempio, modificare l’inclinazione;
VideoStream : espone un’istanza di ImageStream che descive lo stream della video camera del Kinect. Vedremo in dettaglio in un altro post la classe ImageStream, per ora ci basti immaginarlo come uno stream che fornisce i fotogrammi rilevati dalla videocamera;
DepthStream : anche in questa proprietà espone un’istanza di ImageStream ma questa volta riguarda le immagini di profondità, ovvero le immagini in cui il Kinect traduce la distanza degli oggetti da se stesso;
SkeletonEngine : è la proprietà che espone il motore che gestisce il riconoscimento della figura umana (ce ne occuperemo in un altro post).

I metodi della Runtime

Initialize : abbiamo già visto questo metodo ed ha lo scopo di “avviare” l’aggetto richiedendo le funzionalità di cui abbiamo bisogno. Il parametro che accetta come argomento è del tipo RuntimeOptions, un’enumerazione flag con i seguenti valori:

Uninitialize : esegue lo shutdown dell’istanza di runtime. Una volta eseguito lo shutdown della Runtime, pur se l’oggetto managed non è Nothing, non è più possibile tentare di inizializzarlo in quanto viene rilasciata definitivamente tutta la parte unmanaged che c’è dietro. Se si prova si ottiene un’eccezione.

Gli eventi della Runtime

Gli eventi della classe Runtime sono i membri della classe che, di fatto, ci permettono un primo uso, anche se banale della stessa:

VideoFrameReady : viene sollevato quando un’immagine dello stream video è pronta per essere utilizzata;
DepthFrameReady : viene sollevato quando un’immagine dello stream di profondità è pronta per essere utilizzata;
SkeletonFrameReady : viene sollevato quando un’immagine del riconoscimento della figura umana è stata elaborata dallo skeleton engine ed è pronta per essere utilizzata.

I primi due eventi hanno per argomento la classe ImageFrameReadyEventArgs, mentre il terzo ha come argomento la classe SkeletonFrameReadyEventArgs.

Vedremo in dettaglio la struttura della SkeletonFrameReadyEventArgs in un prossimo post, mentre la ImageFrameReadyEventArgs ha la seguente struttura:

Di fatto l’argomento dell’evento ci fornisce l’immagine dello stream corrispondente che possiamo elaborare a nostro piacimento.

Quindi, istanziamo la Runtime, la inizializziamo, gestiamo gli eventi di cui sopra e siamo in grado, almeno per ora di riportare a video ciò che il Kinect sta inquadrando. In realtà, tra l’inizializzazione della Runtime e la fruizione delle immagini manca uno step fondamentale ovvero l’apertura degli stream VideoStream e DepthStream che se non aperti non comincerebbero a produrre immagini.

Il metodo Open ha la seguente sintassi:

dove:

streamType : ci consente di definire la tipologia di stream che vogliamo ricevere;
poolSize : è il numero di frame che il runtime di NUI deve memorizzare. Il valore massimo è 4, nella maggior parte delle applicazioni è sufficiente 2;
resolution : dichiara la risoluzione che si vuole per lo stream. Sono disponibili svariate risoluzioni ma se si hanno più stream aperti (ad esempio video e depth) non tutte le combinazioni funzionano;
image : definisce la tipologia dell’immagine. Ad esempio DepthAndPlayerIndex cioè un’immagine che contiene al suo interno i dati di distanza e del numero del giocatore.

Andremo in dettaglio dello stream di distanza in un altro post prossimamente.

Nell’esempio allegato a questo post trovate una banale applicazione WPF, sviluppata con il pattern MVVM, che visualizza i due stream illustrati in precedenza.

La creazione del ViewModel relativo alla finestra principale è la seguente:

 Public Sub New()
    If Not DesignerProperties.GetIsInDesignMode(New DependencyObject()) Then
        Nui = New Runtime
 
        AddHandler Nui.DepthFrameReady, AddressOf DepthFrameHandler
        AddHandler Nui.VideoFrameReady, AddressOf VideoFrameHandler
 
        Nui.Initialize(RuntimeOptions.UseColor Or RuntimeOptions.UseDepthAndPlayerIndex)
 
        Nui.DepthStream.Open(ImageStreamType.Depth, 2, ImageResolution.Resolution640x480, ImageType.DepthAndPlayerIndex)
        Nui.VideoStream.Open(ImageStreamType.Video, 2, ImageResolution.Resolution640x480, ImageType.Color)
    End If
End Sub
 

dove Nui è un attributo privato del ViewModel di tipo Runtime.

Per la gestione delle immagini provenienti dai due stream mi sono affidato ad un toolkit sviluppato da Coding4Fun che fornisce degli extension methods per la conversione tra immagini Kinect e immagini WPF. Il toolkit si chiama “Kinect toolkit for WPF” (ne esiste una versione anche per Windows Form) e si può referenziare nel nostro progetto tramite NuGet:

In questo caso il ViewModel espone le ultime due immagini dei due stream che possono essere messe in binding con un normale controllo Image dell’interfaccia:

 Imports System.ComponentModel
Imports Microsoft.Research.Kinect.Nui
Imports Coding4Fun.Kinect.Wpf
 
Public Class MainWindowViewModel
    Implements INotifyPropertyChanged
 
    Private Nui As Runtime
 
    Public Sub New()
        If Not DesignerProperties.GetIsInDesignMode(New DependencyObject()) Then
            Nui = New Runtime
 
            AddHandler Nui.DepthFrameReady, AddressOf DepthFrameHandler
            AddHandler Nui.VideoFrameReady, AddressOf VideoFrameHandler
 
            Nui.Initialize(RuntimeOptions.UseColor Or RuntimeOptions.UseDepth)
 
            Nui.VideoStream.Open(ImageStreamType.Video, 2, ImageResolution.Resolution640x480, ImageType.Color)
            Nui.DepthStream.Open(ImageStreamType.Depth, 2, ImageResolution.Resolution320x240, ImageType.Depth)
 
        End If
    End Sub
 
    Public Event PropertyChanged As PropertyChangedEventHandler Implements INotifyPropertyChanged.PropertyChanged
 
    Protected Sub OnNotifyPropertyChanged(propertyName As String)
        RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(propertyName))
    End Sub
 
    Private _VideoImage As ImageSource
    Public Property VideoImage As ImageSource
        Get
            Return _VideoImage
        End Get
        Protected Set(value As ImageSource)
            Me._VideoImage = value
            OnNotifyPropertyChanged("VideoImage")
        End Set
    End Property
 
    Private _DepthImage As ImageSource
    Public Property DepthImage As ImageSource
        Get
            Return _DepthImage
        End Get
        Protected Set(value As ImageSource)
            Me._DepthImage = value
            OnNotifyPropertyChanged("DepthImage")
        End Set
    End Property
 
    Private Sub DepthFrameHandler(sender As Object, e As ImageFrameReadyEventArgs)
        Me.DepthImage = e.ImageFrame.ToBitmapSource()
    End Sub
 
    Private Sub VideoFrameHandler(sender As Object, e As ImageFrameReadyEventArgs)
        Me.VideoImage = e.ImageFrame.ToBitmapSource()
    End Sub
 
 
 
    Protected Overrides Sub Finalize()
        MyBase.Finalize()
        Nui.Uninitialize()
    End Sub
End Class
 

Tag di Technorati: kinect sdk,runtime class,video stream,depth stream,kinect,vb.net

Agosto in città?………Parti per tecnolandia!!!

2011-07-30T14:40:00.001+02:00

Ad Agosto resti in città? Niente ferie estive o poca voglia di andare nella calca “ferragostiana”?

Allora approfitta per studiare, aggiornarti ed imparare cose nuove grazie ad MSDN:

Tag di Technorati: tecnolandia,msdn,risorse,cloud,web,mobile,windows phone,windows

Alla scoperta del Kinect: presentazioni e convenevoli

2011-07-29T21:22:00.001+02:00

Oggi è arrivato un Kinect nuovo nuovo su cui cominciare a fare sperimentazione ed ho, quindi, deciso di condividere tutto ciò che scopro, le cavolate che faccio e i segreti che scopro con chi mi segue.

I post che cercherò di scrivere con frequenza sono post di un neofita che si avvicina all’”Aggeggio” e che quindi sono diretti a chi nulla dell’argomento.

Gli esperti troveranno noiosi e banali questi post, ma non si può aver tutto dalla vita.

Per cominciare, scartato l’”Aggeggio” ho cominciato a preparare l’ambiente di sviluppo:

1) Visual Studio 2010 Ultimate (che uso normalmente ma che non è necessario in quanto si può sviluppare tranquillamente con la express edition);

2) Kinect SDK, scaricabile all’indirizzo http://research.microsoft.com/en-us/um/redmond/projects/kinectsdk/download.aspx

3) DirectX Software Development Kit scaricabile all’indirizzo http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=6812

A questo punto vi basta connettere il Kinect alla presa di corrente e al vostro PC tramite cavo USB e potete cominciare a giocare.

Vi consiglio di dare un’occhiata ai seguenti webcast di channel9:

Una volta installati gli SDK e i driver (questi potrebbero metterci qualche tempo) verificate che il dispositivo sia correttamente installato semplicemente controllando se è presente il nodo Kinect nella gestione del computer:

e che i microfoni siano visti all’interno delle periferiche audio che compaiono dall’opzione Sound del pannello di controllo:

A questo punto dovrebbe essere tutto pronto ma………potrebbe succedervi quello che è successo a me: ho provato a creare, da codice, una istanza della classe Runtime (di cui parleremo in seguito) e ad inizializzarla:

 nui = New Runtime()
 
nui.Initialize(RuntimeOptions.UseDepth Or RuntimeOptions.UseColor)

ed ho ottenuto:

Kinect installato, connesso ed alimentato, SDK pronti e codice banale, ma allora cosa accade?

Non ho mai installato altri framework per gestire il Kinect, quindi non può essere quello.

Ho chiuso tutte le applicazioni inutili, ma nulla.

Gira che ti rigira, alla fine ho la fortuna di staccare la docking station dell’ufficio a cui è attaccato il mio notebook per usufruire della tastiera e del mouse wireless e del monitor esterno e a cui c’è attaccato anche un hub USB alimentato.

Beh, la fortuna ha voluto che fosse quello, il Kinect ha cominciato a funzionare. Quindi fate attenzione che le vostre USB non siano “collegate” in qualche modo tra loro (evidentemente le mie lo sono).

Staccate tutto quello che avete sull’USB tranne il Kinect e procedete riattacando solo quello che vi serve.

Rimanete connessi perché i post continueranno.

Tag di Technorati: kinect,xbox,kinect sdk,visual studio 2010

Un grazie a DotNetCampania per la bellissima giornata di sabato!!

2011-07-18T10:43:00.001+02:00

Mi sembra d’obbligo utilizzare questo post per ringraziare Michele e i soci di DotNetCampania per avermi invitato, sabato scorso, al loro Community Day su MVC 3 e Orchard.

Una bellissima giornata in compagnia di ragazzi preparati, curiosi e con tanta voglia di fare community.

In una giornata così informale si riesce a prendere in esame quegli aspetti pratici (i famosi “casi pelosi”) che sarebbe difficile prendere in esame in un evento “ufficiale”.

Ne nasce una giornata che, magari non segue esattamente l’agenda prevista, ma poco importa perché il dialogo che ne viene fuori è sempre costruttivo e stimolante.

Complimenti a Michele e a tutti i ragazzi della community campana perché stanno svolgendo un ottimo lavoro e suggerisco a tutti coloro che vivono a Napoli e dintorni di seguire la community campana e di diventare soci perché ne vale la pena!!!

Un particolare ringraziamento a Gaetano: incarna esattamente il personaggio community come lo intendo io. Mettere a disposizione la propria sede per degli eventi community è da ILLUMINATO come se ne conoscono pochi in Italia e, poi,………sviluppa in VB.NET (che non è da poco)!!!!

Grazie ancora e spero di poter essere presente anche ad altri Community Day!!!

Tag di Technorati: dotnetcampania,community day

Evento on-line su Windows Phone 7 “Mango”

2011-07-15T09:13:00.001+02:00

Come certamente sapete, da qualche settimana è disponibile, per gli sviluppatori Windows Phone 7, la beta del nuovo sistema operativo per il telefono Microsoft denominato “Mango”.

MSDN Italia ha preparato un evento on-line in streaming (registrato, ovviamente) che permette di avvicinarsi allo sviluppo su questa piattaforma.

L'evento (link) è composto da una keynote e da 6 sessioni tecniche:

Introduzione allo sviluppo per Windows Phone – Cristian Civera
Il design delle applicazioni Windows Phone – Roberto Cavallini
Le novità della piattaforma di sviluppo in Windows Phone "Mango" – Lorenzo Barbieri
Multitasking nelle applicazioni Windows Phone "Mango" – Matteo Pagani
Live Tile e notifiche in Windows Phone "Mango" – Michele Locuratolo
Phone + Cloud in pochi clic con Azure Toolkit per Windows Phone 7 – Roberto Freato

Tag di Technorati: windows phone 7,mango,windows phone mango,silverlight,XNA,evento

Caliburn.Micro, NuGet, Visual Basic.Net e Windows Phone 7

2011-07-03T21:20:00.001+02:00

No, non mi sono sbagliato e ho ripubblicato un precedente post, semplicemente si tratta della versione del precedente post per WP7.

Anche in questo caso, se tentiamo di utilizzare Caliburn.Micro tramite NuGet in un progetto VB.NET per WP7, otteniamo che le classi che il package NuGet genera sono per C#.

Ma procediamo con ordine, per cominciare accertiamoci di aver installato ed abilitato NuGet tra le estensioni di VS (basta vedere se con il tasto destro su un progetto appare il menù contestuale “Add Library Package Reference…”). Se non abbiamo NuGet, possiamo installarlo utilizzando l’Extension Manager del menù Tools.

Come secondo passo creiamo un nuovo progetto WP7 e, una volta che Visual Studio ha terminato la procedura di creazione, selezioniamo il nostro progetto e scegliamo il comando “Manage NuGet Packages…” che compare con la pressione del tasto destro del mouse.

Digitiamo “Caliburn” nella casella di ricerca della finestra di NuGet che appare subito dopo:

Premendo il tasto install, il package NuGet provvede a creare le opportune classi (che abbiamo detto essere in C#) che servono per il funzionamento di Caliburn.Micro su WP7. In particolare, come possiamo vedere nella figura in seguito, vengono create due classi: AppBoostraper.cs e MainPageViewModel.cs

Ovviamente, noi VB-isti non possiamo farci nulla delle classi generate quindi le cancelliamo e le sostituiamo con le seguenti:

AppBoostrapper.vb

 Imports Caliburn.Micro
 
Public Class AppBootstrapper
    Inherits PhoneBootstrapper
 
    Dim container As PhoneContainer
 
    Protected Overrides Sub Configure()
        container = New PhoneContainer(RootFrame)
 
        container.RegisterPhoneServices()
        container.PerRequest(Of MainPageViewModel)()
 
        AddCustomConventions()
    End Sub
 
    Protected Overrides Function GetInstance(service As System.Type, key As String) As Object
        Return container.GetInstance(service, key)
    End Function
 
    Protected Overrides Function GetAllInstances(service As System.Type) As System.Collections.Generic.IEnumerable(Of Object)
        Return container.GetAllInstances(service)
    End Function
 
    Protected Overrides Sub BuildUp(instance As Object)
        container.BuildUp(instance)
    End Sub
 
 
    Public Shared Sub AddCustomConventions()
        ConventionManager.AddElementConvention(Of Pivot)(Pivot.ItemsSourceProperty, "SelectedItem", "SelectionChanged").ApplyBinding = _
            New Func(Of System.Type, String, System.Reflection.PropertyInfo, System.Windows.FrameworkElement, Caliburn.Micro.ElementConvention, Boolean) _
            (Function(viewModelType, path, [property], element, convention)
                 If (ConventionManager.GetElementConvention(GetType(ItemsControl)).ApplyBinding(viewModelType, path, [property], element, convention)) Then
                     ConventionManager.ConfigureSelectedItem(element, Pivot.SelectedItemProperty, viewModelType, path)
                     ConventionManager.ApplyHeaderTemplate(element, Pivot.HeaderTemplateProperty, viewModelType)
                     Return True
                 End If
                 Return False
             End Function)
 
        ConventionManager.AddElementConvention(Of Panorama)(Panorama.ItemsSourceProperty, "SelectedItem", "SelectionChanged").ApplyBinding = _
                 New Func(Of System.Type, String, System.Reflection.PropertyInfo, System.Windows.FrameworkElement, Caliburn.Micro.ElementConvention, Boolean) _
                 (Function(viewModelType, path, [property], element, convention)
                      If (ConventionManager.GetElementConvention(GetType(ItemsControl)).ApplyBinding(viewModelType, path, [property], element, convention)) Then
                          ConventionManager.ConfigureSelectedItem(element, Panorama.SelectedItemProperty, viewModelType, path)
                          ConventionManager.ApplyHeaderTemplate(element, Panorama.HeaderTemplateProperty, viewModelType)
                          Return True
                      End If
 
                      Return False
                  End Function)
    End Sub
End Class
 

MainPageViewModel.vb

 Public Class MainPageViewModel
 
End Class

A questo punto possiamo seguire i passi descritti nel tutorial per poter configurare la nostra app all’utilizzo di Caliburn.Micro.

Il suggerimento che vi posso dare è quello di ristrutturare le cartelle dell’applicazione creando le cartelle Views e ViewModels in cui inserire le views e i viewmodels (inizialmente MainPage e MainPageViewModel) nel seguente modo:

Infine, visto che ci siamo, modifichiamo i namespace delle classi MainPage (namespace CaliburnMicroWP7.Views) e MainPageViewModel (namespace CaliburnMicroWP7.ViewModels).

In allegato al post trovate la soluzione completa con le classi e le modifiche.

Tag di Technorati: Caliburn.Micro,Caliburn,WP7,Windows Phone 7,Visual Basic .NET,VB.NET,NuGet,Bootstrapper,AppBootstrapper

Recensione : Windows® Phone 7 Developer Guide

2011-06-23T11:58:00.001+02:00

- Titolo: Windows® Phone 7 Developer Guide
- Autori: Sharp, John
- Editore: Microsoft Press
- Data di pubblicazione: 07/12/2010
- Pagine: 736
- ISBN13: 9780735645561
- ISBN10: 9780735645561
-Lingua: Inglese

L’arrivo di Windows Phone 7 ha dato nuova linfa allo sviluppo di applicazioni mobile nell’ambito del framework .NET e il supporto didattico (libri, materiale video, post su blog, etc., etc.) sono andati di pari passo.

Il rischio che si corre nella scrittura di un libro su questo argomento è quello di realizzare una “collezione” di materiale già esistente e recuperabile nel vasto mondo della rete.

Quello che colpisce, invece, di questo libro è che “ci mette del suo” cioè, oltre a trattare argomenti “classici” per lo sviluppo Windows Phone 7 che si trovano in tutti i testi o i post sulla rete, va a toccare argomenti poco considerati come l’utilizzo del MVVM nelle applicazioni WP7 (sia in termini generici che facendo riferimento a Prism), la gestione dei dati on the cloud o la gestione delle interazioni asincrone (utilizzando Reactive Extensions).

Il lato negativo del libro è, invece, che gli argomenti sono trattati in maniera superficiale e senza entrare in dettaglio. Questo può essere visto come un fatto negativo perchè ci costringe ad utilizzare altre fonti per esplodere l’argomento ma anche in termini positivi perchè fa si che il libro si mantenga snello e fluido.

Da segnalare un’intera appendice riguardante le “capability” dei device WP7 come touch and gesture, contatti e messaggi, etc., etc.; un’appendice su Prism (secondo me mirata a chi già conosce il framework MVVM di casa Microsoft) e una su Sync Framework ed il suo utilizzo con WP7 (poteva forse essere espansa per fornire maggiori info, ma sono presenti, almeno, i links alle risorse da consultare).

Per quanto riguarda gli argomenti trattati, mi ha colpito la presenza di un paragrafo in cui si parla del design delle applicazioni. E’, a mio modo di vedere, fondamentale capire come deve essere strutturata un’interfaccia WP7 in quanto il successo di un’applicazione per un display con poco spazio e con l’interfaccia in stile Metro dipende fortemente da come i controlli e l’accesso alle funzionalità sono presentate.

In definitiva un libro discretamente scritto ma che non riscotrerà i favori di chi cerca dettagli specifici su particolari argomenti. Se state cercando di approfondire degli argomenti specifici non è il vostro libro, mentre se state cercando un libro snello che vi dia gli spunti per, poi, approfondire con altre risorse ciò che avete letto, allora il testo è adattissimo allo scopo.

Tag di Technorati: wp7 tools,patterns & practices,recensione,books,libro,windows phone 7

Recensione : Windows Communication Foundation 4 – Step by Step

2011-06-23T09:31:00.001+02:00

Adoro leggere e adoro tenermi aggiornato riguardo al mondo .NET, quindi unendo le due cose ecco che vorrei inaugurare una rubrica di recensioni di libri anche in virtù del fatto che faccio parte dell’O'Reilly Blogger Review Program.

Il libro di questo post è “Windows Communication Foundation 4 – Step by Step” di John Sharp.

- Titolo: Windows Communication Foundation 4 Step By Step
- Autori: Sharp, John
- Editore: Microsoft Press
- Data di pubblicazione: 07/12/2010
- Pagine: 736
- ISBN13: 9780735645561
- ISBN10: 9780735645561
-Lingua: Inglese

Quando ci si avvicina ad una nuova tecnologia, ed in particolare quando questa tecnologia è complessa come lo è Windows Communication Foundation, è importante, a mio modesto avviso, costruire delle solide basi teoriche, degli strumenti di base, che consentano, in seguito, di poter addentrarsi nei dettagli e nei casi particolari senza dover pagare dazio.

Nel momento in cui si conosce la tecnologia (almeno le basi) è necessario, invece, avere a disposizione una reference guide in grado di fornire rapidamente le risposte cercate per poter essere immediatamente produttivi o per poter avere quell’input necessario a sbloccare un momento di difficoltà che ci blocca nel nostro lavoro quotidiano.

Il libro che vi propongo è un libro della collana Step by Step di Microsoft Press, scritto da John Sharp (autore di altri linbri della serie Step by Step soprattutto su C#) ed è un ottimo strumento per chi si avvicina a WCF ed ha la necessità di costruire quel bagaglio di strumenti di base di cui parlavo in precedenza.

Il libro non è una reference guide ma limitatamente ai concetti introduttivi di WCF 4.0 permette di avere rapidamente le informazioni cercate. Si tratta di un testo adatto a chi si trova per la prima volta alle prese con il framework WCF mentre lo è meno per chi conosce WCF e vuole approfondire l’argomento.

Gli argomenti trattati non entrano quasi mai nello specifico ma si limitano a fornire una infarinatura di base (decisamente ben fatta, ma comunque di base) ma questa è, generalmente, una caratteristica della serie Step By Step e questo volume non è diverso dagli altri.

La lettura scorre relativamente fluida (sempre considerando che si tratta di un libro pieno di vocaboli e termini tecnici), gli esempi sono sufficientemente spiegati ed il codice con gli esempi è scaricabile dal web.

Se vogliamo trovare un punto a sfavore del libro, possiamo dire che la maggior parte del discorso è incentrato sulla visione web services di WCF e vengono poco presi in esame gli altri possibili bindings messi a disposizione da WCF. Credo che, però, questa sia una scelta dell’autore visto il taglio beginner del testo e la vastità del mondo bindings in WCF (di fatto, il primo utilizzo che si fa di WCF da parte di chi si avvicina al framework è quello di sostituire i “vecchi” web service XML). In ogni caso se avete la necessità di studiare o approfondire la visione WCF non WebServices, allora questo libro non fa al caso vostro.

Per concludere, a mio modesto avviso, si tratta di un buon libro da cui non ci si deve però aspettare il ruolo di reference guide su WCF. Se abbiamo bisogno della “bibbia” di WCF, quseto non è il nostro libro, mentre se dobbiamo avvicinarci al mondo WCF, probabilmente si tratta della scelta giusta.

Tag di Technorati: o'reilly,windows communication foundation 4,wcf 4,step by step,libri,books

Caliburn.Micro, NuGet e Visual Basic.Net

2011-06-16T14:19:00.001+02:00

In questi giorni mi trovo, per lavoro e per la community, a smanettare con Caliburn.Micro (che tra le altre cose consiglio perché se ci riesco a lavorare io, significa che è veramente fatto bene).

Ho notato che, agganciando il framework con NuGet all’interno di un progetto Visual Basic.Net, compaiono le classi di bootstrap, la shell e l’interfaccia che definisce la shell ma con la spiacevole controindicazione che sono in C#.

Questo post ha lo scopo di spiegare come agganciare Caliburn con NuGet in un progetto VB.NET.

Agganciare il framework con NuGet è semplicissimo (come lo è sempre utilizzando NuGet). In questo caso stiamo parlando di un progetto WPF, ma la procedura è identica per Silverlight o WP7.

Per cominciare accertiamoci di aver installato ed abilitato NuGet tra le estensioni di VS (basta vedere se con il tasto destro su un progetto appare il menù contestuale “Add Library Package Reference…”).

Lanciamo il comando precedente sul progetto in cui vogliamo aggiungere Caliburn.Micro e selezioniamo il package dalla maschera:

Il tasto install ci consente di istallare e configurare Caliburn.Micro.

Al termine dell’installazione il progetto apparirà nel seguente modo:

Rimuoviamo i file .cs e inseriamo gli omonimi file .vb con le classi che riporto di seguito:

Appbootstrapper.vb

 Imports Caliburn.Micro
Imports System.ComponentModel.Composition.Hosting
Imports System.ComponentModel.Composition.Primitives
  ImportsSystem.ComponentModel.Composition
 
Public Class AppBootstrapper
    Inherits Bootstrapper(Of IShell)
 
    Private container As CompositionContainer
 
    ' <summary>
    ' By default, we are configured to use MEF
    ' </summary>
    Protected Overrides Sub Configure()
        Dim catalog = New AggregateCatalog(AssemblySource.Instance.Select(Function(x) New AssemblyCatalog(x)).OfType(Of ComposablePartCatalog)())
 
        container = New CompositionContainer(catalog)
 
        Dim batch = New CompositionBatch()
 
        batch.AddExportedValue(Of IWindowManager)(New WindowManager())
        batch.AddExportedValue(Of IEventAggregator)(New EventAggregator())
        batch.AddExportedValue(container)
        batch.AddExportedValue(catalog)
 
        container.Compose(batch)
    End Sub
 
 
    Protected Overrides Function GetInstance(service As System.Type, key As String) As Object
        Dim contract = If(String.IsNullOrEmpty(key), AttributedModelServices.GetContractName(service), key)
        Dim exports = container.GetExportedValues(Of Object)(contract)
 
        If exports.Count() > 0 Then Return exports.First()
 
        Throw New Exception(String.Format("Could not locate any instances of contract {0}.", contract))
    End Function
 
    Protected Overrides Function GetAllInstances(service As System.Type) As System.Collections.Generic.IEnumerable(Of Object)
        Return container.GetExportedValues(Of Object)(AttributedModelServices.GetContractName(service))
    End Function
 
    Protected Overrides Sub BuildUp(instance As Object)
        container.SatisfyImportsOnce(instance)
    End Sub
 
 
End Class
 

IShell.vb

 Public Interface IShell
 
End Interface

ShellViewModel.vb

 Imports System.ComponentModel.Composition
 
<Export(GetType(IShell))>
Public Class ShellViewModel
    Implements IShell
 
End Class
 

Le classi possono ovviamente essere personalizzate sia nel comportamento che nei namespace.

Con l’inserimento di queste classi, il progetto assume la forma:

Per la configurazione dello startup dell’applicazione fate riferimento alla documentazione di Caliburn.Micro (http://caliburnmicro.codeplex.com/wikipage?title=Nuget&referringTitle=Documentation) che spiega passo passo cosa fare.

Ricordatevi di fare attenzione ai namespace della ShellView e della ShellViewModel per fare in modo che Caliburn riesca ad associarle.

In particolare è necessario prestare attenzione alla ShellView. Il package NuGet, infatti, crea il seguente Xaml:

 <Window x:Class="NomeProgetto.ShellView"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
 
    <Grid Background="White">
        <TextBlock Text="Hello Caliburn Micro!"
                   VerticalAlignment="Center"
                   HorizontalAlignment="Center"
                   FontSize="20" />
    </Grid>
 
</Window>
 

Come possiamo osservare la classe ShellView si trova nel namespace “NomeProgetto.ShellView”, mentre la ShellViewModel (così come definita in precedenza) nel namespace root. In questo caso la convenzione che sta alla base del funzionamento di Caliburn non è in grado di associare View e ViewModel ed otterrete:

Per risolvere il problema è sufficiente togliere il namespace davanti al nome della classe nella view.

Tag di Technorati: Caliburn.Microsoft Solver Foundation,Caliburn,NuGet,VB.NET,Visual Basic,bootstrapper

Rilasciata una nuova versione dei Code Contracts

2011-06-07T09:24:00.001+02:00

Il 2 giugno è stata rilasciata la versione 1.4.40602.0 dei Code Contracts.

Potete scaricare i due pacchetti di installazione dal sito ufficiale (link).

Nel sito trovate anche l’extension per Visual Studio (accessibile anche attraverso Extension Manager) che permette di visualizzare nell’ambiente di sviluppo il tooltip con gli eventuali contratti definiti.

Le novità di questa versione sono relative ad ottimizzazioni e poco più in particolare riguerdanti lo Static Checker.

Tag di Technorati: code contracts,rise

DomusDotNet 1.0 Unleashed è fuori!!!

2011-06-01T16:17:00.001+02:00

In qualità di curatore e appartenente alla community DomusDotNet sono orgoglioso di comunicarvi che è stato pubblicato il libro:

Il testo nasce per festeggiare il primo anno di vita della community romana.

E’ un estratto di articoli e pillole pubblicate durante il primo anno di vita del portale.

Il libro è in vendita su Lulu.com.

Tag di Technorati: domusdotnet,domusdotnet 1.0 unleashed,pubblicazione,lulu.com

Certificare gratuitamente le proprie applicazioni che utilizzano SQL Server 2008 R2

2011-05-31T13:04:00.001+02:00

Vorrei segnalarvi questo post di Vito Lorusso riguardante la possibilità di certificare gratuitamente le proprie applicazioni che utilizzano SQL Server 2008 R2.

La certificazione è “self-service” ed gratuita, quindi mi sembra un’ottima opportunità da sfruttare.

Date una lettura al post e sarà tutto più chiaro!!!

Tag di Technorati: msdn,certificazione sql server 2008 r2

La classe Lazy(Of T)

2011-05-30T08:00:00.000+02:00

Una interessante classe inserita nella versione 4.0 del framework è la Lazy(Of T).

Si tratta di un generic il cui scopo è quello di permettere la creazione di oggetti differita.

Uno scenario tipico che può capitare quando sviluppiamo è quello di avere una nostra classe che occupa molte risorse (memoria, accesso a database, accesso a filesystem, e via discorrendo) e desiderare che tale classe venga istanziata solo quando serve.

In più, alcune volte, sarebbe anche comodo poter avere un accesso concorrente a tale istanza.

Se il primo requisito è facilmente implementabile con un manciata di righe di codice, il secondo non è altrettanto banale.

La classe Lazy(Of T) ci viene in aiuto perché è, di fatto, un wrapper che gestisce la creazione dell’istanza del tipo T e il thread safe in maniera nativa.

La classe Lazy prevede una serie di costruttori il più semplice dei quali non prevede argomenti. Sia MyClass la nostra classe di cui vogliamo gestire la creazione differita:

 Public Class [MyClass]
 
    Public Sub New()
        ConsoleHelper.WriteConsole("MyClass - New")
    End Sub
 
    Public Sub New(i As Integer)
        ConsoleHelper.WriteConsole(String.Format("MyClass - New with {0}", i))
    End Sub
 
    Public Sub MyMethod()
        ConsoleHelper.WriteConsole("MyClass - MyMethod")
    End Sub
End Class
 

La classe ConsoleHelper permette di utilizzare la Console per scrivere dei messaggi a cui viene anteposto un timestamp. Nei costruttori della classe MyClass ho inserito la scrittura dei messaggi per poter, effettivamente, capire quando il costruttore stesso viene invocato.

Prendiamo in esame il seguente pezzo di codice:

 Sub Main()
    ConsoleHelper.WriteConsole("CreateSimpleLazy - Before")
    Dim lazy = CreateSimpleLazy()
    ConsoleHelper.WriteConsole("CreateSimpleLazy - After")
    Threading.Thread.Sleep(1000)
    lazy.Value.MyMethod()
    Console.ReadLine()
End Sub
 

e il seguente:

 Public Function CreateSimpleLazy() As Lazy(Of [MyClass])
    Dim retVal = New Lazy(Of [MyClass])
 
    Return retVal
End Function
 

Il metodo CreateSimpleLazy altro non fa che istanziare un oggetto di classe Lazy(Of MyClass) e restituirlo al chiamante.

Nel metodo chiamante eseguiamo la chiamata al metodo MyMethod della MyClass in maniera differita (cioè solo dopo aver atteso 1 secondo dall’istanziazione dell’oggetto Lazy).

Il risultato a video è il seguente:

Come possiamo osservare il costruttore della classe MyClass (riga “MyClass – new”) viene richiamato solo nel momento in cui si esegue l’istruzione lazy.Value.MyMethod e non quando viene creato l’oggetto Lazy.

In effetti la classe Lazy espone l’istanza della classe che wrappa tramite la proprietà Value all’interno della quale viene gestito l’effettivo richiamo del costruttore. Se l’oggetto wrappato non è stato ancora istanziato, nel momento in cui viene utilizzata la proprietà Value, viene richiamato il costruttore di default della classe wrappata.

Ma se la nostra classe non prevede un costruttore di default?

In questo caso ci viene in aiuto un altro costruttore della Lazy la cui sintassi è la seguente:

 Public Sub New(
              valueFactory As Func(Of T)
              )
 

Questo costruttore prevede che si possa utilizzare una Func(Of T) come parametro (ad esempio una lambda expression), all’interno della quale creeremo l’istanza della nostra classe e la restituiremo alla Lazy che la gestirà in maniera del tutto analoga al caso precedente:

 Sub Main()
    ConsoleHelper.WriteConsole("CreateParametricLazy - Before")
    Dim parametricLazy = CreateParametricLazy(100)
    ConsoleHelper.WriteConsole("CreateParametricLazy - After")
    Threading.Thread.Sleep(1000)
    parametricLazy.Value.MyMethod()
 
    Console.ReadLine()
End Sub
 

In questo caso utilizziamo il costruttore della classe MyClass che prevede un parametro intero:

 Public Function CreateParametricLazy(i As Integer) As Lazy(Of [MyClass])
    Dim retVal = New Lazy(Of [MyClass])(Function()
                                            Return New [MyClass](i)
                                        End Function)
 
    Return retVal
End Function
 

Il risultato che otteniamo è:

La classe Lazy, per default, ThreadSafe cioè permette accesso contemporaneo (e sicuro) alla proprietà Value da thread differenti. La modalità di default è la LazyThreadSafetyMode .ExecutionAndPubblication che prevede che un solo thread possa eseguire l’inizializzazione di T ma che tale istanza sia poi disponibili a tutti i thread che la richiedono.
Questo significa che se più thread tentano di eseguire l’inizializzazione della classe T, uno solo di questi ha accesso al costruttori e gli altri attendono l’effettiva creazione della stessa.

Questo fatto comporta che se la nostra classe utilizza dei meccanismi di thread safe interni e questi non lavorano correttamente, si potrebbero creare dei dedlock da cui non si può uscire.

Possiamo stabilire il comportamento della classe Lazy rispetto all’accesso contemporaneo con opportuni costruttori della stessa che ci permettono di avere un’istanza non ThreadSafe oppure di stabilire esattamente il LazyThreadSafetyMode da utilizzare. I possibili valori di questa enumerazione sono:

None : non thread safe;
ExecutionAndPubblication: un unico thread può inizializzare T la cui istanza viene utilizzata da tutti i thread. E’ una modalità ThreadSafe;
PublicationOnly : più thread possono inizializzare T, il primo che riesce rende l’istanza disponibile e viene utilizzata dagli altri. Eventuali altre istanze vengono scartate. E’ una modalità ThreadSafe.

La tipologia di ThreadSafe scelta influenza anche il comportamento della classe Lazy rispetto alle eventuali eccezioni generate dal costruttore della classe contenuta.

Se stiamo utilizzando il costruttore di default, l’eventuale eccezione generata viene immediatamente sollevata (a prescindere da quale valore di LazyThreadSafetyMode abbiamo scelto) mentre se stiamo utilizzando un costruttore con parametri l’eventuale eccezione generata si comporta in maniera differente in base al valore di LazyThreadSafetyMode scelto.

Se si è scelto PublicationOnly (valore di default) le eccezioni vengono immediatamente generate nel costruttore della Lazy (come nel caso precedente), mentre se stiamo utilizzando uno delle altre sue modalità di LazyThreadSafetyMode, allora le eccezioni vengono salvate in cache e proposte nel momento in cui viene invocata la proprietà Value.

Infine, la classe Lazy(Of T) prevede la proprietà IsValueCreated che permette di conoscere se l’istanza di T è stata già creata o meno.

Tag di Technorati: Lazy,Lazy(Of T),Framework 4.0,.NET Framework 4.0,Lazy initialization,inizializzazione differita

Disponibili i nuovi tools di sviluppo per WP7

2011-05-24T16:42:00.001+02:00

Microsoft ha annunciato il rilascio nelle prossime ore dei tools (in beta) per lo sviluppo con le nuove funzionalità previste per l'aggiornamento denominato "Mango".

Maggiori informazioni relativamente alle funzionalità introdotte con questa versione sono disponibili all'indirizzo http://www.microsoft.com/presspass/presskits/windowsphone/.

I tools saranno scaricabili dall'hub degli sviluppatori all'indirizzo http://create.msdn.com/en-us/resources/downloads.

LA documentazione relativa alle nuove API è già disponibile all'indirizzo http://msdn.microsoft.com/en-us/library/hh237343%28v=VS.96%29.aspx

Tag di Technorati: WP7,Windows phone 7,Mango,wp7 tools

DDD NLayered .NET 4.0 Architecture Guide

2011-05-23T20:53:00.001+02:00

Vi segnalo un interessante ebook redatto dal Platform Architecture Team MSDN riguardante l’architettura DDD NLayered.

Potete scaricare il formato ebook e gli esempi all’indirizzo

http://msdn.microsoft.com/es-es/architecture/en/

Tag di Technorati: ddd nlayered,ddd,architecture

TFS2010 Object Model: Collegarsi ad un server TFS 2008 tramite l’object model di TFS 2010

2011-04-29T10:07:00.001+02:00

Questo post funge da compendio a tutti i post già pubblicati sull’object model di Team Foundation Server 2010 e agli articoli pubblicati su DomuDotNet (link, link, link, link, link e link) e ha lo scopo di mostrare come sia possibile utilizzare l’object model di TFS per accedere ad un server TFS 2008.

L’object model di Team Foundation Server 2010 è completamente compatibile con il server 2008 e, in particolare, l’unica differenza sostanziale è la modalità con cui si recupera le due istanze fondamentali per l’accesso al server: TfsConfigurationServer e TfsTeamProjectCollection.

Cominciamo con il prendere in esame il recupero dell’istanza di TfsConfigurationServer e per fare ciò vediamo come si presenta la finestra di inserimento di un nuovo server nelle due versioni del team explorer.

Nella versione 2010 abbiamo:

mentre nella versione 2008:

La differenza tra le due maschere è la presenza della proprietà Path (nella 2010) che fa si che, a parità di nome server, l’url sia leggermente diverso ed in particolare:

http://NomeMioServer:8080/tfs nella versione 2010;
http://NomeMioServer:8080 nella versione 2008.

Questa osservazione ci permette facilmente di recuperare un istanza di TfsConfigurationServer utilizzando, ad esempio, la factory TfsConfigurationServerFactory:

 Public Function GetTFSConfigurationServer(serverName As String) As TfsConfigurationServer
    Contract.Requires(Of ArgumentNullException)(serverName IsNot Nothing)
 
    Dim retval As TfsConfigurationServer = Nothing
    Try
        retval = TfsConfigurationServerFactory.GetConfigurationServer(GetServerUri(serverName),
                                                                      New UICredentialsProvider())
    Catch ex As Exception
        Throw
    End Try
    Return retval
End Function
 

Il metodo GetServerUri non fa altro che generare la classe Uri corrispondente al server TFS 2008 a partire dal nome del server (http://NomeServer:8080/):

 Public Function GetServerUri(serverName As String) As Uri
    Contract.Requires(Of ArgumentNullException)(serverName IsNot Nothing)
    Dim tfsUrl = String.Format("http://{0}:8080", serverName)
    Return New Uri(tfsUrl)
End Function
 

Per quanto riguarda le project collection, TFS 2008 non prevede queste entità. Come è possibile, allora, recuperare un’istanza di TfsTeamProjectCollection? Abbiamo, infatti, bisogno della TfsTeamProjectCollection per poter accedere a servizi come WorkItemStore (gestione dell’item tracking) o VersionControlServer (gestione del version control).

Nella realtà, proprio la non esistenza dlle collections fa si che l’intero server TFS sia visto come un unica collection il cui Url è, proprio, http://NomeServer:8080/.

Per questo motivo possiamo scrivere:

 Public Function GetTeamProjectCollection(serverName As String) As TfsTeamProjectCollection
    Contract.Requires(Of ArgumentNullException)(serverName IsNot Nothing)
 
    Dim retval As TfsTeamProjectCollection = Nothing
    Try
        retval = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(GetServerUri(serverName),
                                                        New UICredentialsProvider())
        retval.EnsureAuthenticated()
    Catch ex As Exception
        Throw
    End Try
    Return retval
End Function
 

Una volta recuperata la TfsProjectCollection possiamo accedere ai servizi di work item tracking, version control etc., etc. in maniera analoga a quanto facciamo usualmente con le collection di TFS 2010.

Tag di Technorati: tfs 2008,tfs 2010 object model,tfs 2008 object model

Rilasciato Microsoft Solver Foundation

2011-04-28T21:10:00.001+02:00

Vi segnalo che Microsoft DevLabs ha pubblicato, martedì scorso, Microsoft Solver Foundation un framework per costruire ed ottimizzare modelli matematici.

Vi segnalo anche il post di Somasegar in cui viene annunciato il lancio del framework e riportati un paio di esempi pratici.

Tag di Technorati: Microsoft Solver Foundation,DevLabs

Provate Azure per un mese gratuitamente!!!

2011-04-28T20:57:00.001+02:00

Vorrei riportarvi il post di Brian Harry che vi da la possibilità di provare Windows Azure per 30 giorni senza pagare assolutamente nulla.

Vi basta andare sul sito http://windowsazurepass.com/ ed inserire il codice promozionale CRMIKEA.

Quello che vi aspetta è il seguente:

Tag di Technorati: Windows Azure,promo code

Definire i contratti su interfacce generiche in VB.NET

2011-04-22T17:46:00.001+02:00

Uno dei grandi vantaggi dei code contracts di Microsoft (vedere gli articoli sul sito www.domusdotnet.org per maggiori info) è quello di poter definire i contratti anche sulle interfacce.

Ad esempio le precondizioni si definiscono attraverso uno dei metodi statici Requires della classe Contracts (System.Diagnostic.Contracts):

 Imports System.Diagnostics.Contracts
 
Module Module1
 
    Sub Main()
        Dim chr = GetLastChar("pippo")
        Dim chr2 = GetLastChar("")
    End Sub
 
    Public Function GetLastChar(str As String) As String
        Contract.Requires(Not String.IsNullOrEmpty(str))
        Return str.Substring(str.Length - 1)
    End Function
 
End Module
 

Il metodo GetLastChar richiede che l’argomento non sia né Nothing, né “” e, nel caso precedente, in fase di compilazione, si ottiene il seguente warning

mentre in fase di esecuzione si ottiene la seguente eccezione:

Fino a qui tutto bene, ma come facciamo a definire le precondizioni (ma il concetto vale anche per postcondizioni ed invarianti d’oggetto) nel caso di interfacce o di metodi astratti di classi in cui non abbiamo la possibilità di inserire del codice?

In questo caso abbiamo la possibilità di definire una classe che funge da “contenitore” per le definizioni dei contratti. Ad esempio:

 <ContractClass(GetType(InterfacciaContract))>
Public Interface IInterfaccia
    Function Metodo(arg As Integer) As Integer
End Interface
 
<ContractClassFor(GetType(IInterfaccia))>
Public MustInherit Class InterfacciaContract
    Implements IInterfaccia
 
    Public Function Metodo(arg As Integer) As Integer Implements IInterfaccia.Metodo
        Contract.Requires(arg > 0)
        Throw New NotSupportedException
    End Function
End Class
 

La classe InterfacciaContract funge da contenitore per i contratti dei metodi esposti dalla Interfaccia.

Il codice presente nei metodi dell’interfaccia implementati dalla classe contenitore non viene eseguito se non quello relativo alla definizione dei contratti.

Il problema nasce quando abbiamo una interfaccia generica (ovvero il cui comportamento dipende da uno o più tipi). In questo caso come definiamo la classe “contenitore” dei contratti e come indichiamo il tipo dell’interfaccia nell’attributo ContractClassFor?

In questo caso si può utilizzare la sintassi NomeTipo(Of ) come mostrato nel seguente esempio:

 <ContractClass(GetType(RepositoryContract(Of )))>
Public Interface IRepository(Of T)
    Function GetAll() As IEnumerable(Of T)
    Function GetSingle(id As Integer) As IEnumerable(Of T)
End Interface
 
<ContractClassFor(GetType(IRepository(Of )))>
Public MustInherit Class RepositoryContract(Of T)
    Implements IRepository(Of T)
 
    Public Function GetSingle(id As Integer) As System.Collections.Generic.IEnumerable(Of T) Implements IRepository(Of T).GetSingle
        Contract.Requires(id > 0)
        Throw New NotImplementedException()
    End Function
 
    Public Function GetAll() As System.Collections.Generic.IEnumerable(Of T) Implements IRepository(Of T).GetAll
        Throw New NotImplementedException()
    End Function
End Class
 

Nel momento in cui definiamo una classe reale imponendo il tipo T, avremo che il contratto viene “ereditato” automaticamente:

 Public Class Repository
    Implements IRepository(Of Entity)
 
    Public Function GetSingle(id As Integer) As System.Collections.Generic.IEnumerable(Of Entity) Implements IRepository(Of Entity).GetSingle
        Return Nothing
    End Function
 
    Public Function GetAll() As System.Collections.Generic.IEnumerable(Of Entity) Implements IRepository(Of Entity).GetAll
        Return Nothing
    End Function
End Class
 

senza che noi si debba riscriverlo.

Nel caso in cui l’interfaccia dipenda da più tipi è sufficiente scrivere le opportune virgole:

 <ContractClass(GetType(RepositoryContract(Of ,)))>
Public Interface IRepository(Of T1, T2)
    Function GetAll() As IEnumerable(Of T1)
    Function GetSingle(id As Integer) As IEnumerable(Of T1)
End Interface
 
<ContractClassFor(GetType(IRepository(Of ,)))>
Public MustInherit Class RepositoryContract(Of T1, T2)
    Implements IRepository(Of T1, T2)
 
    Public Function GetAll() As System.Collections.Generic.IEnumerable(Of T1) Implements IRepository(Of T1, T2).GetAll
        Throw New NotImplementedException()
    End Function
 
    Public Function GetSingle(id As Integer) As System.Collections.Generic.IEnumerable(Of T1) Implements IRepository(Of T1, T2).GetSingle
        Contract.Requires(id > 0)
        Throw New NotImplementedException()
    End Function
End Class
 

Tag di Technorati: code contracts,interfacce,abstract class,generics

Un servizio clienti al servizio del cliente

2011-04-17T20:55:00.001+02:00

Vorrei spendere questo post per sottolineare l’ottimo servizio fornitomi dal servizio clienti Vodafone.

In particolare il tutto è nato dalla necessità, all’arrivo del mio nuovo Omnia 7, di attivare una opzione internet sulla mia scheda Vodafone.

Nell’attivare tale opzione ho attivato inavvertitamente anche l’opzione per la navigazione wap il cui costo è decisamente sproporzionato.

Dopo un paio di giorni di navigazione wap e senza riuscire a switchare sulla navigazione web, ho chiamato il servizio clienti e, inaspettatamente, l’operatore mi ha comunicato che avrebbe provato a risolvere il mio errore e, contestualmente, mi avrebbe restituito i soldi spesi per errore.

E, già, qui sono rimasto sorpreso!

Dopo l’intervento del servizio clienti, la situazione non è migliorata ed il telefonino continuava ad andare in wap, così ho richiamato, dopo un paio di giorni, di nuovo il servizio clienti.

L’operatore, lo stesso della precedente volta, a cui, quindi non ho dovuto rispiegare di nuovo la situazione, ha cercato, assieme a me, di configurare lato telefono la connessione e, non riusciendoci, ha disabilitato il wap sulla scheda.

Ora il telefono è correttamente configurato e, ho pure ricevuto un ulteriore rimborso per gli altri giorni spesi con il wap!!!

La cosa mi ha piacevolmente sorpreso e ho accantonato l’idea di cambiare operatore!!!

Tag di Technorati: vodafone,190,servizio clienti,navigazione internet

Async CTP SP1 WP7 – Demo

2011-04-14T12:58:00.001+02:00

Vi segnalo questo video in cui viene illustrato come utilizzare la nuova SP1 di Visual Studio Async su WP7:

Tag di Technorati: WP7,Windows Phone 7,Async CTP SP1

Rilasciata Async CTP SP1

2011-04-13T19:47:00.001+02:00

E’ stata rilasciata la SP1 di Async CTP.

Questa versione include:

compatibilità con Visual Studio 2010 SP1;
API per Windows Phone 7
possibilità di utilizzare Async in produzione.

La pagina ufficiale di Visual Studio Asynchronous Programming è al seguente link.

E’ possibile scaricare la CTP al seguente link.

Tag di Technorati: Async CTP Sp1,Visual Studio Asynchronous Programming

MIX 11 – IE10 Platform Preview

2011-04-13T11:05:00.001+02:00

Coloro che hanno visto la keynote di ieri del Mix 11 saranno rimasti impressionati dalle potenzialità di IE10.

Per poter provare le funzionalità di IE10, è stata rilasciata la prima Preview Platform che è scaricabile da:

http://ie.microsoft.com/testdrive/Info/Downloads/Default.html

Come già avvenuto per IE9, le plattform preview verranno rilasciate in sequenza per permettere agli utenti di scoprire le nuove funzionalità non appena vengono messe a disposizione.

Tag di Technorati: ie10,ie10 platform preview,mix11

MIX11–Guarda la keynote

2011-04-13T10:00:00.001+02:00

Per chi ha perso la diretta della prima keynote di MIX11, può vederla registrata al seguente link

Key Note iniziale MIX 11

Tag di Technorati: mix11,ie10,keynote

Visual Studio 2010 SP1: Addio ByVal!!!

2011-03-14T14:35:00.001+01:00

Non è il titolo di un film, ma semplicemente una novità introdotta nella SP1 di Visual Studio 2010.

Gli sviluppatori VB sono abituati al fatto che, quando scrivono gli argomenti dei metodi, in automatico l’IDE inserisce (se già non c’è o non è stata inserita la ByRef) la parola chiave ByVal (il cui significato è riportato qui).

Con l’istallazione della SP1 di VS2010 ciò non accade più nel senso che se non mettiamo la parola chiave ByVal, l’IDE non la inserisce in automatico.

Non si tratta di un errore ma semplicemente del fatto che ByVal è di default e, quindi non è necessario inserirla.

Ovviamente se la mettiamo funziona tutto come prima.

Tag di Technorati: ByVal,VS 2010 SP1,Visual Studio 2010 SP1,ByRef