Blog di Vanini Mirco

TinyCLR.it a Hack Reality 2012

2012-02-23T06:01:00.001-08:00

Anche se con qualche giorno di ritardo volevo ringraziare tutti per la splendida giornata trascorsa in quel di Bologna all’hackathon “Hack Reality 2012” organizzato dai ragazzi di Whymca. Il team composto da Lorenzo Maiorfi, Gianluca Ruta, Mario Vernari ed il sottoscritto ha fatto la sua parte per la buona riuscita dell’evento. Come prima uscita di TinyCLR.it mi ritengo soddisfatto sia per l’esperienza che per la curiosità ed i contatti che abbiamo avuto. L’occasione è stata sicuramente un’ottima palestra per lo scambio di idee, esperienze ed il confronto con le più disparate tecnologie. In questo post potete trovare alcune foto dell’evento. Esperienza sicuramente da ripetere!

Windows Virtual PC & Microsoft Device Emulator

2012-02-21T15:00:00.001-08:00

In questi giorni ho ripreso in mano un progetto basato su Windows Mobile 6.x e con mia sorpresa ho scoperto che l’emulatore di WM6 non riusciva più a riconoscere la scheda di rete (NE2000 PCMCIA). L’errore riportato era il seguente:

The required Virtual Machine Network Driver could not be found. Make sure that Virtual PC 2007 is installed. You can install Virtual PC 2007 from http://go.microsoft.com/fwlink/?linkid=46859.

Pensando un po' ho fatto mente locale ricordando che l’installazione di Windows Virtual PC richiedeva la disinstallazione di Virtual PC2007. Morale: l’emulatore non funziona con i nuovi drivers di Windows Virtual PC. Cercando in rete ho trovato diverse soluzioni al caso molto simili ma quella che mi ha risolto il problema è la seguente:

Download Virtual PC 2007 SP1
Rinominare l’eseguibile setup.exe in vpc.exe
Aprire una shell dos ed eseguire il comando vpc.exe /c
Questo comando estrae il file MSI nel folder %temp%
Posizionarsi nel folder ed eseguire il comando msiexec /a Virtual_PC_2007_Install.msi /qb TARGETDIR=c:\vpc
Questo estrae i files del MSI nel folder c:\vpc
Aprire “Centro connessioni di rete e condivisione” e selezionare “Modifica Impostazioni scheda”

Selezionare la scheda di rete con cui ci si connette ad internet e aprire le proprietà della stessa
Premere il pulsante “Installa”

Selezionare “Servizio”

Selezionare “Disco Driver…”

Navigare in C:\vpc\Program Files\Microsoft Virtual PC\Utility\VMNetSrv\ per i sistemi x86 e in C:\vpc\Program Files\Microsoft Virtual PC\Utility\VMNetSrv\x64 per i sistemi a x64
Selezionare il file “VMNetSrv.inf”
Selezionare Virtual Machine Network Services e confermare

A questo punto il driver è installato e collegato alla scheda selezionata, se si vuole installare lo stesso driver su più schede si deve ripetere la procedura dal punto 8 per ogni singola scheda.

Hack Reality, ci siamo quasi

2012-02-16T15:27:00.001-08:00

Dopo il rinvio di due settimane fa causa abbondante nevicata e conseguenti disagi, sabato 18 febbraio si terrà a Bologna l’incontro di Hack Reality, l’evento di hackathon targato WhyMCA orientato all'interazione tra mobile e realtà. Io sarò presente con gli altri colleghi di TinyCLR.it con cui presenteremo dei brevi workshop inerenti il mondo .NET MicroFW, sicuramente ci sarà da divertirsi! Vi aspetto numerosi.

Windows 8 for ARM

2012-02-09T14:46:00.001-08:00

Post assolutamente da non perdere !

TinyCLR.it a HACK REALITY

2012-01-25T14:39:00.001-08:00

Il prossimo 4 febbraio si terrà a Bologna “Hack Reality”, il nuovo hackathon targato WhyMCA, orientato all'interazione tra mobile e realtà. Fra le varie tecnologie utilizzabili ci sarà spazio anche per .NET Micro Framework quindi per gli appassionati del genere sarà una bella occasione per mettersi alla prova e creare qualcosa di originale sia con il .NET MF che con le altre interessanti tecnologie disponibili. Ci vediamo a Bologna per “interagire con la realtà”.

.NETCF: ResolveAssemblyReferences warnings

2012-01-25T13:59:00.001-08:00

Durante lo sviluppo di un progetto per .NET CF mi è capitato di incontrare diversi warning del tipo:

ResolveAssemblyReferences: Consider app.config remapping of assembly "System.Windows.Forms, Culture=neutral, PublicKeyToken=969db8053d3322ac, Retargetable=Yes" from Version "2.0.0.0" [] to Version "3.5.0.0" [C:\Program Files\Microsoft.NET\SDK\CompactFramework\v3.5\ WindowsCE\System.Windows.Forms.dll] to solve conflict and get rid of warning.

Questo avviso viene visualizzato quando il compilatore ha caricato le librerie BCL del .NET Compact Framework 3.5, ma i metadati contenuti nei assembly referenziati fanno riferimento alle librerie BCL del .NET Compact Framework 2.0.

Per rimuovere questi warning è possibile aggiungere un file app.config al progetto e reindirizzare le associazioni degli assembly della 2.0 a gli equivalenti della 3.5. Di seguito è riportato un esempio di XML per reindirizzare la versione 2.0 di System.dll alla versione 3.5:

<?xml version="1.0" encoding="utf-8" ?><configuration>  <runtime>    <assemblybinding xmlns="urn:schemas-microsoft-com:asm.v1">      <dependentassembly>        <assemblyidentity name="System" culture="neutral" publickeytoken="969db8053d3322ac" />        <bindingredirect  newVersion="3.5.0.0" oldVersion="2.0.0.0" />      </dependentassembly>    </assemblybinding>  </runtime></configuration>

Sarà necessario aggiungere un elemento dependentassembly per ognuno dei warning ResolveAssemblyReferences che si ricevono dal compilatore.

In fine, assicurarsi che la proprietà Build Action del file app.config sia impostata su Content e la proprietà di Copy To Output Directory sia impostata su Only if newer.

XeDotNet – Prossimi meeting

2012-01-11T14:01:00.001-08:00

Anno nuovo, nuovo calendario di sessioni per il primo semestre 2012 di XeDotNet.

10/02/2012 - HTML5 e lo sviluppo mobile

Andrea Dottor - ASP.NET e lo sviluppo mobile?
Davide Senatore - Packaging HTML5 application with PhoneGap

09/03/2012 - Sviluppo client side

Andrea Boschin - What's new in Silverlight 5.0
Andrea Dottor - Il mondo è sempre più client. ASP.NET e lo sviluppo Client Side

30/03/2012 - Real world experience

Cristiano Simionato - Ma quanto costa Windows Azure?
Mirco Vanini - REST & .NET Micro FW - A Real Case

04/05/2012 - Uno sguardo a futuro

Davide Vernole - Visual Studio vNext - Application Lifecycle Management
Andrea Boschin - Sviluppare applicazioni Metro con Windows 8 e WinRT

15/06/2012 - Playing with gadgets

Mirco Vanini - Are you a Gadgeteer?
Davide Vernole - Playing with Team Foundation Server

In questo semestre avrò il piacere di tenere due sessioni su argomenti ed esperienze che mi vedono impegnato in prima persona sia nell’ambito lavorativo sia nell’ambito di community. La prima sessione sarà basata su un caso reale mentre la seconda riguarderò il .NET Gadgeteer.

NETMF Extension Methods

2012-01-07T01:49:00.001-08:00

Una delle caratteristiche più accattivanti di C# sono gli extension methods, peccato che per il .NET MicroFW non siano disponibili. Infatti tentando di utilizzarli si ottiene il seguente errore:

Cannot define a new extension method because the compiler required type 'System.Runtime.CompilerServices.ExtensionAttribute' cannot be found. Are you missing a reference to System.Core.dll?

Cercando una possibile soluzione ho trovato questo post che riporta la soluzione al problema:

using System;using System;using System.Threading; using Microsoft.SPOT;using Microsoft.SPOT.Hardware; // Required for NETMF to recognized extension methodsnamespace System.Runtime.CompilerServices{    [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Method)]    public sealed class ExtensionAttribute : Attribute { }} // Extension methods for byte[] - typically would be put in a separate filepublic static class ByteArrayExtensions{    // Method to create a string from UTF8-encoded bytes - be careful about null "this" being passed in    public static string ToStringFromUTF8(this byte[] bytes)    {        return null == bytes ? String.Empty : new String(System.Text.Encoding.UTF8.GetChars(bytes));    }}

Come si vede dal codice riportato il trucco è definire l’attributo ExtensionAttribute.

TinyCLR.it è finalmente online!

2011-12-09T03:39:00.001-08:00

Come vi avevo preannunciato qualche settimana fa siamo finalmente online. Nei prossimi giorni aggiungeremo vari contenuti che spero cattureranno sempre di più la vostra attenzione. Volevo ringraziare in modo particolare Lorenzo per lo sforzo che ha dedicato per la messa online del sito.

Slide della sessione: “Visual Studio Architect Tools”

2011-12-06T05:09:00.001-08:00

Ecco disponibile al download le slide del XeDotNet community meeting che ho tenuto il 2 Dicembre 2011 dal titolo Visual Studio Architect Tools inerente l’utilizzo dei Layer Diagram.

“In Visual Studio Ultimate è possibile utilizzare un Layer Diagram per visualizzare l'architettura logica del sistema. Un Layer Diagram organizza gli elementi fisici nel sistema in gruppi logici e astratti chiamati Layer. Questi Layer consentono di identificare, descrivere e differenziare i tipi di attività eseguite dagli elementi. Ogni Layer può contenere anche livelli aggiuntivi o sottolivelli, che descrivono specifiche attività più piccole eseguite dai gruppi discreti di elementi. Utilizzando un Layer Diagram è possibile eseguire le attività seguenti: Comunicare l'architettura logica esistente o desiderata del sistema; Individuare i conflitti tra il codice esistente e l'architettura desiderata; Visualizzare l'impatto delle modifiche sull'architettura desiderata quando si esegue il refactoring, l'aggiornamento o l'evoluzione del sistema; Rinforzare l'architettura desiderata durante lo sviluppo e la manutenzione del codice includendo la convalida con le operazioni di archiviazione e compilazione. Durante questa sessione vedremo come sia possibile utilizzare questa tipologia di diagramma per migliorare la creazione e la manutenzione delle nostre applicazioni.”

Volevo porgere un ringraziamento a tutte le numerose persone presenti al meeting, allo staff di XeDotNet ed in particolare a Andrea Boschin e a Davide Vernole, con cui ho condiviso la sessione, per il supporto tecnico, morale ed organizzativo della sessione e per l’opportunità che mi è stata data.

XeDotNet Meeting - Visual Studio Architect Tools

2011-11-29T12:45:00.001-08:00

