.NET

AVR Italy Community

Riccardo Mariotti — Wed, 28 May 2008 12:47:06 GMT

Volevo segnalare il mio tentativo di istituire la prima comunità italiana di utilizzatori di microcontrollori AVR® della Atmel®, appassionati di elettronica e di programmazione. Si prenderanno in considerazione prevalentemente i progetti e gli articoli riguardanti lo sviluppo di applicazioni, plug-in e librerie per l'interfacciamento del mondo dei micro AVR ed i personal computer con sistema operativo Microsoft® Windows®, prendendo come riferimento per lo sviluppo il Framework Microsoft® .NET, il linguaggio C# e Visual Studio.

Per gli interessati: http://avr.rmariotti.it

Modifica delle proprietà e INotifyPropertyChanged

Riccardo Mariotti — Fri, 14 Mar 2008 09:54:26 GMT

Spesso in rete trovo degli esempi di implementazione dell'interfaccia INotifyPropertyChanged che non mi piacciono per niente (anche su MSDN). In particolare sono interessato a come e quando generare l'evento di notifica della modifica di una proprietà. Sembra che quasi tutti ignorino il fatto di generare la notifica solo quando il valore della proprietà è stato effettivamente modificato.

Credo invece sia importante gestire correttamente tale notifica, per una serie di ragioni, prima su tutte le performance. Nelle mie implementazioni di entità gestisco l'impostazione del nuovo valore e la notifica in modo centralizzato, con un metodo protected implementato nella classe base da cui derivano tutte le entità, con il compito di verificare effettivamente se il valore è cambiato oppure no prima di impostare il nuovo valore e generare l'evento. E' chiaro che tutte le entità concrete devono rispettare il pattern di richiamare tale metodo nei rispettivi setter ed implementare l'override del metodo Equal (e quindi obbligatoriamente anche GetHashCode) in modo da comparare anche proprietà che rappresentano altre entità.

Sto sbagliando, nel senso, mi sto facendo troppi problemi?

Implementare ISupportInitialize nelle classi entità

Riccardo Mariotti — Thu, 13 Mar 2008 12:13:05 GMT

Sto realizzando l'ennesima versione di una classe base astratta da utilizzare per tutte le entità aziendali. Questa classe dovrà implementare alcune interfacce basilari, tra le quali INotifyPropertyChanged, e pensavo anche alla ISupportInitialize. Il dubbio che ho nell'implementare quest'ultima interfaccia è se devo generare o no gli eventi di notifica del cambio dei valori delle proprietà nel momento che a seguito della chiamata al metodo ISupportInitialize.EndInit() vado ad impostare tutti i valori delle proprietà modificate dopo la chiamata a ISupportInitialize.BeginInit().

Per chiarezza (?), segue il frammento dell'implementazione della classe ed in particolare la parte di implementazione dell'interfaccia ISupportInitialize.

#region ISupportInitialize implementation

public void BeginInit()

{

if (!m_Initializing)

{

m_InitializeData = new Hashtable();

m_Initializing = true;

}

public void EndInit()

{

if (m_Initializing)

{

m_Initializing = false;

Type t = this.GetType();

foreach (DictionaryEntry entry in m_InitializeData)

{

PropertyInfo pi = t.GetProperty((string)entry.Key);

if (pi != null)

{

pi.SetValue(this, entry.Value, null);

}

m_InitializeData = null;

}

#endregion

In questa implementazione nel metodo EndInit si impostano i valori di tutte le proprietà modificate dopo la chiamata alla BeginInit bufferizzate in una tabella hash, chiamando il metodo SetValue via reflection che invoca il setter della relativa proprietà, la quale noticherà la modifica generando l'evento relativo all'implementazione della INotifyPropertyChanged (non mostrata nel frammento di codice).

Quindi ecco il dubbio: è corretto così, oppure devo disabilitare le notifiche del cambio delle proprietà quando sono nella EndInit? Personalmente credo che come è scritta ora non vada bene. Da quello che ho capito io, lo scopo dell'implementazione dell'interfaccia ISupportInitialize è di impostare tutte le proprietà senza craere problemi di incoerenza sullo stato dell'entità stessa e quindi, credo che non debbano essere generare le relative notifiche, le quali potrebbero dare problemi ai client "in ascolto".

Sono graditi commenti e/o suggerimenti.

WPF binding con oggetti Visual ed entità

Riccardo Mariotti — Thu, 28 Feb 2008 09:55:52 GMT

Sto progettando un framework per il disegno di oggetti grafici in WPF utilizzabili per comporre disegni, schemi, organigrammi, pert, ecc. Dato che ogni disegno dovrà essere caricato e salvato in data set di vario tipo (file XML, database SQL) ogni oggetto grafico sarà in realtà una rappresentazione di entità aziendali custom serializzabili.

Per disaccoppiare la rappresentazione grafica ed i dati, ho pensato di utilizzare il binding già implementato da WPF. In pratica, l'utilizzo del binding è un po' fuori dai soliti schemi ed esempi che si trovano in rete, nel senso che le proprietà collegate non sono riferite a controlli utente di una window, ma sono proprietà di oggetti Visual disegnabili su un Canvas (semplificando al massimo, si immagini che siano primitive del tipo rettangolo, ellisse, testo, poligono, ecc.). Inoltre le proprietà saranno modificabili dall'utente in modo interattivo utilizzando ad esempio un editor specifico, con l'uso di adorner creati appositamente. La modifica interattiva, tramite il binding, modificherà anche le rispettive proprietà degli oggetti entità e quindi i dati persistenti sul data set.

Questa tecnica, per le prove fatte fino ad ora, funziona (ovviamente il framework .NET fa il suo dovere). Volevo sapere se qualcuno di voi ha già fatto cose simili o conosce qualche link in merito al binding su primitive grafiche.

Distruttori e Dispose in .NET

Riccardo Mariotti — Sat, 29 Oct 2005 15:09:00 GMT

Durante lo sviluppo di una classe base per l'accesso ai dati utilizzando la Enterprise Library mi sono accorto di un mio bug riguardante il non rilascio delle risorse quando utilizzavo il contesto di configurazione nel costruttore della classe. Questo provocava un memory leaks che mi faceva crescere il numero di thread allocati mano a mano che utilizzavo le classi per l'accesso ai dati. Quindi mi sono detto: mi scrivo una serie di regole per evitare in futuro questo grossolano errore nella programmazione in .NET. Per fortuna, come capita di sovente, in rete altri hanno già fatto esperienza e scritto qualche cosa, e in questo caso mi sono ritrovato a leggere un interessante post http://www.csharphelp.com/archives3/archive571.html, riguardante alcune semplici regole quando si tratta di distruttori e Dispose in .NET. Mi sono permesso di tradurlo a modo mio nell'articolo http://blogs.ugidotnet.org/rimariot/articles/28926.aspx.