Mobile

Brutto bug (corruzione dati) in SQL Server Compact per Mobile

Raffaele Rialdi — Thu, 18 Dec 2008 22:04:19 GMT

Il problema che ho scoperto poco fa (con non poca fatica) accade in SQL Server Compact 3.5 per Mobile e non l'ho testato nelle altre edizioni.

Il bug è che l'ordine dei parameters non viene più considerato e i parametri vengono "randomizzati". Di conseguenza potreste ottenere un errore perché il tipo del parameter è invalido oppure l'inversione dei dati in query o in aggiornamento!

I fatti:

Applicazione fatta e funzionante per SQL Mobile (quello di VS2005 tanto per intenderci)
Ricompilato con VS2008 senza modifiche di sorgente
Problema 1. È obbligatorio aggiornare i device con SQL Compact Mobile 3.5 perché la versione installata con VS2008 non permette di fare diversamente.
Deploy di SQL Compact 3.5
Deploy dell'applicazione
Problema 2. Bug che inverte i parametri di un command

In SQL Mobile 2005 le query dovevano essere scritte con i placeholder "?" stile oledb.

In SQL Compact 3.5 le qury possono essere scritte con i named parameter.

Peccato che il listato per SQL Mobile mi ha invertito due parametri di una query. La cosa strana è che il bug accade su PocketPC 2003 CE 4.2 e non su PocketPC con CE 5.0.

Attenzione quindi perché il bug non significa errore di runtime ma è silente! In pratica sul DB possono finire due dati in ordine invertito solo perché sono dello stesso tipo.

Mia personale raccomandazione: cambiare tutte le query in modo che usino i named parameter in SQL Server Compact 3.5 a prescindere dall'edizione.

Compact Framework, PowerToys e gli emulatori

Raffaele Rialdi — Sun, 02 Mar 2008 14:59:17 GMT

Voglio ringraziare Alex Feinman per l'illuminante spiegazione su come avviare RTF Host sugli emulatori di Windows Mobile.

Seguendo infatti passo-passo la procedura indicata nei power toys, non si riesce ad aggiungere un "TCP Device" ottenendo invece l'errore seguente.

Riporto perciò la traduzione della procedura che Alex Feinman ha pubblicato sul proprio blog:

L'errore deriva dal fatto che gli emulatori di default usano il trasporto DMA (DeviceDMA.dll), perciò RTF non seleziona il trasporto corretto. Per poter eseguire la procedura "Add TCP Device" la procedura è la seguente:

1. Avviare l'emulatore usando il Device Emulator Manager
2. Configurare una connessione di rete e il folder condiviso mappato sulla storage card.
3. Copiare il seguente file nella storage card:
C:\Program Files\Common Files\microsoft shared\CoreCon\1.0\Target\wce400\armv4i\TCPConnectionA.dll"
4. Usando il file explorer dell'emulatore, aprire la cartella \Windows\Corecon1.1
Se la cartella non fosse presente, collegarsi con l'emulatore da Visual Studio almeno una volta.
5. Lanciare ClientShutdown (a seguito del quale verrà creata una nuova cartella che ha per nome un guid)
6. Copiare \Storage\Card\TcpConnectionA.dll in \Windows
7. Aprire la cartella \Windows e cancellare DeviceDMA.dll
Il file risulta occupato solo se non si è lanciato ClientShutdown precedentemente
8. Aprire la cartella \Windows\Corecon1.1 e lanciare ConmanClient.exe
9. Lanciare RTF Host

La procedura non è affatto ovvia e purtroppo non è documentata in MSDN. Ad ogni modo avviare RTF Host su un emulatore è utile sostanzialmente per eseguire delle demo e difficilmente potrà risultare utile durante il normale sviluppo su device reali dove questo problema non si verifica.

Thanks Alex!

Micro Framework Trace su serial port

Raffaele Rialdi — Wed, 19 Dec 2007 15:12:06 GMT

Le limitazioni del Micro Framework non permettono soluzioni eleganti come quella di redirigere lo stream dello standard output sulla porta seriale. Per questo motivo mi sono scritto una piccola classe helper che consente di eseguire il dump sulla porta seriale.