Volevo segnalarvi il prossimo meeting di XeDotNet che si terrà il 2 dicembre 2011

UML con Visual Studio 2010
Speaker: Davide Vernole

Una corretta progettazione è alla base di un applicazione in grado di dare valore al cliente. Quando ci troviamo in questa fase del ciclo di vita di un'applicazione la domanda che spesso ci si pone è: quale notazione utilizzare? Visual Studio 2010 ci propone una possibile risposta indicando in UML la scelta standard da seguire. Sebbene l'implementazione di Visual Studio 2010 non sia UML al 100% la soluzione offerta aiuta a standardizzare l'approccio progettuale di uno o più team di sviluppo. La sessione si pone l'obiettivo di dimostrare queste funzionalità simulando l'intero processo di progettazione.

Layer Diagram con Visual Studio 2010
Speaker: Mirco Vanini

In Visual Studio Ultimate è possibile utilizzare un Layer Diagram per visualizzare l'architettura logica del sistema. Un Layer Diagram organizza gli elementi fisici nel sistema in gruppi logici e astratti chiamati Layer. Questi Layer consentono di identificare, descrivere e differenziare i tipi di attività eseguite dagli elementi. Ogni Layer può contenere anche livelli aggiuntivi o sottolivelli, che descrivono specifiche attività più piccole eseguite dai gruppi discreti di elementi. Utilizzando un Layer Diagram è possibile eseguire le attività seguenti: Comunicare l'architettura logica esistente o desiderata del sistema; Individuare i conflitti tra il codice esistente e l'architettura desiderata; Visualizzare l'impatto delle modifiche sull'architettura desiderata quando si esegue il refactoring, l'aggiornamento o l'evoluzione del sistema; Rinforzare l'architettura desiderata durante lo sviluppo e la manutenzione del codice includendo la convalida con le operazioni di archiviazione e compilazione. Durante questa sessione vedremo come sia possibile utilizzare questa tipologia di diagramma per migliorare la creazione e la manutenzione delle nostre applicazioni.

Venerdì 2/12/2011 ore 19:30
Novotel Castellana
Via Alfredo Ceccherini 21 - Venezia Mestre

per iscrizioni: clicca qui

Gestione prenotazioni con .NET Micro FW

2011-11-27T03:12:00.001-08:00

Come vi avevo anticipato nei post precedenti vi anticipo qualche contenuto che sarà pubblicato sul sito TinyCLR.it.

Introduzione

Durante la mia attività di sviluppatore mi sono imbattuto in svariate problematiche che ho risolto utilizzando le varie tecnologie presenti sul mercato. Non sempre queste tecnologie risolvevano in modo “pulito” tutti i punti di queste problematiche ma come si dice di necessità virtù!

Come tutti mi è capitato di riaffrontare le stesse problematiche a distanza di tempo e confrontare e/o rivedere le scelte tecnologiche fatte. In questo caso, che andrò ad illustrare, vi porto la mia esperienza di sviluppo di un sistema di gestione prenotazioni basato su dispositivi con il .NET MF 3.0 e la sua rivisitazione con il .NET FW 4.1 con le nuove funzionalità in esso contenute.

Richieste funzionali

Come in tutti i progetti si parte dalle richieste funzionali che il software deve soddisfare. Di seguito sono esposte le principali, in dettaglio:

Si richiede lo sviluppo di un sistema di gestione prenotazione code per punto vendita. Il sistema deve prevedere:

un pulsante di prenotazione
la stampa della prenotazione
un sistema di verifica della stessa prenotazione
un sistema di evasione della prenotazione
un sistema di consultazione dello stato coda
un sistema di notifica avanzamento coda
…

La rappresentazione dei moduli principali della soluzione può essere riassunto nel seguente schema:

Come si può notare dallo schema precedente la soluzione è suddivisa in varie parti, in dettaglio:

Un servizio di back-end che ospita tutta la logica delle prenotazioni, la loro persistenza, la logica delle notifiche, ecc.
Un modulo di gestione della richiesta di prenotazione.
Un modulo di gestione dell’emissione del ticket di prenotazione.
Un modulo di gestione interrogazione e/o verifica dei ticket di prenotazione.
Un modulo di gestione esecuzione prenotazione.
Un modulo di gestione di esecuzione notifica verso i vari dispositivi informativi.

In tutti i moduli in cui vi è un’iterazione con dispositivi esterni (stampanti, lettori di barcode, display, ecc.) si è scelto di adottare dei dispositivi con .NET FW.

I vari moduli basati su dispositivo MF, sono stati elencati come moduli separati per semplicità, ma nella realtà sono “racchiusi” in un’unica procedura.

Questa soluzione, nella sua prima versione, è stata sviluppata utilizzando VS2008 e .NET MF 3.0. Per la sua rivisitazione è stato poi adottato VS2010 e .NET MF 4.1. Oltre all’ambiente di sviluppo sono state cambiate molte parti della stessa cercando di utilizzare al meglio tutto quello che il nuovo .NET Micro FW metteva a disposizione con la nuova versione.

In questo articolo mi soffermerò soprattutto sul modo con cui i due mondi, servizio di back-end e dispositivi MF, si parlano e come questo sia evoluto con il cambio del MF.

I sorgenti allegati al presente sono divisi in due esempi, sample1 utilizza una comunicazione basata su socket mentre sample2 utilizza WCF per la parte di comunicazione. Per questi esempi è stato utilizzato VS2010 e .NE MF 4.1 in entrambe le sezioni, simulando nel primo caso la soluzione adottata con il FW 3.0.

Questa opzione è stata adottata per non costringere a chi utilizza il codice di avere installato e configurato entrambi gli ambienti.

Codice Allegato

Allegato all’articolo è fornito il codice sorgente di esempio trattato nei vari capitoli seguenti. La solution di VS 2010 è composta dai seguenti moduli:

Esempi con MF 3.0
- Xe.Sample1.Server: progetto windows form che racchiude le funzionalità di back-end del servizio di gestione prenotazioni.
- Xe.Sample1.MicroDevice: progetto device di tipo console che racchiude le funzionalità di consumo del servizio di gestione prenotazioni.
Esempi con MF 4.1
- Xe.Sample1.FakeService: progetto window form per la generazione di un servizio fake.
- Xe.Sample2.ReservationMarker: progetto device di tipo windows che racchiude le funzionalità di consumo di richiesta prenotazione.
- Xe.Sample2.ReservationMicroProxy: progetto device i tipo class library che racchiude il proxy verso il servizio di gestione prenotazioni
- Xe.Sample2.ReservationService: progetto windows form che racchiude le funzionalià del servizio di gestione prenotazioni.
- Xe.Sample2.ReservationTicket: progetto device di tipo windows che racchiude le funzionalità di stampa della prenotazione.
- Xe.Sample2.ReservationTicketClient: progetto di tipo windows form che racchiude le funzionalità di richiesta stampa della prenotazione.
- Xe.Sample2.ReservationTicketProxy: progetto di tipo class library che contiene il proxy verso il servizio di gestione della stampa del ticket prenotazione

P.S.: Per ovvi motivi commerciali e di chiarezza il codice illustrato ed allegato a questo articolo è solo una parte riadattata della soluzione realizzata.

Esempio con MF 3.0

L’esempi che utilizza il MF 3.0 è composto dalle seguenti parti:

Reservation Service (.NET WinForm)
- TcpCommandListener
- MicroProtocol
- ThreadPooling
Reservation Marker (.NET Micro FW Console)
- TcpCommandListener
- DeviceManager
- MicroProtocol

Reservation Service(Xe.Sample1.Server)

Le funzionalità base del servizio di prenotazioni sono le seguenti:

Richiesta di una nuova prenotazione su una particolare coda (AskNewQueueReservation)
Richiedi lo stato di una particolare coda (GetCurrentQueueReservation
Esegui la prenotazione corrente per una determinata coda (ExecCurrentQueueReservation)

Queste funzionalità del servizio sono esposte ai vari dispositivi utilizzando un protocollo basato su socket nella versione 3.0 del .NET MF. Il protocollo che viene illustrato è semplice ed epurato di tutte le complessità e controlli che un protocollo deve avere. Le richieste verso il servizio di prenotazioni sono gestite tramite un listener socket che ascolta e cattura le richieste provenienti dai vari dispositivi

Le classi principali di questo modulo sono:

QueueManager: classe di gestione prenotazioni
TcpCommandListener: classe di gestione richieste / risposte tramite socket
MicroProtocol: classe di gestione protocollo da e per i device

Reservation Marker(Xe.Sample1.MicroDevice)

Questo modulo è sviluppato utilizzando .NET MF e costituisce il consumatore del servizio di prenotazione precedentemente illustrato. Trami questa modulo è possibile richiedere le seguenti azioni:

Eseguire una nuova prenotazione.
Richiedere lo stato di una specifica coda.
Eseguire la prenotazione corrente.

Il modulo utilizza una comunicazione basata su socket e su un protocollo proprietario. Questo protocollo ovviamente è condiviso con la parte di back-end.

Le classi principali di questo modulo sono:

DeviceManager: classe di gestione del device
TcpCommandListener: classe di gestione richieste / risposte tramite socket
MicroProtocol: classe di gestione protocollo da e per il serivzio di back-end

Considerazioni Sample1

Se si osserva il codice allegato si potrà notare la complessità nella comunicazione tra dispositivo e server di back-end. Tale complessità è insita nella tecnologia utilizzata, i socket sono sempre la strada più performante ma come tutte le cose ha un costo, la relativa complessità di implementazione ma soprattutto la sua manutenzione. Ogni volta che doppiamo modificare e/o estendere il protocollo di comunicazione per nuove funzionalità il lavoro da fare non è poco. Il .NET MF 3.0 offre i DPWS, non certo facili da implementare ma soprattutto non supportati nella versione 3.5 del .NET FW lato desktop. Oltre a questo il server e i dispositivi devono conoscersi, in altre parole il dispositivo deve conoscere l’indirizzo IP e la relativa porta a cui il servizio risponde, viceversa anche il server deve conoscere l’indirizzo IP e la relativa porta del dispositivo a cui il servizio deve rispedire le risposte. Per evitare questo si posso implementare sistemi di identificazione o di auto censimento, ma come dicevo precedentemente, poi bisogna anche mantenerli e/o estenderli.

case MicroProtocol.ProtocolType.AskNewQueueReservation:     AddMessage2Trace("Device -> AskNewRQueueeservation");     ret = MicroProtocol.ReturnOkToken;     ThreadPool.QueueUserWorkItem(state =>    {        var tmp = state as MicroProtocol;         var resp = new MicroProtocol(MicroProtocol.ProtocolType.AskNewQueueReservationResponse,                                     Queues.AskNewQueueReservation(tmp.Param).ToString());                                            CmdListener.SendCommand(DeviceIpToken,                                DeviceIpPortToken,                                MicroProtocol.Serialize(resp));                        }, cmd);     break;

Con l’uscita del .NET MF 4.1 e soprattutto con l’uscita del .NET FW 4.0 lato desktop le cose sono cambiate. In questa versione il MF supporta la versione 1.1 di DPSW compatibile con la versione 4.0 di WCF. Utilizzando il nuovo binding (ws2007HttpBinding) è possibile consumare servizi WCF direttamente dal dispositivo MF e viceversa, il dispositivo MF può esporre dei servizi consumabili tramite un client WCF.

Quest’ultima affermazione cambia radicalmente il possibile approccio per l’implementazione della comunicazione tra il servizio ed il dispositivo MF. Per questo motivo, e per il naturale evoluzione delle cose, l’applicazione è stata rivista adottando le ultime tecnologie disponibili.

Esempio con MF 4.1

L’esempi che utilizza il MF 4.1 è composto dalle seguenti parti:

Reservation Service (.NET WinForm)
- WCF Service [service discoverable over UDP multicast]
Reservation Marker (.NET Micro WinApp)
Reservation MicroProxy (.NET Micro Class Library)
- Discovery [send UDP request to the DPWS multicast address]
Reservation Ticket (.NET Micro WinApp)
- DSPW Service
Reservation Ticket Proxy (.NET Micro Class Library)
- Discovery [client discovery]
Reservation Ticket Client (.NET WinForm)

Reservation Service(Xe.Sample2.ReservationService)

Le funzionalità esposte dal servizio sono le stesse del modulo precedente. Quello che cambia in questo caso è come vengono esposte tali funzionalità. Infatti in questo caso le stesse sono erogate tramite un servizio WCF. La peculiarità di questo servizio è la possibilità dello stesso di essere individuato dai device tramite il multicast UDP. La creazione e la configurazione di questa modalità sono espresse nel codice della windows form che funge da host del servizio WCF.

if (Service != null && Service.State == CommunicationState.Opened)    Service.Close(); Uri baseAddress = new Uri("http://" +                           "192.168.1.33" +                           ":8084/Xe.Sample2.ReservationService/ReservationService/"); Service = new ServiceHost(typeof(ReservationService),                           baseAddress); ServiceEndpoint wsEndpoint = Service.AddServiceEndpoint(typeof(IReservationService),                                                         new WSHttpBinding(SecurityMode.None),                                                                           string.Empty);EndpointDiscoveryBehavior endpointDiscoveryBehavior = new EndpointDiscoveryBehavior(); // Add the discovery behavior to the endpoint.//wsEndpoint.Behaviors.Add(endpointDiscoveryBehavior); // Make the service discoverable over UDP multicast//Service.Description.Behaviors.Add(new ServiceDiscoveryBehavior());Service.AddServiceEndpoint(new UdpDiscoveryEndpoint(DiscoveryVersion.WSDiscovery11)); ServiceMetadataBehavior smb = new ServiceMetadataBehavior();smb.HttpGetEnabled = true;smb.HttpGetUrl = baseAddress;Service.Description.Behaviors.Add(smb); Service.Open();

In questa modalità i device MF non devono conoscere l’indirizzo IP del servizio ma solamente il nome del contratto e/o il guid dello stesso.

Reservation Proxy(Xe.Sample2.ReservationProxy)

Una volta definite il servizio WCF modifichiamo il modulo MF che richiede le prenotazioni. Per questo è stato creato un nuovo modulo che racchiude il proxy verso il servizio di back-end. Il proxy è racchiuso nell’esempio denominato Xe.Sample2.ReservationMicroProxy. Per la generazione del proxy si usa l’utility MFSvcUtil.exe inclusa nel sdk del .NET MF 4.1. Nel codice ho inserito anche il batch che invoca l’utility che genererà i seguenti file:

Reservation.cs
ReservationClientProxy.cs

Questi due file rappresentano il data contract serializer per le entità passate attraverso il canale e il proxy autogenerato. La classe di helper che permette di utilizzare il proxy autogenerato è ReservationProxy. Oltre alle funzioni di helper questa classe si incarica anche di esegure il discover del servizio. Questo viene eseguito specificando semplicemente il contratto esposto completo di name space.

private void CreateServiceProxy(){    try    {        Uri remoteEp = new Uri("http://192.168.1.33:8084/Xe.Sample2.ReservationService/ReservationService/");        WS2007HttpBinding binding = new WS2007HttpBinding(new HttpTransportBindingConfig(remoteEp));         /// ProtocolVersion11 can be used if the corresponding WCF desktop server application        /// WcfServer uses wsHttpBinding instead of the custom binding "Soap11AddressingBinding"        ///         _proxy = new ReservationServiceClientProxy(binding,                                                    new ProtocolVersion11());         _proxy.IgnoreRequestFromThisIP = false;         if (!Discover())        {            Debug.Print("Discovery failed, trying direct address");            _proxy.EndpointAddress = "http://192.168.1.33:8084/Xe.Sample2.ReservationService/ReservationService/";        }    }    catch (Exception ex)    {        Debug.Print(ex.ToString());    }}

private bool Discover(){    DpwsServiceTypes typeProbes = new DpwsServiceTypes();    typeProbes.Add(new DpwsServiceType("IReservationService",                                        "http://localhost/ReservationService"));     // A Probe is used to discover services on a network.     // The Probe method sends a UDP request to the DPWS multicast address,     // 239.255.255.250:3702. Any service that implements types specified     // in the filters parameter should respond with a ProbeMatches message.     // The ProbeMatches message is unicast back to the that client that made     // the request. If a null filter is supplied, any DPWS-compliant service     // should reply with a ProbeMatches response.     // Probe waits ReceiveTimeout for ProbeMatches.     //    DpwsServiceDescriptions descs = _proxy.DiscoveryClient.Probe(typeProbes, 1, 20000);     if (descs.Count > 0)    {        _proxy.EndpointAddress = descs[0].XAddrs[0];        return true;    }     return false;}

Il codice sopra esposto esegue il discover del servizio e ne ritorna endpoint address dello stesso. In caso di errore viene assegnato un endpoint address preconfezionato. Una volta eseguito il discover del servizio il proxy è pronto per essere utilizzato.

Reservation Marker(Xe.Sample2.ReservationMarker)

Questo modulo è sviluppato utilizzando .NET MF e costituisce il consumatore del servizio di prenotazione precedentemente illustrato. Trami questa modulo è possibile richiedere le seguenti azioni:

Eseguire una nuova prenotazione.
Richiedere lo stato di una specifica coda.

Il device utilizzato in questo esempio è dotato di touch screen e tramite questo viene eseguita la richiesta di una nuova prenotazione. Dopo l’invio della richiesta di una nuova prenotazione viene aggiornato lo stato corrente della coda di prenotazioni su cui è stata eseguita la richiesta stessa.

private void ImgTouchDown(object sender, TouchEventArgs e){    try    {        _border.BorderBrush = _reverseBorderBrush;        _border.Invalidate();         Utility.Piezo(1000, 400);         int ret = ReservationProxy.Instance.AskNewQueueReservation(QueueCodeToken);         this.Dispatcher.BeginInvoke(new DispatcherOperationCallback(UpdateValues),                                     null);         Debug.Print("AskNewQueueReservation: " + ret.ToString());    }    catch (Exception ex)    {                        Debug.Print(ex.ToString());    }}

Da notare l’utilizzo del dispatcher per la richiesta asincrona di aggiornamento della stato della coda.

private object UpdateValues(object input){    try    {        var status = ReservationProxy.Instance.GetQueueStatus(QueueCodeToken);        if(status == null)            return null;         _currentText.TextContent = Utils.PadLeft(status.Current.ToString(), 3);        _nextText.TextContent    = Utils.PadLeft(status.Next.ToString(), 3);        _currentText.Invalidate();        _nextText.Invalidate();         return status;    }    catch (Exception ex)    {        Debug.Print(ex.ToString());        return null;    }}

Altra cosa fondamentale da notare è il valore di ritorno della chiamata GetQueueStatus. Il valore ritornato è un’istanza di una classe QueueStatus definita nel proxy. Tale classe è autogenerata dall’utility MFSvcUtil vista in precedenza. Questo punto è fondamentale. Nell’esempio precedente, ogni modifica al protocollo era costosa in ordine di tempo e di debug. In questo caso se il servizio modifica l’entità ritornata basterà semplicemente rigenerare il proxy.

Reservation Ticket(Xe.Sample2.ReservationTicket)

Nel modulo precedente abbiamo visto come consumare un servizio WCF, ora vediamo come sia possibile rendere disponibile un servizio WCF direttamente su un device con .NET Micro FW. Questo servizio sarà consumato da un applicativo lato desktop. Il modulo mette a disposizione un servizio WCF per la stampa del ticket di prenotazione su una stampante dedicata collegata direttamente sul device tramite porta USB. Per generare il servizio WCF sul device dobbiamo prima creare un servizio fake con cui interagire con l’utility MFSvcUtil. Il servizio fake in questione è il modulo denominato Xe.Sample2.FakeService. Questo modulo è un applicativo winform che contiene un servizio WCF con lo stesso contratto del servizio che vogliamo sia implementato lato device.

[ServiceContract]public interface IReservationTicketService{    [OperationContract]    void PrintReservationTicket(byte [] buffer);}

Una volta implementato il servizio facciamo partire l’applicativo e tramite l’utility MFSvcUtil generiamo il proxy. Nel codice di esempio ho incluso il file batch che genera il proxy del servizio fake. Se notiamo l’utility, oltre al codice del proy, genera anche la classe per implementare hosting del servizio lato device con lo stesso contratto del servizio su cui si è eseguito il proxy. In dettaglio la classe generata è contenuta nel file ReservationTicketHostedService.cs. Ora il prossimo passo è quello di implementare la classe del servizio vero e proprio. Il codice è contenuto nel file ReservationTicketImpl.cs.

public PrintReservationTicketResponse PrintReservationTicket(PrintReservationTicket req){     try     {                    Program.Instance.InvokeUpdateAction(Resources.GetString(Resources.StringResources.ActionPrintTicket));                Program.Instance.InvokePrintTicket(req.buffer);         System.Threading.Thread.Sleep(500);         var ret = new PrintReservationTicketResponse();         Program.Instance.InvokeUpdateAction(Resources.GetString(Resources.StringResources.ActionWaitPrintTicket));         Debug.Print("PrintReservationTicket");                return ret;            }    catch (Exception ex)    {        Debug.Print(ex.ToString());         return new PrintReservationTicketResponse();    }}

La classe ReservationTicketImpl, che contiene il metodo sopra riportato, implementa l’interfaccia IIReservationTicketService generata sempre durante la fase di generazione del proxy.

Il servizio sul dispositivo è fatto partire nel main dell’applicativo:

Program.Instance.Dispatcher.BeginInvoke(new DispatcherOperationCallback(Program.Instance.AsyncStartService), null)

La funzione di start vera è propria è la seguente:

private void StartService(){    try    {        // Initialize the binding        //        string guid = "urn:uuid:926A876C-6C6A-4FC5-B665-05B36DDBB932";         // ProtocolVersion10 can be used only if the corresponding client application        // uses a custom binding with Soap12WSAddressingAugust2004 text message encoding.        //        ProtocolVersion version = new ProtocolVersion11();        Device.Initialize(new WS2007HttpBinding(new HttpTransportBindingConfig(guid, 8085)),                           version);         // Set device information        //        Device.ThisModel.Manufacturer    = "MyCompany";        Device.ThisModel.ManufacturerUrl = "http://www.mycompany.com/";        Device.ThisModel.ModelName       = "Reservation Ticket Device";        Device.ThisModel.ModelNumber     = "1.0";        Device.ThisModel.ModelUrl        = "http://www.mycompany.com/";        Device.ThisModel.PresentationUrl = "http://www.mycompany.com/";         Device.ThisDevice.FriendlyName    = "ReservationTicketService";        Device.ThisDevice.FirmwareVersion = "alpha";        Device.ThisDevice.SerialNumber    = "32345678";         // Add a Host service type        //        Device.Host = new ReservationTicketService(version);         // Add Dpws hosted service(s) to the device        //        Device.HostedServices.Add(new IReservationTicketService(new ReservationTicketImpl()));         // Set this device property if you want to ignore this clients request        //        Device.IgnoreLocalClientRequest = false;         // Turn console messages on        //        Console.Verbose = true;         Debug.Print("Start DPWS device service with endpoint address: '" + Device.EndpointAddress + "'");         ServerBindingContext ctx = new ServerBindingContext(version);         // Start the device        //        Device.Start(ctx);          _serviceStatus = Resources.GetString(Resources.StringResources.ServiceStartedStatus);        _actionStatus  = Resources.GetString(Resources.StringResources.ActionWaitPrintTicket);    }    catch (Exception ex)    {        _serviceStatus = Resources.GetString(Resources.StringResources.ServiceFailedStatus);        Debug.Print(ex.ToString());    }     this.Dispatcher.BeginInvoke(new DispatcherOperationCallback(UpdateValues), null);}

Come si vede la partenza del servizio da prima crea il binding, poi crea l’host del servizio a cui aggiunge l’implementazione concreta del nostro servizio e poi fa partire la parte DPWS. A questo punto il nostro servizio WCF su dispositivo .NET Micro FW è pronto per accettare richieste dall’esterno.

Sempre nello stesso modulo da notare anche l’utilizzo diretto della porta USB, mediante le librerie fornite dal produttore della scheda stessa.

USBHostController.DeviceConnectedEvent += Program.Instance.DeviceConnectedEvent; … private void DeviceConnectedEvent(USBH_Device device){    if (device.TYPE == USBH_DeviceType.Printer)    {        Debug.Print("Printer Connected");         Printer = new USBH_Printer(device);    }} … public void InvokePrintTicket(byte[] buffer){    if (Printer != null && Printer.GetStatus() == USBH_PrinterStatus.Selected)    {        Printer.SendData(buffer, 0, buffer.Length, 1000);    }}

Reservation Ticket Client (Xe.Sample2.ReservationTicketClient)

Questo modulo rappresenta il client, lato desktop, del servizio WCF che abbiamo appena implementato sul device. Per consumare il servizio WCF come sempre creiamo il nostro modulo proxy. Questo modulo è racchiuso nell’esempio Xe.Sample2.ReservationTicketProxy. In questo modulo importiamo il file ReservationTicketService.cs, generato in precedenza durante lo sviluppo del servizio WCF. In questo file vi è la definizione dell’interfaccia IReservationTicketService che sarà utilizzata come criterio di ricerca per eseguire il discover del servizio stesso.

private bool FindService(){    try    {        DiscoveryClient discoveryClient =            new DiscoveryClient(new UdpDiscoveryEndpoint(DiscoveryVersion.WSDiscovery11));         Collection<EndpointDiscoveryMetadata> services = discoveryClient.Find(new FindCriteria(typeof(IReservationTicketService))).Endpoints;         discoveryClient.Close();         if (services.Count == 0)        {            return false;        }        else        {            _serviceAddress = services[0].ListenUris[0];        }    }    catch    {        return false;    }     return true;}

Tramite questo codice la classe di proxy ricerca un servizio che espone il contratto definito nell’interfaccia IReservationTicketService senza conoscerne url. Una volta definito il proxy non ci resta che consumare il servizio sul device.

public void PrintReservationTicket(byte[] buffer){    try    {        if (_proxy == null)        {             if(FindService())                _proxy = new ReservationTicketServiceClient(EndPointConfigurationName,                                                             _serviceAddress.AbsoluteUri);        }         _proxy.PrintReservationTicket(buffer);    }    catch (Exception ex)    {                        throw;    }}

Questi sono i devices che ho utilizzato per la realizzazione degli esempi.

Considerazioni Sample2

Osservando il codice del secondo esempio si può capire come si sia evoluta la parte di comunicazione tra i due FW. L’introduzione del supporto WCF tra i due mondi del .NET FW ha aperto scenari di integrazione molto accattivanti. Il fatto di poter eseguire la ricerca di un servizio senza conoscerne in anticipo l’indirizzo esatto permette una libertà totale sull’architettura definibile. Questo e molto altro ancora, introdotto con il .NET FW 4.1, mi ha spinto a rivedere in questa direzione il progetto in questione. Spero che, sia la spiegazione che il codice allegato, sia sufficiente a generare in chi legge curiosità verso il .NET MF.

TinyCLR.it dove eravamo rimasti…

2011-11-23T00:03:00.001-08:00

Già dove eravamo rimasti! Durante la sessione di giugno 2011 riguardante il .NET Micro FW, che ho tenuto per XeDotNet, ho preannunciato l’imminente comparsa della prima community italiana interamente dedicata al .NET Micro FW ed il relativo sito. Questo iniziativa è partita da una serie di professionisti e di colleghi per centralizzare le varie esperienze in un unico contenitore. Come spesso accade sono e siamo stati sommersi dai mille impegni lavorativi. Questi mesi ci hanno visto impegnati su vari fronti, la raccolta del materiale da mettere on line, la definizione della piattaforma su ci basare il sito, i vari problemi di hosting, la scrittura di vari articoli, ecc.. Tutto questo ovviamente “mediando” il tempo tra lavoro, famiglia ed impegni vari. Morale: entro la fine di dicembre andremmo on line con il sito! Nei prossimi giorni pubblicherò qualche anteprima del sito, giusto per raccogliere qualche commento e suggerimento.

Windows Embedded roadmap update

2011-11-17T00:55:00.001-08:00

I teams di Windows Embedded stanno delineando le prossime generazione dei loro prodotti, in questo link trovata la roadmap. Un sunto per punti è disponibile in questo link.

Windows Embedded Compact 7 Online Training

2011-11-17T00:46:00.001-08:00

Grazie a Valter Minute ora sono disponibili una nuova serie di training on line, bel lavoro come sempre.

Developing a Windows Phone Application from Start to Finish

2011-11-17T00:43:00.001-08:00

Articolo veramente ben fatto!

FEZ Hydra preview

2011-11-06T01:03:00.001-07:00

GHI ha pubblicato le prime immagini della nuova scheda FEZ Hydra per la famiglia .NET Gadgeteer, buona visione!

.NET Micro FW 4.2 RTM

2011-10-06T14:29:00.001-07:00

Da qualche giorno è stata rilasciata la versione RTM del .NET MF 4.2. È possibile scaricare l' SDK e PK. In questa versione sono state introdotte le seguenti nuove funzionalità:

Remoto Firmware Update
Complete Cryptographic Object Model over PCKS #11
1-Wire, PWM and A/D object model
SNTP and FTP (client and server)
StringBuilder and Regex types
VB.NET
Support for Cortex M3 devices with STM32 processor family samples
PKStudio

Per un elenco dettagliato delle nuove funzionalità questo è il link dell’annuncio

SQL Compact Query Analyzer

2011-09-22T01:54:00.001-07:00

Per chi utilizza Sql Compact questo sicuramente è un strumento molto interessante.

Portable Libraries for Visual Studio 2010 SP1

2011-09-06T04:58:00.001-07:00

Il BCL Team di Microsoft ha rilasciato questo interessante PowerTool per VS2010 SP1. Tramite questo tool è possibile gestire assemblies per uno o più target .NET FW. Il tool gestisce il .NET FW Full (dalla 2.0 alla 4.0, con il profilo full o client), Silverlight, Silverlight for Windows Phone 7 e Xbox 360. Gran bel lavoro!

Windows Azure Toolkits for devices

2011-09-06T04:45:00.001-07:00

Volevo segnalare l’aggiornamento del medesimo SDK per iOS e Android !

A .NET Micro FW Cool Product

2011-09-02T10:05:00.001-07:00

Questo video da una buona dimostrazione dei prodotti che si possono sviluppare/realizzare con il .NET Micro FW. Buona visione.

The Internet of Things

2011-09-02T10:02:00.001-07:00

Vi segnalo questo libro, ottima introduzione, e non solo, all’argomento!!!

NETMF Version 4.2 Release Candidate 2

2011-09-02T10:00:00.001-07:00

In questo articolo viene spiegato cosa introduce questa nuova versione. Buona lettura.

CE Power Management

2011-09-02T09:14:00.001-07:00

Chi sviluppa su device basati su Windows CE di tipo industriale sa bene che il controllo del livello della batteria è una dei criticità da affrontare. Purtroppo il .NET CF per Windows CE non offre nessuna classe per il monitoraggio di tale risorsa. Ovviamente il sistema operativo mette a disposizione un set di API apposite per questo problema. Nel codice associato al post trovare una classe C# che si fa carico di gestire queste API. Oltre al codice della classe trovate anche un programma di esempio che ne dimostra l’utilizzo, in dettaglio:

   1: private void Form1_Load(object sender, EventArgs e)   2: {   3:     PwdManagment = new PowerManagement();   4:     5:     PwdManagment.PowerNotify += PwdManagment_PowerNotify;               6: }

   1: private void btnStart_Click(object sender, EventArgs e)   2: {   3:     PwdManagment.StartNotifications();   4:     lblNotification.Text = "StartNotifications...";   5: }

   1: private void btnStopNotification_Click(object sender, EventArgs e)   2: {   3:     PwdManagment.StopNotifications();   4:     lblNotification.Text = "StopNotifications...";   5: }

   1:     2: private void PwdManagment_PowerNotify(object sender, EventArgs e)   3: {   4:     try   5:     {   6:         // get power info element   7:         //   8:         var powerInfo = PwdManagment.GetNextPowerInfo();   9:    10:         if ( powerInfo.Message != PowerManagement.MessageTypes.Status )  11:             return;  12:    13:         this.BeginInvoke(new Action<PowerManagement.PowerInfo>(UpdateLevels), powerInfo);  14:     }  15:     catch(Exception ex)  16:     {  17:         MessageBox.Show(ex.ToString());  18:     }  19: }

Fez Spider Kit for .NET Gadgeteer

2011-07-30T01:36:00.001-07:00

Finalmente, dopo un po' di attesa, iniziano ad arrivare le prime mainboard basate su .NET gadgeteer. Come sempre GHI non delude!!! Ecco il link al kit, sto già compilando il modulo d’ordine!!!

SQL Server 2008 R2 – Error 2337 su Virtual PC

2011-07-29T00:39:00.001-07:00

In questi giorni sto preparando un po' di macchine virtuali con Windows Virtual PC. Durante l’installazione di SQL Server 2008 R2, montando direttamente l’immagine .iso nella macchina virtuale, a circa metà installazione ricevo l’errore 2337! Cercando un po' scopro che è un problema della gestione del file .iso di Virtual PC. Soluzione ? Montare il cd fisico o estrarre i files sulla macchina virtuale o share condivisa e ripetere l’installazione!

TFS, OData & Windows Phone 7

2011-07-21T05:02:00.001-07:00

In questo post trovate un client WP7 per la consultazione di TFS tramite TFS OData Service.

Agile Project Management in Visual Studio ALM V.Next

2011-07-21T03:16:00.001-07:00

Per chi vuole avere un’idea delle features inerenti “agile project management” che arriveranno nella prossima versione di TFS questo post ne da un’anticipazione. Buona lettura a tutti.

.NET Micro FW–Progetti in CodePlex

2011-07-12T06:42:00.001-07:00

Nella versione 4.2 del Micro FW, attualmente in beta, vi sono numerosi contributi da parte della comunità. In questo post sono riassunti i vari progetti che stanno “comparendo” su codeplex in modo parallelo. Ovviamente questa è solo una sintesi del materiale che potete trovare ma sicuramente sono i più accattivanti.

.NET Micro FW 4.2–Porting Kit

2011-06-21T13:53:00.001-07:00

Dopo appena qualche settimana dall’uscita della versione beta del NETMF 4.2 arriva un altro grande contributo direttamente dalla community. Questo contributo è il PKStudio (Alexandr Surkov e Igor Kiselev).

Che dire, splendido lavoro !!!

Windows Embedded Compact 7–ShowCase

2011-06-20T05:02:00.001-07:00

Volevo segnalare una serie di video di self training su Windows Embedded Compact 7. Si va dall’architettura, alle nuove features fino alle tecniche avanzate di debugging, passando per la creazione completa di un’immagine del sistema operativo. Buona visione a tutti.

“Professional Windows Embedded Compact” 7

2011-06-20T04:55:00.001-07:00

In arrivo il libro della Wrox dedicato a Windows Embedded Compact 7, gli autori sono Samuel Phung, David Jones e Thierry Joubert. L’uscita è prevista per settembre ma è già possibile acquistarlo in “pre order”.

Android Open Accessory & .NET MicroFW

2011-06-20T04:50:00.001-07:00

La piattaforma Android 3,1 (backport anche per Android 2.3.4) introduce il supporto accessori Open Android, che consente ad un hardware esterno USB di interagire con un dispositivo Android in una speciale modalità "accessorio". In questo link potete trovare una interessante soluzione per far parlare i due “mondi”.

Codice e Slide della sessione: “Introduzione a .Net Micro Framework”

2011-06-16T09:43:00.001-07:00

Ecco disponibili al download, il codice e le slide del XeDotNet community meeting che ho tenuto il 10 Giugno 2011 dal titolo Introduzione a .Net Micro Framework

“Il Micro Framework è un’infrastruttura per microcontrollori a 32 bit i cui vantaggi principali consistono nel fornire una ricca API indipendente dall’hardware, un’efficiente controllo sulle periferiche del microcontrollore, una runtime che gestisce aspetti che vanno dal bootstrap al debug del firmware, un ricco ambiente di sviluppo quale Visual Studio, il supporto all'emulazione del dispositivo oltre, naturalmente, a innumerevoli altri vantaggi intrinseci del Framework .NET."

Volevo porgere un ringraziamento a tutte le numerose persone presenti al meeting ed allo staff di XeDotNet per il supporto tecnico, morale ed organizzativo della sessione e per l’opportunità che mi è stata data.

Introduzione a .NET Micro Framework

2011-06-01T07:43:00.001-07:00

Venerdì 10.06.2011 terrò un meeting con XeDotNet su questo argomento.

“Il Micro Framework è un’infrastruttura per microcontrollori a 32 bit i cui vantaggi principali consistono nel fornire una ricca API indipendente dall’hardware, un’efficiente controllo sulle periferiche del microcontrollore, una runtime che gestisce aspetti che vanno dal bootstrap al debug del firmware, un ricco ambiente di sviluppo quale Visual Studio, il supporto all'emulazione del dispositivo oltre, naturalmente, a innumerevoli altri vantaggi intrinseci del Framework .NET. “

In questa sessione saranno esplorate le basi del .NET Micro Framework e le sue possibilità, in dettaglio:

Cos’è .NET Micro FW
Ambiente di compilazione
Device disponibili e relativi SDK
.NET MF Base Class Library
Accesso HW
Networking
Graphics e Graphics User Interface

L’incontro si terrà presso:

Novotel Castellana
Via Alfredo Ceccherini 21 - Venezia Mestre

Se siete interessati non potete mancare, per iscrizioni: clicca qui

Codice e Slide della sessione: “WCF & .NET Micro Framework – A real case”

2011-03-28T03:38:00.001-07:00

Ecco disponibili al download, il codice e le slide del XeDotNet community meeting che ho tenuto il 25 Marzo 2011 dal titolo WCF & .NET Micro Framework – A real case

“Con l’uscita della versione 4.0 di WCF e della versione 4.1 del .NET Micro FW i due mondi hanno la possibilità di parlarsi nativamente senza dover costruire sovrastrutture apposite. In questa sessione sarà affrontato un caso reale di utilizzo di WCF 4.0 con dispositivi basati su .NET Micro FW 4.1. L’utilizzo è bidirezionale, sarà mostrato come consumare servizi WCF da dispositivi e come gli stessi a loro volta possono mettere a disposizione servizi ricercabili e consumabili. La sessione si basa su un caso reale di utilizzo di cui verrà discussa sia l’architettura che le parti salienti del codice”

Volevo porgere un ringraziamento a tutte le numerose persone presenti al meeting ed in particolare ad Andrea Boschin per il supporto tecnico, morale ed organizzativo della sessione. Grazie ancora a XeDotNet per l’opportunità che mi è stata data.

WCF & .NET Micro FW

2011-03-22T15:02:00.000-07:00

Venerdì 25.03.2011 terrò un meeting con XeDotNet su questo argomento, in questa sessione verrà illustrato un caso reale di integrazione tra device e servizi WCF in entrambi i lati. Questi sono i devices che utilizzerò nella presentazione. Alla fine della stessa ci sarà anche una piccola sorpresa, vi aspetto numerosi.

L’incontro si terrà presso:

Novotel Castellana
Via Alfredo Ceccherini 21 - Venezia Mestre

Se siete interessati non potete mancare, per iscrizioni: clicca qui

.NET Micro Framework–Virtual meeting

2011-03-02T08:41:00.001-08:00

Nel cambio dal vecchio al nuovo host di XeDotNet erano andati persi i link delle registrazioni dei virtual meeting. Di seguito riporto il nuovo link della sessione che avevo tenuto:
.NET Micro Framework

Codice e slide della sessione “.NET Parallel Programming”

2011-02-28T04:46:00.000-08:00

Ecco disponibili al download, il codice e le slide del XeDotNet community meeting che ho tenuto il 25 Febbraio 2011 dal titolo .NET Parallel Programming

“La programmazione concorrente è notoriamente difficile, anche per utenti esperti. Microsoft con l'iniziativa Parallel Computing Initiative pone le basi sia per la costruzione di programmi paralleli sia per la creazione di una nuova generazione di applicazioni. In questa sessione verranno affrontati Elaborazione parallela, Programmazione concorrente, Miglioramento delle prestazioni, Debug delle applicazioni parallele, Analisi delle applicazioni parallele. Tali argomenti saranno esposti utilizzando C# e il .NET 4.0 con i relativi nuovi strumenti messi a disposizione da VS 2010 inerenti la programmazione parallela. “

Volevo porgere un ringraziamento a tutte le numerose persone presenti al meeting ed in particolare ad Andrea Boschin per il supporto “tecnico e morale” e la condivisione della sessione. Grazie ancora a XeDotNet per l’opportunità che mi è stata data.

XeDotNet–Prossimi Meeting

2011-01-27T00:15:00.001-08:00

28/01/2011 - Visual Studio Tips & Tricks

Davide Vernole - Visual Studio 2010 Template, Wizard.
Personalizzare la propria esperienza di utilizzo di Visual Studio 2010 per migliorare normalizzazione e produttività nel team di sviluppo. La sessione introdurrà i partecipanti all'uso di Template, Wizard e Add-In.>/p>
Marco Parenzan - Code Generation con con i templates T4 in Visual Studio
Uno degli strumenti meno pubblicizzati ma più utili in Visual Studio sono i templates T4. Strumenti come l'Entity Framework e ASP.NET MVC li hanno resi (forse) più diffusi. Come sono fatti? Come si usano? Cosa ci si può fare? Una carrellata di alcuni usi interessanti, dagli oggetti POCO a WPF, passando attraverso lo "scaffolding" e i Domain Specific Languages...

25/02/2011 - .NET Programming Tecniques

Mirco Vanini - .NET Parallel Programming
La programmazione concorrente è notoriamente difficile, anche per utenti esperti. Microsoft con l'iniziativa Parallel Computing Initiative pone le basi sia per la costruzione di programmi paralleli sia per la creazione di una nuova generazione di applicazioni. In questa sessione verrano affrontati Elaborazione parallela, Programmazione concorrente, Miglioramento delle prestazioni, Debug delle applicazioni parallele, Analisi delle applicazioni parallele. Tali argomenti saranno esposti utilizzando C# e il .NET 4.0 con i relativi nuovi strumenti messi a disposizione da VS 2010 inerenti la programmazione parallela.>/p>
Andrea Boschin - MEF Explained
Il Managed Extensibility Framework è un Dependency Container, introdotto recentemente nel framework, che consente di gestire facilmente la modularità delle applicazioni e il testing. Vedremo i concetti base di MEF, il suo utilizzo in alcuni casi pratici e l'integrazione con la più recente versione di Prism.

25/03/2011 - WCF 4.0 Unleashed

Davide Vernole - WCF 4.0 - What's new
Windows Communication Foundation 4 ha introdotto nuove funzionalità che facilitano o agevolano l'utilizzo di questa tecnologia in particolari scenari di utilizzo. La sessione sarà incentrata sulle novità della versione 4.0 e sul confronto con la versione 3.5
Mirco Vanini - WCF & .NET Micro FW – A real case
Con l’uscita della versione 4.0 di WCF e della versione 4.1 del .NET Micro FW i due mondi hanno la possibilità di parlarsi nativamente senza dover costruire sovrastrutture apposite. In questa sessione sarà affrontato un caso reale di utilizzo di WCF 4.0 con dispositivi basati su .NET Micro FW 4.1. L’utilizzo è bidirezionale, sarà mostrato come consumare servizi WCF da dispositivi e come gli stessi a loro volta possono mettere a disposizione servizi ricercabili e consumabili. La sessione si basa su un caso reale di utilizzo di cui verrà discussa sia l’architettura che le parti salienti del codice.

15/04/2011 - Smartphone & .NET

Davide Senatore - Total Smartphone Interoperability: A tale to interoperate between WCF, Windows Phone 7 and Android<
In un mondo dove la parola d'ordine è ""connected"", gli smartphone giocano un ruolo chiave. Sempre più siamo abituati ad interagire con l'informazione ovunque. Twitter, Facebook e servizi di vario genere, ormai consentono l'accesso attraverso dispositivi mobili. La parola chiave per rendere fruibili i nostri servizi? Interoperabilità. E' infatti chiaro che se un servizio non è interoperabile, si potrebbero precludere delle occasioni di marketing per determinati possessori di smartphone a vantaggio di altri. In questa sessione vedremo come realizzare un servizio WCF interoperabile, lo metteremo on line e svilupperemo due client che lo consumino: il primo per Windows Phone 7, ed il secondo per Android. Analizzeremo ambienti di sviluppo, tecniche, pro e contro degli approcci di ciascuna piattaforma, in una atmosfera di confronto produttivo.
Andrea Boschin - Programming with Reactive Extensions with .NET, Silverlight and WP7
Le reactive extensions consentono la gestione semplificata di ObservableCollections e di stream di dati. In questa sessione vedremo le caratteristiche di questa libreria, disponibile per .NET Framework, Silverlight e Windows Phone con una serie di esempi.

20/05/2011 - Programming DotNetNuke 5.0

Andrea Dottor - Sviluppare con DotNetNuke. Un framework sul framework
Sviluppare applicazioni, occupandosi delle sole funzionalità che vuole il cliente, senza doversi occupare anche del codice di infrastruttura può sembrare un'utopia, ma non è così. In questa sessione vedremo come DotNetNuke, che è un CMS (content management system) open source, permetta allo sviluppatore tutto ciò. DotNetNuke può essere visto come un framework sul framework, in grado di fornire allo sviluppatore funzionalità avanzate che permettono di aumentare la produttiva e al contempo di ridurne i tempi di sviluppo.
Davide Senatore - Fast and Furious DotNetNuke: Web App Development at the speed of light.
DotNetNuke: semplicemente il CMS più diffuso al mondo con più di 6.000.000 di download totali e 600.000 siti in produzione. In questa sessione vedremo come si possa affrontare la sfida di creare web applications utilizzando DNN come piattaforma di sviluppo. Valuteremo come creare moduli, come integrarli all'interno del CMS e come sfuttare le caratteristiche native della piattaforma a nostro vantaggio. Analizzeremo le nuove caratteristiche, l'integrazione con JQuery e Google Analytics, la personalizzabilità estrema e la produttività straordinaria che questa piattaforma mette a disposizione.

10/06/2011 - Test & Tools Track

Emanuele Delbono - Test Driving a MVVM Application
Test Driven Development è sempre più utilizzato ma gli esempi che si trovano sui blog sono spesso troppo astratti per poter essere applicati al lavoro di tutti i giorni. Durante la sessione vedremo come applicare il TDD per realizzare un'applicazione WPF basata sul pattern MVVM. Vedremo come grazie al TDD potremo risparmiare molto tempo di debug e di prove reali dell'applicazione aggiungendo test dopo test le funzionalità richieste.
Federico Degrandis - Sterling: un database per Silverlight e Windows Phone 7
Sterling è un database per Windows Phone 7 e Silverlight scritto da Jeremy Likness. Vedremo cos'è, come funziona e come lo possiamo utilizzare all'interno delle nostre applicazioni. Inoltre vedremo com'è possibile gestire alcune problematiche riscontrate su un progetto reale.

Unable to start debugging

2010-12-13T15:11:00.000-08:00

Alcuni giorni fa’ mi sono imbattuto in un problema abbastanza strano. Di colpo VS2008 non riusciva più a eseguire il debug di un’applicazione C++ su Windows CE riportando l’errore sibillino “unable to start debugging”. Come prima cosa ho incolpato il device che stavo utilizzando e sono passato su un altro tipo di device. Niente, stesso errore.

Dopo parecchi minuti spesi in rete per cercare qualche lume inizio a leggere un po’ di post che parlano di qualche effetto collaterale dovuto all’installazione di phone 7 SDK su VS2010.

In effetti, il codice su cui stavo cercando di eseguire il debug l’avevo scritto qualche mese fa, prima di installare tutto l’ambiente per windows phone 7. Cercando meglio nei post scopro che è legato proprio all’installazione di tale ambiente.

Soluzioni ? Disinstallare VS2010 e/o reinstallare VS2008 ? Sono da clienti e di certo non posso permettermi di fare una cosa del genere!

Scavando meglio in rete trovo altre persone che hanno lo stesso problema. Umm, nessuna soluzione se non reinstallare i vari ambienti di sviluppo.

Alla fine trovo un post di Raffaele Limosani che spiega come effettuare un work-around “temporaneo” ed “accettabile”:

1. rinominare la cartella C: \ Program Files \ Microsoft Visual Studio 10.0 \ SmartDevices \ Debugger \ target \ wce400 \ ARMV4i in .. \ armv4i_temp

2. copiare la cartella C: \ Program Files \ Microsoft Visual Studio 9.0 \ SmartDevices \ Debugger \ target \ wce400 \ ARMV4i all'interno del percorso di Visual Studio 2010.

Funziona !!!

Comunque, come sempre di fronte a certe cose, non penso servano commenti.

Codice e slide della sessione “Da Windows Mobile 6.5 a Windows Phone 7”

2010-12-06T05:12:00.001-08:00

Ecco disponibili al download, il codice e le slide del XeDotNet community meeting che ho tenuto il 03 Dicembre 2010 dal titolo Da Windows Mobile 6.5 q Windows Phone 7.

In questa sessione affronteremo le differenze principali tra le due versioni del s.o. Windows Mobile esplorando sia gli strumenti di sviluppo che le architetture. Verranno illustrati i punti in comune e non per preparare i nostri applicativi al passaggio verso il nuovo s.o. Nella sessione saranno esplorati poi i dettagli dell'architettura su cui si basa il nuovo s.o. Windows Phone

Volevo porgere un ringraziamento a tutte le persone presenti al meeting ed in particolare ad Andrea Boschin per il supporto “tecnico e morale” e la condivisione della sessione. Grazie ancora a XeDotNet per l’opportunità che mi è stata data.

Pyxis 2.0 – an Operating Environment for NETMF

2010-11-30T13:48:00.001-08:00

Vedere per credere!!!

XE.NET: Mobile Track

2010-10-22T05:26:00.001-07:00

Da Windows Mobile 6.5 a Windows Phone 7 Series
In questa sessione affronteremo le differenze principali tra le due versioni del s.o. Windows Mobile esplorando sia gli strumenti di sviluppo che le architetture. Verranno illustrati i punti in comune e non per preparare i nostri applicativi al passaggio verso il nuovo s.o. Nella sessione saranno esplorati poi i dettagli dell’architettura su cui si basa il nuovo s.o. Windows Phone.
Speaker: Mirco Vanini – Senior Consultant

Creare applicazioni per Windows Phone 7 Series con Silverlight
In questa sessione affronteremo lo sviluppo con Windows Phone 7, con particolare riguardo alla realizzazione di applicazioni con Silverlight, lo strumento principale per lo sviluppo su questo nuovo dispositivo. La sessione indicherà come predisporre l'ambiente di sviluppo, quali sono gli strumenti di sviluppo e le basi da cui iniziare.
Speaker: Andrea Boschin (MVP Silverlight)

Data: Venerdì 3 Dicembre 2010
Ore: 19.30
Luogo: Novotel Venezia Mestre Castellana – Via Alfredo Ceccherini 21 – 30174 Venezia Mestre

Iscrizione

XE.NET: Virtual Meeting–F#

2010-10-22T05:24:00.001-07:00

Iniziare con F#
In Visual Studio 2010 è apparso un nuovo linguaggio: F#. Cos'è, da dove nasce, come si scrive in F#. E perchè tanti lo stanno apprezzando più di C#...
Speaker: Marco Parenzan

Registrazione: 21:00:00
Inizio: 21:30:00
Località: Live Meeting online

Iscrizione

XE.NET: Microsoft Community Tour 2010/2–17.11.2010

2010-10-22T05:21:00.001-07:00

09:30 – Keynote
Speaker: Lorenzo Barbieri - Microsoft Developer Evangelist

10:10 - Windows Phone 7: Sviluppare applicazioni per il Marketplace
In questa sessione vedremo lo sviluppo di applicazioni per il Marketplace di WP7, con esempi presi da applicazioni reali.
Speaker: Lorenzo Barbieri - Microsoft Developer Evangelist

11:35 - Make javascript Simple with jQuery
La costante richiesta di interfacce rich nella applicazioni internet sta spingendo sempre più l'adozione di librerie Javascript che facilitino la programmazione con questo linguaggio che per molti versi è ostico, almeno quanto flessibile. jQuery ormai si è guadagnato la palma di migliore e maggiormente adottata libreria, con un core molto snello e una serie di plugin di grande efficacia che aiutano molto il programmatore quando l'ambiente non consente l'uso di più moderni strumenti RIA. In questa sessione affronteremo jQuery, cercando di comprendere i principi che stanno alla base del suo funzionamento vedendoli applicati in un piccolo gioco sviluppato in appena 100 righe di codice. Vedremo come jQuery porti sollievo a molti dei problemi di Javascript e perchè no anche quali sono i confini entro cui la sua efficacia viene meno.
Speaker: Andrea Boschin - MVP Silverlight

14:15 - Windows Azure: Getting Started
Iniziamo a mettere la testa tra le nuvole esplorando l'offerta Microsoft per il Cloud Computing. Windows Azure, SQL Azure e Windows Azure AppFabbric offrono allo sviluppatore un modo nuovo di disegnare le proprie applicazioni garantendo maggior disponibilità, scalabilità e manutenibilità a costi inferiori rispetto a quanto ottenibile con approcci di sviluppo e distribuzione tradizionali. Cosa sono e come si utilizzano sono gli aspetti su cui si baserà questa sessione con l'intento finale di mostrare ai partecipanti come iniziare a utilizzare questa piattaforma.
Speaker: Davide Vernole – MVP Visual Studio ALM

15:25 - XBAP Application with WPF 4.0
Le applicazioni browser XAML (XBAP) combinano le funzionalità delle applicazioni Web e delle applicazioni rich client. In modo analogo alle applicazioni Web, le applicazioni XBAP possono essere distribuite in un server Web e avviate da Internet Explorer o Firefox. Come le applicazioni rich client, le applicazioni XBAP possono trarre vantaggio dalle funzionalità di WPF. In questa sessione vedremo un'introduzione allo sviluppo di applicazioni XBAP e vengono illustrate le differenze esistenti tra lo sviluppo di questo tipo di applicazioni e lo sviluppo di applicazioni rich client standard.
Speaker: Davide Senatore - MVP Client App Dev

16:50 - Potenzialità e benefici di ASP.NET MVC
ASP.NET MVC è un framework sviluppato da Microsoft che permette lo sviluppo di applicazioni web utilizzando il pattern Model-View-Controller. Questo pattern si propone di apportare alcuni benefici: maggiore controllo del markup della pagina, URL più leggibili, facilità di integrazione con librerie javascript, chiara separazione dei ruoli/responsabilità tra layer, testabilità e manutenzione del codice... In questa sessione cercheremo di capire quali siano gli effettivi vantaggi che ASP.NET MVC porta agli sviluppatori, e quindi capire, con un occhio pratico, quali reali benefici si abbiano nell'adottare questa tecnologia.
Speaker: Andrea Dottor - MVP ASP.NET

Registrazione: 09:00:00
Inizio: 09:30:00
Località: Hotel Holiday Inn, Marghera (VE)

Iscrizione

XE.NET: Quality Track

2010-10-22T05:06:00.001-07:00

Microsoft Test Manager
Pianificare, testare e tracciare le attività di testing non è mai stato così completo. Visual Studio 2010 introduce un nuovo approccio alle attività compiute dai tester di applicazioni facilitando la stima di questa delicata parte del ciclo di vita del software. Durante la sessione impareremo a conoscere un nuovo compagno di avventura, Microsoft Test Manager (MTM), in grado di risolvere molti dei problemi che hanno da sempre afflitto il processo di test e bug fixing. Perfettamente integrato con Team Foundation Server 2010 è destinato ad essere uno strumento indispensabile per la creazione di software di qualità.
Speaker: Davide Vernole (MVP Visual Studio ALM)

Ottimizzazione di un'applicazione ASP.NET
Nelle applicazioni di tutti i giorni, spesso ci scontriamo con problemi di performance, oppure siamo alla ricerca di un miglioramento che possa rendere più reattiva la nostra applicazione. In questa sessione vedremo come grazie all'utilizzo della cache, session, ed altri strumenti, possiamo ottimizzare il nostro sito fornendo un feedback migliore all'utente. Con esempi pratici, vedremo il beneficio di come semplici accortezze potranno migliorare notevolmente un'applicazione. Cache, session, IIS 7, routing...saranno i principali argomenti trattati.
Speaker: Andrea Dottor (MVP ASP.NET)

Data: Giovedì 4 Novembre 2010
Ore: 19.30
Luogo: Novotel Venezia Mestre Castellana – Via Alfredo Ceccherini 21 – 30174 Venezia Mestre

Informazioni - Iscrizioni

A volte ritornano…

2010-10-17T06:59:00.001-07:00

Dopo molti mesi ritorno a scrivere sul blog, nuovo blog e nuova avventura. Per una serie di circostanze sia familiari sia lavorative non ho più curato quest’attività, non ultimo la chiusura inattesa e non conosciuta del blog ugimobile che mi ospitava. Grazie all’aiuto di Andrea sono riuscito a recuperare un po’ di articoli che avevo scritto nel tempo, perdendone tanti tanti altri. Sinceramente non capisco il comportamento di alcune persone e le motivazioni che hanno portato alla chiusura di ugimobile, ma questa è un’altra storia. Bene non mi resta che tirarmi su le maniche e riiniziare a scrivere.

.NET Micro Framework 4.0 Download

2010-10-17T06:50:00.001-07:00

Alcuni giorni fà è stata rilasciata la versione 4.0 del .NET Micro Framework. Questa è la prima release dopo il trasferimento del gruppo sotto la Developer Division. La versione ha un certo numero di nuove funzionalità. In questo link potete trovare la lista completa.

Il donload è diviso in diversi pacchetti, in dettaglio:

Penso che sia la risposta più “concreta” a chi dava il progetto Micro FW sul viale del tramonto.

Microsoft Silverlight for Windows Embedded

2010-10-17T06:49:00.001-07:00

Con il rilascio di Windows CE SR3 una delle features più interessanti è la disponibilità di Silverlight for Windows Embedded. Attenzione è un UI framework che si basa su API Win32/nativo e non su codice gestito.

WiFi 802.11 Wireless for .NET Micro FW

2010-10-17T06:48:00.003-07:00

GHI ha annunciato il primo modulo hardware “Micro Famework WiFi Expansion” che rende disponibile una connessione WiFi su .Net Micro FW 3.0. Il nuovo modulo supporta WEP, WPA, WPA2 attraverso la cifratura hw AES e RSA. il modulo è disponibile per i seguenti prodotti di GHI: ChipworkX ed Embedded Master

“Expert .NET Micro Framework” – Second edition

2010-10-17T06:48:00.001-07:00

E’ disponibile la seconda edizione del libro “Expert .NET Micro Framework” di Jens Kühner. (Apress – Amazon)

VS2008: Errore connessione a un dispositivo Windows CE senza ActiveSync

2010-10-17T06:43:00.001-07:00

Chi sviluppa su device Windows CE avrà sicuramente letto ed utilizzato la procedura per stabilire una connessione verso un dispositivo Windows CE senza ActiveSync riportata nel seguente articolo (Procedura stabilire una connessione a un dispositivo Windows CE senza ActiveSync). Niente da dire, anzi se non che dopo l'installazione di VS 2008 sullo stesso PC in cui è installato VS 2005 ogni tentativo di stabile una connessione verso il device riporta i seguenti errori:

VS 2005 Connection failed:0x8973151A

VS 2008 Connection failed: The version of Comman client running on the device is incompatible with the desktop. Boostrap the device with desktop compatible device binaries and try connectiong again.

Dopo alcuni tentativi e ricerche infruttuose su internet ho trovato il bandolo della matassa. La parte inerente il device emulator di VS 2008 non è installabile side by side, in altre parole la versione di VS 2005 viene sovrascritta da quella di VS 2008.

Per ovviare il problema basta copiare nel dispositivo i files aggiornati da VS 2008 contenuti nel percorso.

C: \Programmi\File comuni\Microsoft Shared\CoreCon\1.0\Target\wce400\<CPU>

Embedded Master Development System

2010-10-17T06:42:00.003-07:00

Finalmente è arrivata!

Alla fine mi sono deciso a comprarla (GHI Electronics - Embedded Master Development System), l'ho aperta da qualche giorno e devo dire che il rapporto qualità prezzo mi ha soddisfatto. La confezione si presenta scarna ma il "contenuto" è sicuramente all'altezza delle aspettative.

Dopo l'installazione del .NET Micro Framework ho ovviamente installato EmbeddedMasterSDK della scheda, non presente nella confezione ma scaricato dal sito. Il setup è andato al primo colpo senza intoppi e/o sorprese. La documentazione e gli esempi forniti nel SDK sono sufficientemente completi, anche se come al solito la documentazione non è mai abbastanza :)

Dopo un pò di prove con il .NET Micro Framework Deployment Tool sono riuscito a stabilire la connessione tra il PC e la scheda. L'unico intoppo l'ho trovato nell'installazione del Virtual Com Port Drive per la parte di debug, dopo vari tentati di collegamento andati a vuoto ho scoperto che dovevo cambiare il tempo di latenza (da 16 msec a 1 msec) nell'impostazioni della USB Serial Port.

Ho scaricato poi le varie patch sia del TinyBooter e del TinyCLR dal sito del costruttore della scheda e le ho installate senza grossi problemi. Gli steps per l'upgrade sono spiegati in dettaglio nella documentazione del SDK.

Ho poi caricati gli esempi forniti con SDK, compilati, distribuiti e debbugati direttamente sulla scheda. Anche l'emulatore fornito con SDK non è malaccio, tanta scena ma manca tutta la gestione degli I/O della scheda. Sarebbe stato comodo avere un sistema di emulazione degli I/O senza andare per forza su HW

Bene, adesso sono finalmente pronto a scrivere il mio primo programma su .NET Micro FW.

Expert .Net Micro Framework

2010-10-17T06:42:00.001-07:00

Dopo aver acquistato il kit di sviluppo GHI Electronics - Embedded Master Development System ho pensato bene di acquistare un libro dedicato al .NET Micro Framework. Devo dire che sul mercato non c'è tantissimo e alla fine ho deciso di acquistare il libro di Jens Kühner - Expert .Net Micro Framework. Devo dire la verità, sin dall'inizio mi è piaciuto.

Essendo un amante dei libri cartacei ricevere un libro con copertina rigida, rilegato in modo che non si sfaldi dopo le seconda lettura e stampato su della carta di qualità discreta fa solo che piacere. Oltre all'impressione "estetica" e "fisica" devo dire che è un buon libro, strutturato bene, che prende per mano il lettore e lo porta ad esaminare le varie parti del .Net Micro FW.

Si parte dalla genesi del Micro FW, ne descrive le varie parti costituenti e fà una rapida carellata sui kit di sviluppo attualmente disponibili. Questa è solo l'introduzione del libro, poi si passa alla "sostanza". Descrive in modo accurato la gestione delle varie porte hardware, il threading disponibile, la crittografia, la comunicazione via socket, per poi arrivare al DPWS (Device Profile for Web Service). Devo dire che forse è il capitolo che mi ha entusiasmato di più, anche se per poterlo utilizzare si deve scrivere un bel pò di codice.

Si arriva poi alla gestione della localizzazione e sopratutto alla parte di gestione grafica e di user interface. Anche questo capito è degno di nota sopratutto per i semplici ma efficaci esempi riportati.

Ultima parte ma non per questo meno importante è la gestione dell'emulazione hardware e dei relativi componenti. Ben scritta e documentata sopratutto negli esempi di implementazione di componenti per l'emulazione hardware.

Che dire ? Sicuramente è un libro ben fatto ed indispensabile per chi vuole partire ed approffondire lo sviluppo con .Net Micro FW.

Buona lettura a tutti

Technorati Tag: book,.Net Micro FW

AddHeader - ISAPI

2010-10-17T06:41:00.001-07:00

Durante lo sviluppo di una ISAPI filter mi è capitata la necessità di creare una variabile server IIS durante la gestione della notifica SF_NOTIFY_AUTHENTICATION.

Peccato che in questa notifica il parametro pvNotification passato da IIS sia di tipo PHTTP_FILTER_AUTHENT e non vi sia il modo di recuperare la struttura di tipo PHTTP_FILTER_PREPROC_HEADERS che contiene il metodo AddHeader.

Dopo un po' di tentativi ho percorso questa strada:

1. Definisco i seguenti typedef e define

   1: #define MYISAPI_HEADER       "MYISAPI-HEADER:"   2: #define HTTP_MYISAPI_HEADER    "HTTP_MYISAPI_HEADER"   3:     4: typedef BOOL (WINAPI * PAddHeader)    5:               (   6:                 struct _HTTP_FILTER_CONTEXT * pfc,   7:                 LPSTR                         lpszName,   8:                 LPSTR                         lpszValue   9:               );

2. Nella notifica SF_NOTIFY_PREPROC_HEADERS creo una variabile server che contiene l'indirizzo del metodo AddHeader come nel codice seguente

   1: TCHAR szTmp[256];   2: sprintf_s(szTmp, sizeof(szTmp), "%08lx", ((PHTTP_FILTER_PREPROC_HEADERS)pvNotification)->AddHeader);   3: if(((PHTTP_FILTER_PREPROC_HEADERS)pvNotification)->HttpStatus == 0)   4: {   5:     TCHAR szValue[256];   6:     DWORD dwValue = sizeof(szValue);   7:     8:     *szValue = 0;   9:     ((PHTTP_FILTER_PREPROC_HEADERS)pvNotification)->GetHeader(pfc, MYISAPI_HEADER, szValue, &dwValue);  10:    11:     if(*szValue == 0)  12:         ((PHTTP_FILTER_PREPROC_HEADERS)pvNotification)->AddHeader(pfc, MYISAPI_HEADER, szTmp);  13: }  14: return(SF_STATUS_REQ_NEXT_NOTIFICATION);

3. Nella notifica SF_NOTIFY_AUTHENTICATION utilizzo la variabile server creata precedentemente nella notifica SF_NOTIFY_PREPROC_HEADERS, eseguo il cast su il pointer a funzione definito nel typedef e la richiamo per impostare una nuova variabile server

   1: TCHAR szValue[256];   2: DWORD dwValue = sizeof(szValue);   3:     4: *szValue = 0;   5: pfc->GetServerVariable(pfc, HTTP_MYISAPI_HEADER, szValue, &dwValue);   6: if(*szValue != 0)   7: {   8:     try   9:     {  10:         PAddHeader pHeader = (PAddHeader)strtoul(szTmp, NULL, 16);  11:         if(pHeader)  12:            (pHeader)(pfc, MYISAPI_USER_ID_LDAP, W2A(pszUidLdap));      13:     }  14:     catch(CException *e)  15:     {  16:         DumpException(e)  17:         e->Delete();  18:     }  19: }

Funziona :)

System Meter Chart PDA

2010-10-17T06:40:00.001-07:00

Durante lo sviluppo di un progetto mi sono imbattuto nella necessità di realizzare un controllo per PDA che rapresentasse l'andamento di un valore nel tempo. Come "fonte di ispirazione" ho utilizzato la visualizzazione della "cronologia utilizzo CPU" del task manager.

Dopo un pò di lavoro sono riuscito a "confezionare" un controllo che ne mima il comportamento. Ho esteso un pò il grafico prodotto permettendo la gestione dello stesso sia tramite line che stick.

Il controllo utilizza un sistema di "Double Buffering" con una bitmap offline in cui viene effettivamente disegnato il grafico. Questo ovviamente per evitare il flickering che inevitabilmente sarebbe comparso.

Tutto questo perchè su .Net CF i controls non supportano il double buffer nativamente, per esempio in .Net è possibile attivarlo tramite il seguente codice:

   1: public void EnableDoubleBuffering()   2: {   3:    // Set the value of the double-buffering style bits to true.   4:    this.SetStyle(ControlStyles.DoubleBuffer |    5:                  ControlStyles.UserPaint |    6:                  ControlStyles.AllPaintingInWmPaint,   7:                  true);   8:    this.UpdateStyles();   9: }

Di seguito riporto un print screen del programma demo e il link in cui trovare il medesimo.

Sorgenti Progetto di esempio

Buone "misurazioni" a tutti :)

ActiveSync - GuestOnly

2010-10-17T06:39:00.003-07:00

Chi collega e scollega device tutto il giorno al proprio PC, si sarà chiesto se vi è la possibilità di disattivare la richiesta di creazione relazione da parte di ActiveSync. Sicuramente l'impostazione di relazione va bene per sincronizzare mail, appuntamenti, ecc. ma non sicuramente per le sessioni di debug.

Ecco allora la chiave del registry da modificare:

[HKEY_LOCAL_MACHINE\Software\Microsoft\Windows CE Services]
"GuestOnly"=dword:1

Ovviamente per ripristinare la richiesta di relazione basta impostare "GuestOnly a 0 (zero)

Community Meeting - .NET Compact Framework

2010-10-17T06:39:00.001-07:00

Volevo ringraziare tutti i partecipanti, Xe.Net ed 1nn0va per l'opportunità che mi hanno concesso. A breve metterò in linea il materiale del meeting.

Come sempre un ringraziamento "speciale" ad Andrea Boschin per il supporto materiale e morale.

DLL - Import

2010-10-17T06:38:00.001-07:00

Se dovete collegare codice nativo e/o Win32 API a C# / VB.NET consiglio vivamente questo sito.

System Meter Chart – .Net Micro Framework

2010-10-17T06:37:00.001-07:00

Finalmente in questi giorni di “festa” sono riuscito a trovare qualche ora di calma da famiglia, figlie, clienti, rogne, ecc. per effettuare il porting del controllo System Meter Chart da .NET Compact Framework (CF) a .NET Micro Framework (MF). Questa è stata una buona occasione per “toccare con mano” le diversità tra i due ambienti per quello che riguarda la progettazione di user control. Il .NET MF supporta una versione ridotta (molto) di WPF e la gestione / progettazione dei controlli ovviamente è diversa tra i due ambienti. Nel caso specifico (.NET MF) ho implementato un Control (UIElement) che si espone come oggetto WPF.

Nelle applicazioni MF con presentation esistono due thread, il primo creato del programma per la gestione degli I/O, periferiche, ecc. mentre il secondo è creato ed utilizzato internamente dal CLR per le varie operazioni di UI (ridisegno degli elementi di UI come i controlli, le finestre, ecc.). Questo secondo thread è chiamato anche Dispatcher e il suo scopo è quello di accedere in modo “sicuro” ai vari elementi della UI. Per maggiori informazioni vi consiglio di leggere 'Using the Dispatcher’.

L’esempio di utilizzo del controllo usa un timer per l’assegnazione di valori random da 0 a 100. Essendo il timer asincrono rispetto all’interfaccia utente, per le operazioni di invalidate interne del controllo, è necessario chiamare BeginInvoke per far si che il controllo grafico sia acceduto dal thread principale. La scelta di BeginInvoke è preferibile rispetto a Invoke così da poter liberare il thread del timer al più presto senza attendere il termine dell’esecuzione del gestore dell’evento.

L’esempio utilizza i 5 tasti presenti nell’emulatore del .NET MF, in dettaglio:

Tasto Up abilita la visualizzazione in “Stick Mode”
Tasto Down abilita la visualizzazione in “Line Mode”
Tasto Left abilita la visualizzazione in “NoGrid”
Tasto Right abilita la visualizzazione in “Grid”
Tasto Select abilita / disablita la visualizzazione del Gradient

Di seguito riporto alcune immagini delle modalità supportate dal controllo

Non nego che sono sempre più entusiasta del MF, penso solo a quanto codice avrei dovuto scrivere per realizzare lo stesso controllo su un’altra tipo di scheda non MF magari con un compilatore C++ proprietario. Seconda osservazione, la portabilità del codice da una piattaforma MF all’altra, infatti nell’esempio non ho utilizzato nulla di proprietario della mia scheda GHI ma solo chimate “standard” del MF 3.0. Come ultimo punto vorrei rimarcare l’integrazione del MF con Visual Studio, si riesce a sviluppare ed eseguire il debugging dell’applicazione sia con l’emulatore che direttamente sulla scheda collegata via USB. Questo permette l’analisi sotto debugger di scenari che difficilmente sarebbero ripetibili tramite un emulatore e con una serie di comodità come solo i progammatori di Visual Studio sono abituati. Ovviamente le schede che supportano MF non sono schede su cui la battaglia si gioca sui centesimi ma quello che da a disposizione MF ripaga anche il relativo costo.

In questo link potete scaricare lo zip dei sorgenti del programma di esempio.

GDI – Leak – WinCE – C#

2010-10-17T06:36:00.001-07:00

Suona strano avere dei memory leak in codice gestito ma sono molto più frequenti di quello che si possa pensare. Alcune settimane fà ho tenuto una sessione di code review presso un mio cliente e ho speso alcuni giorni a sistemare diversi memory leak su una programma scritto in C# per Windows CE.

Quello che bisogna tenere a mente che tutti gli oggetti GDI (Bitmap, Font, Brush, Pen, ecc.) di C# in realtà sono dei wrapper sopra oggetti Win32. Tali oggetti sono referenziati tramite Handle e devono essere rilasciati. Il GC non lo fà per voi in modo automatico perchè semplicemente non li può gestire. Sopratutto nelle applicazioni mobile, in cui le risorse sono limitate, bisogna porre particolare attenzione a questo.

Durante la sessione di debug ho utilizzato questo tool (GDIView) che mi ha aiutato a verificare quali handle non venivano rilasciati.

Alcuni consigli pratici:

Richiamare sempre il Dispose di tutti gli oggetti grafici utilizzati, meglio ancora usare sempre la keword “using” per richiamare sempre in modo implicito il Dispose, esempio:

   1: SolidBrush fillBrush = new SolidBrush(Color.White);   2: graphImage.FillRectangle(fillBrush, 0, 0, UI_CLIENT_WIDTH, UI_HEIGHT);   3: fillBrush.Dispose();   4:     5: // or   6:     7: using(SolidBrush fillBrush = new SolidBrush(Color.White))   8: {   9:     graphImage.FillRectangle(fillBrush, 0, 0, UI_CLIENT_WIDTH, UI_HEIGHT);  10: }  11:  

Quando si riassegna una Bitmap assicurarsi che l’oggetto precedente sia deallocato, esempio:

   1: // wrong   2: picCapture.Image = new Bitmap(32, 32);   3:     4: // good   5: if(picCapture.Image != null)   6:     picCapture.Image.Dispose();   7: picCapture.Image = new Bitmap(32, 32);

Quando si utilizza una Image contenuta in una ImageList è bene ricordare quanto esposto su MSDN: “The returned bitmap is a copy of the original image and should be disposed of using the Image.Dispose method.”. In altre parole tutte le get da una ImageList clonano una nuova immagine che deve essere rilasciata tramite un Dispose!
Quando si utilizzano direttamente le funzioni native Win32 porre attenzione se queste ritornano una nuova istanza di una risorsa in memoria. Leggere attentamente la loro documentazione!
Ogni volta che si alloca memoria tramite funzioni native Win32 è vostra responsabilità deallocarla.
Quando si crea un nuovo oggetto non gestito, salvare il riferimento (handle) in una variabile non accessibile dall’esterno. Se per qualsiasi motivo il riferimento viene sovrascritto non sarà più possibile deallocare correttamente la risorsa non gestita.