Collego la scheda con un cavo seriale al PC
Apro la finestra di terminale, per esempio a 9600 baud
Aggiungo al progetto la classe statica
Nel progetto chiamo la Init che apre la porta seriale
Dove serve chiamo DebugSerial.Write(...) o DebugSerial.WriteLine(...)
Ogni output viene buttato sulla seriale

Il tutto è semplice e banale. L'aiuto viene soprattutto da alcuni metodi in overload che consentono di scrivere sulla seriale molti Type differenti (e naturalmente la loro controparte WriteLine che aggiunge 0x0d 0x0a alla fine della riga):

public static void Write(object obj) ==> usa ToString per ottenere la stringa da stampare
public static void Write(string Text) ==> Stampa la stringa
public static void Write(byte[] Blob) ==> Stampa la rappresentazione Hex dell'array di byte

Nella classe è inclusa il metodo di conversione in Hex che il MicroFramework non implementa (non esiste la ToString("x")).

/// <summary>

/// Small static class used to write on the serial port

/// Use similar to the System.Diagnostics.Trace class

/// </summary>

public static class DebugSerial

{

static Microsoft.SPOT.Hardware.SerialPort _Serial;

static byte[] _CrLf;

static DebugSerial()

{

_CrLf = new byte[] { 0x0d, 0x0a };

}

  

/// <summary>

/// Init serial port at 9600 baud

/// </summary>

public static void Init()

{

Init(Microsoft.SPOT.Hardware.SerialPort.BaudRate.Baud9600);

}

  

/// <summary>

/// Init the serial port at an arbitrary baud rate

/// </summary>

/// <param name="RafDog">http://www.weloveraf.com/archive/2007/11/09/fact-ffc7b73a-8eb6-11dc-977f-ac8256d89593-live-from-teched.aspx</param>

public static void Init(Microsoft.SPOT.Hardware.SerialPort.BaudRate RafDog)

{

if(_Serial != null)

Close();

Microsoft.SPOT.Hardware.SerialPort.Configuration config = 

new Microsoft.SPOT.Hardware.SerialPort.Configuration(

Microsoft.SPOT.Hardware.SerialPort.Serial.COM1, 

RafDog, false);

_Serial = new Microsoft.SPOT.Hardware.SerialPort(config);

  

}

  

/// <summary>

/// Write the string resulting from ToString()

/// </summary>

/// <param name="obj">object to dump</param>

public static void Write(object obj)

{

Write(obj.ToString());

}

  

/// <summary>

/// Write the string resulting from ToString()

/// and the line terminator over the serial port

/// </summary>

/// <param name="obj">object to dump</param>

public static void WriteLine(object obj)

{

Write(obj);

_Serial.Write(_CrLf, 0, _CrLf.Length);

}

  

/// <summary>

/// Write a string over the serial port

/// </summary>

/// <param name="Text">String to write</param>

public static void Write(string Text)

{

byte[] blob = System.Text.Encoding.UTF8.GetBytes(Text);

_Serial.Write(blob, 0, blob.Length);

}

  

/// <summary>

/// Write a string and the line terminator over the serial port

/// </summary>

/// <param name="Text">String to write</param>

public static void WriteLine(string Text)

{

Write(Text);

_Serial.Write(_CrLf, 0, _CrLf.Length);

}

  

/// <summary>

/// Write the hex representation of a byte array over the serial port

/// </summary>

/// <param name="Blob">byte array to write</param>

public static void Write(byte[] Blob)

{

Write(ToHex(Blob));

}

  

/// <summary>

/// Write the hex representation of a byte array and the line terminator over the serial port

/// </summary>

/// <param name="Blob">byte array to write</param>

public static void WriteLine(byte[] Blob)

{

Write(Blob);

_Serial.Write(_CrLf, 0, _CrLf.Length);

}

  

static string _Alpha = "0123456789ABCDEF";

static char _HexSeparator = '.';

/// <summary>

/// Convert a byte array to a string containing the hex representation of the array

/// </summary>

/// <param name="Blob">The byte array to convert in hex string</param>

/// <returns></returns>

static string ToHex(byte[] Blob)

{

return ToHex(Blob, true);

}

  

/// <summary>

/// Convert a byte array to a string containing the hex representation of the array

/// and an optional character separator for bytes

/// </summary>

/// <param name="Blob">The byte array to convert in hex string</param>

/// <param name="UseSeparator">Wether to use the separator or not</param>

/// <returns></returns>

static string ToHex(byte[] Blob, bool UseSeparator)

{

int Len = Blob.Length;

char[] res;

if(UseSeparator)

res = new char[Len * 2 + Len - 1];

else

res = new char[Len * 2];

  

for(int i = 0; i < Blob.Length; i++)

{

byte r = (byte)(Blob[i] % 16);

byte v = (byte)((byte)(Blob[i] - r) / 16);

if(i != Blob.Length - 1 && UseSeparator)

res[(i + 1) * 3 - 1] = _HexSeparator;

if(UseSeparator)

{

res[(i + 1) * 3 - 2] = _Alpha[r];

res[(i + 1) * 3 - 3] = _Alpha[v];

}

else

{

res[(i + 1) * 2 - 1] = _Alpha[r];

res[(i + 1) * 2 - 2] = _Alpha[v];

}

}

return new string(res);

}

  

/// <summary>

/// Explicitly close the serial port

/// </summary>

public static void Close()

{

if(_Serial != null)

_Serial.Dispose();

_Serial = null;

}

}

I commenti erano quasi tutti scontati da capire, esclusi quelli di riga 26 ;-)

È il mio articolo ad inaugurare il blog del team del Micro Framework .NET

Raffaele Rialdi — Wed, 10 Oct 2007 00:01:50 GMT

Il blog del team del Micro Framework.NET è appena nato e come primo post ha pubblicato la traduzione che io stesso ho fatto del mio articolo sullo sviluppo di una applicazione di esempio che mostra come realizzare un piccolo dispositivo che mantiene i tempi (istantanei, medio, massimo e minimo) delle vasche durante un allenamento in piscina.

Il post è il seguente:
http://blogs.msdn.com/netmfteam/archive/2007/10/09/swim-training-with-the-net-micro-framework.aspx

Agli italiani interessati ricordo che l'originale dell'articolo (in Italiano e in forma più estesa) è pubblicato qui, e l'articolo precedente che introduce l'architettura del Micro Framework .NET si trova invece qui.

WPC 2007, che spettacolo!

Raffaele Rialdi — Thu, 20 Sep 2007 13:04:47 GMT

Credo che quest'anno mi divertirò più che mai.

Io e Max stiamo preparando Hacking 101, una sessione lunghissima, per contenuti come di quella di due anni fa, con tantissime demo e molto molto densa di argomenti. Non posso dire altro, ma credo che sarà realmente molto interessante.

Ho già preparato la "Design for Scalability e Performance" che, essendo nella track "Manageriale Sistemi", sarà molto orientata alle scelte decisionali tra le varie tecnologie a disposizione oggi, guardando soprattutto alla scalabilità e alle performance.

Pronta anche la "Security By Design" che affronta il tema della sicurezza nell'architettura di una applicazione. La sessione sarà tutt'altro che teorica, anche qui prendendo in esame le scelte che le tecnologie a disposizione ci offrono, Framework 3.5 compreso. Affrontare la sicurezza di una applicazione in modo pragmatico aiuta il progetto nel suo complesso oltre a tenere sotto controllo le potenziali vulnerabilità.

Infine a WPC ci sarà il battesimo della neonata UgiMobile durante uno degli incontri serali.

Beh, ovviamente l'agenda contiene un'altra montagna di sessioni per tutti i gusti ...

Con piacere so che il numero degli iscritti è già bello tosto quindi ... see you there!

UgiMobile.org è nato!

Raffaele Rialdi — Thu, 13 Sep 2007 15:28:43 GMT

Dopo un modesto tempo di incubazione, è nato UgiMobile, lo User Group Italiano focalizzato allo sviluppo su dispositivi Mobile.

L'artefice è Michele, in arte Mighell che ha fortemente voluto questo User Group. Ho l'onore di essere tra i co-fondatori insieme a Giuseppe Paparone, Giorgio Cifani eSandro Vecchiarelli.

Ogni altro dettaglio è ben specificato qui: ttp://www.michelelocuratolo.com/archive/2007/09/12/ugimobile.org-si-parte.aspx.

Se vi piace sviluppare per PDA, Smartphone e dintorni... fatevi sotto!