blogs.ASPItalia.com

Migliorare la lettura di un sito

2009-06-25T18:02:20+00:00

Mi piace il progetto Readibility, da un sito pieno di riquadri, banner e inutilità varie (IMHO), è possibile con un solo click passare per esempio da:

Comodo per stampe. Ed è anche personalizzabile. Il tutto grazie ad un sapiente uso di Javascript. Carino.

Mia nota personale e domanda a me stesso: se ci si trova in due o più a condividere un'idea, è giusto buttarsi in ciò che c'è già nell'inutilità generale dell'insulsaggine del già visto?

Tags: Javascript, XHTML

C# 4.0 Beta 1, quello che io ho visto

2009-05-24T18:33:00+00:00

Giovedì ho trovato il tempo di installare sulla mia macchina la nuova versione di Visual Studio 2010 beta 1. Leggendo i vari documenti sulle novità, la mia curiosità è stata attratta dalle novità del linguaggio C# della version 4.0. Da quel che ho capito sono quattro le novità:

Dynamic Typed Objects
Optional and Named Parameters
Improved COM Interoperability
Co/Contra-Variance

Sui dynamic ho avuto proprio una discussione sul fatto che la keywork dynamic non centra nulla con var. La dichiarazione di un oggetto come dynamic, crea effettivamente un oggetto di tipo dinamico in runtime ed elaborato in late-binding, con tutti i problemi che ne derivano!

Scrivere queste linee di codice ora è perfettamente corretto:

dynamic az = "Andrea";
Console.WriteLine(az); // Andrea
az = 14;
az = 14 * 2;
Console.WriteLine(az); // 28
az = new System.Data.DataTable();
Console.WriteLine(az.GetType()); // System.Data.DataTable

Ma questo nuovo oggetto è utilizzabile anche nelle dichiarazioni di metodi e altro:

Dynamic1("aa");
Dynamic1(12);
...

static void Dynamic1(dynamic value)
{
   if (value is string)
      Console.WriteLine(value + " is a string!");
   if (value is int)
      Console.WriteLine(value + " is a int!");
}

Ma la potenzialità del dynamic vanno ben oltre. E' possibile ora chiamare oggetti COM in modo molto più semplice, ed è diventato anche banale caricare runtime una dll e utilizzarne i metodi. Per esempio, avevo questa classe in una dll esterna:

namespace TestDynamic
{
    public class Utilities
    {
        public string GetAll(string name)
        {
            return string.Format("{0}: {1}", name, DateTime.Now);
        }
    }
}

Possiamo caricarla e utilizzarla con i dynamic (senza reference). Un esempio di codice che fa questo:

dynamic mya = Assembly.LoadFile("../class.dll");
Type myaClassType = mya.GetType("TestDynamic.Utilities");
dynamic myaDemoClassObj = Activator.CreateInstance(myaClassType);
string val = myaDemoClassObj.GetAll("az");

Facile e comodo? Può essere, ma l'utilizzo del dynamic non è immune da problemi. Innanzitutto prestazionale: come detto prima, tutto ciò che è dynamic è elaborato in runtime/late-binding, dunque con tutti i problemi di prestazioni che ne derivano. L'esempio di codice qui sopra, se confrontato con un metodo tradizionale di loading di una dll e utilizzo del reflector o, meglio, di interfacce, perde su tutti i fronti. Secondo problema: Visual Studio 2010 non è in grado di fornici l'intellisense:

L'utilizzo dei parametri opzionali o dichiarandone il nome è una di quelle novità che ricordano tanto ciò che Visual Basic offre da parecchio tempo:

public string MyMethod(int Id = 0, string Name = "AZ")
{
...
}

Che crea in automatico gli overload del metodo passando ai parametri i valori di default specificati:

            MyMethod();
            MyMethod(1);
            MyMethod(1, "Andrea");

E se nell'esempio sopra volessimo passare solo il parametro Name e non l'Id? Questo codice ci darebbe errore, perché si aspetta in ogni caso come primo parametro un int:

MyMehotd("Andrea");

Una delle altre novità di C# 4.0, è la possibilità di dichiarare oltre al valore anche il parametro a cui sarà assegnato:

MyMethod(Name: "Andrea");
MyMethod(Name: "Andrea", Id: 1);

L'ultima novità, Covariance e Contravariance. La covariance permette di trattare gli oggetti come il tipo da cui deriva. Per esempio, avendo le classi:

    public class First
    {
    }
    public class Second : First
    {
    }

Possiamo scrivere:

First[] coll = new Second[20];

Ma non possiamo in alcun modo utilizzare questa possibilità nel caso dei generic essendo il C# a cui siamo abituati invariant:

List<Second> xsecond = new List<Second>();
List<First> xfirst = xsecond;

Cannot implicitly convert type 'System.Collections.Generic.List<Test1.Second>' to 'System.Collections.Generic.IList<Test1.First>'.

Attualmente ci sono altri metodi per copiare un oggetto o una collection di oggetti (cast o Linq). Con la nuove versione di C#, abbiamo una nuova tecnica ma, come scritto sopra, per ora è possibile solo con le interfacce e delegate modificare questo comportamento:

public class Other<T> where T : First // Or without constraint
{
}
public class Other2<T> : IOther2<T>
{
}
interface IOther2<out T>
{
}

Ora, grazie all'interfaccia (e la specifica del generic T con out), possiamo utilizzare anche gli oggetti derivati della nostra classe:

var xot2 = new Other2<Second>();
IOther2<First> xot21 = xot2;

La keyword out è utilizzata per specificare gli oggetti in output, mentre in come è facilmente intuibile è utilizzabile come parametro input di metodi con i delegate, eccole utilizzare entrambe con i delegate:

delegate T Func1<out T>();
delegate void Action1<in T>(T a);
...
// Covariance
Func1<Second> secondx = () => new Second();
Func1<First> firstx = secondx;
// Contravariance
Action1<First> act1 = (ani) => { Console.WriteLine(ani.ToString()); };
Action1<Second> cat1 = act1;
cat1(new Second());

Ho detto qualcosa di inesatto? E' facile che sia così: il mio studio sulle novità di questo linguaggio si basano su test e letture che il poco tempo libero attuale mi permette. Questa scusa mi lascia scevro di responsabilità? Se ne sono convinto io...

Tags: .NET Framework, .NET Framework 4.0, Visual Studio

ATM e Moby TV

2009-01-23T09:28:00+00:00

Da buon Milanese adottivo, per evitare di affrontare il traffico con mezzi propri, mi affido al trasporto pubblico. Dall'ultimo trimestre dell'anno scorso hanno messo in dotazione sui vari pullman anche la Moby TV, che, tra pubblicità, info, cartoni animati e altro, informa i viaggiatori.

Sinceramente questi apparecchi non mi interessano più di tanto, ma ieri sera, durante il ritorno a casa, dopo aver appena guardato un cartone animano della serie "Stupid Cupid" dove uno Yeti scendeva dalla montagna perché innamorato di uno sciatore, una schermata nera ha attirato la mia attenzione.

La schermata del BIOS è apparsa sul monitor. Conteggio di memoria veloce (se non ricordo male sono macchine con 512MB o 768, non ero così vicino per vedere bene) e avvio della macchina. Il mio interesse si è quindi rivolto completamente al video per capire quale sistema operativo utilizzasse. Dopo la schermata del bios riassuntiva della macchina ecco che si avvia... Linux. Controllo dei vari component, Udev e altro. Avvio classico di Xorg con il mouse a forma di "X" al centro dello schermo e avvio dell'applicazione della Moby TV.

La cosa che mi ha fatto sorridere è stata: ma il riavvio era dovuto ad un crash di Linux o ad un altro problema della macchina?

Il 19 gennaio era il duecentenaio della nascita di Edgar Allan Poe.

Tags: Off Topic

Moonlight - Silverlight 1-2

2009-01-21T08:27:00+00:00

Da scoprire a installare Moonlight 1.0 è passato un attimo. Installazione veloce che richiede solo il riavvio di Firefox come ogni suo plug-in. L'inizio dei test avviene qualche minuto dopo. Innanzitutto: Moonlight 1.0 è la versione 1 di Silverlight! Per vedere le applicazioni scritte in Silverlight 2 si dovrà aspettare la versione 2.0 di Moonlight.

Le prove. Dai miei test sulle applicazioni scritte in Silverlight 1, solo il ~60% gira senza problemi. Mi ha sorpreso vedere filmati girare senza problemi e altre molto più semplici visualizzare solo un rettangolo grigio e niente altro.

Quando sarà disponibile la versione 2.0? Qui le risposte.

Tags: .NET Framework, Mono, Silverlight, XAML

Modificare i PDF

2008-11-09T09:40:19+00:00

Prima o poi chiunque si trova di fronte a questo problemino (!?!?). Una soluzione veloce veloce free è grazie ad una extension per OpenOffice: Sun PDF Import Extension. Scaricato e installato dal menu Strumenti e Gestione estensioni, ci permette di aprire in scrittura i documenti PDF ed effettuare delle modifiche. Delle modifiche perché non permette di rivoluzionare la struttura di un documento. Da miei piccoli test mi sono trovato più volte il testo di un paragrafo separato per righe, quindi con difficoltà nelle correzioni e unione dello stesso.

Però è comodo. Anche nelle fredde ma assolate domeniche mattina.

Tags: Office

Mono e Framework... un po' di semplici benchmark

2008-10-28T08:29:50+00:00

"Ma prestazionalmente, sulla stessa macchina, quant'è la differenza tra un'applicazione che gira sul Framework e sistema operativo Microsoft e la stessa su Linux con Mono?"

Questa era una richiesta che mi era stata fatta parecchio tempo fa, ma per questione di voglia o altro non l'avevo mai fatta. Allora ho scritto una semplice windows forms che facesse delle operazioni ripetute su questi semplici scenari:

Calcolo con interi: banale calcolo con soli numeri interi.
Calcolo con decimal: come sopra, ma con l'uso dei decimali.
Lettura completa di un documento xml da 300KB e 44.000 nodi, con il SelectNodes, nodo per nodo.
Apertura ripetuta dello stesso documento xml ripetutamente con ricerca di nodi all'interno dello stesso.

Innanzitutto vediamo l'applicazione in esecuzione:

E su Linux con Mono:

Riassumendo i risultati in una tabella:

	Integer	Double	Xml 1	Xml 2
Windows .net	453,125s	1859,375s	46,875s	4640,625s
Mono	499,71s	2362.398s	259,891s	26959,493s

NB:

La piccola applicazione è stata scritta con Visual Studio 2008 per il Framework 2.0.
Il computer su cui girava Mono aveva Ubuntu 8.10 RC.
Ho potuto usare solo la versione 1.9 di Mono e non la nuova 2.0, ma purtroppo non potevo testare la nuova versione sul computer a disposizione.
Notare le piccole imperfezioni grafiche della versione Mono, teoricamente risolte con la nuova versione.

Tags: .NET Framework, Mono

GTK, giusta crocevia tra piattaforme?

2008-10-26T12:57:50+00:00

Non ho mai fatto segreto della mia passione per Mono, porting del Framework .Net su sistemi operativi non Microsoft. Passi da gigante sono stati fatti per la compatibilità delle stesse applicazioni su sistemi operativi differenti, soprattutto per applicazioni desktop (sono fondamentalmente contro all'utilizzo di questo porting per webapplication, visto che il risparmio dovuto ad hosting e licenze dei sistemi operativi sia ridicolo di fronte allo sforzo per la realizzazione di web application che girino perfettamente con Mono - ma questo è assolutamente IMHO!).

Da qualche giorno è uscita la versione 2.0 di Mono. E' aumentata notevolmente la compatibilità con le applicazini scritte con il Framework nativo della Microsoft. Ora è possibile lanciare moltissime applicazioni windows forms su Linux con Mono senza trovare grosse differenze e problematiche nell'uso dell'interfaccia grafica (cosa che avveniva in modo pesante con la versione 1.2 e, in modo minore, con la 1.9.1).

Nel poco tempo che riesco a dedicare a Mono per miei test, ho trovato ideale l'utilizzo di una libreria esterna per la creazione e l'utilizzo delle interfacce grafiche, compatibile con entrambi i mondi, Windows e Linux. E' il progetto Gtk#, libreria che permette l'utilizzo di Gtk+ che, ricordo, è la libreria grafica utilizzata dal Desktop environment, Gnome. Inoltre è utilizzata già con successo da molti altri programmi multi piattaforma, come Pidgin.

Il suo utilizzo in applicazioni .Net su sistemi operativi Linux non necessita di alcuno sforzo visto che nel caso di Gnome è già installata la libreria Gtk, nel caso di altri Desktop environment - Kde - è sufficiente installare tale libreria. Installazione necessaria anche sotto Windows da questo link da dove si devono scaricare sia la libreria Gtk+, sia Glade, e infine la Gtk#.

La costruzione dell'interfacce grafica è semplice, grazie a programmi appositi, come Glade (programma scaricato prima), che permette la creazione di interfacce grafiche in modo molto simile a Visual Studio. L'output di questo programma è un xml che, incluso nel nostro progetto con Visual Studio definito come "Embedded Resource" utilizzeremo in questo modo:

public GtkApp(string []args)
{
Application.Init();
Glade.XML gxml = new Glade.XML (null, "googleSearch.googlesearch.glade",
"mainWindow", null);
gxml.Autoconnect (this);
mainWindow.DeleteEvent+=new DeleteEventHandler(mainWindow_DeleteEvent);
btnSearch.Clicked+=new EventHandler(btnSearch_Clicked);
btnClear.Clicked+=new EventHandler(btnClear_Clicked);
Application.Run();
}

Un esempio completo (da cui ho preso questa porzione di codice) lo si trova in questa pagina di CodeProject. Dopo aver caricato l'interfaccia grafica si connette da codice gli eventi agli oggetti come i button all'interno dell'interfaccia grafica. Tutto fatto.

Abbiamo a disposizione altre interfacce grafiche comuni tra i sistemi operativi, come la famosa libreria wxwidgets e il suo porting in .Net, wxwidgets.net. Potente flessibile, ma ha grossi problemi di stabilità almeno sotto windows dove crolla spesso e volentieri in errori inspiegabili - almeno per me.

Tags: Mono

Excel e i formati aperti

2008-10-25T12:00:18+00:00

Questa settimana ho dovuto lavorare parecchio con Excel. Ma non nella costruzione di fogli con il programma Excel per inserire le formulette o per creare grafici, ma per la sua gestione dal di fuori con codice .Net in un ameno CRUD - è applicabile anche fuori dal mondo dei db questo acronimo? Non sono un purista delle terminologia e dunque non me ne frega nulla.

Vediamo un po' le risorse a nostra disposizione senza componenti da installare su un server per leggere e scrivere nel formato .xls di Excel. Innanzitutto partiamo dalla creazione. Abbiamo tre grosse e facili strade:

Tabella html.
Xml
Oledb

La prima strada è la più semplice ma assolutamente non permette alcuna configurazione. In poche parole scordiamoci l'inserimento di formule e formattazioni strane. Il contenuto della tabella sarà importata così com'è, nulla di più, nulla di meno.

L'xml si può dividere in due categorie: quello contenente solo i dati di Excel e quello che rappresenta sia i dati sia la formattazione. Nel primo caso non abbiamo niente di differente dalla tabella html prima citata, mentre nel secondo caso abbiamo pressocché tutte le potenzialità di Excel a disposizione: formattazione, formule, multi-sheet e così via... L'unica limitazione che ho trovato è nell'impossibilità di bloccare con password gli elementi presenti nel documento. Questo formato è molto semplice. Per poterlo vedere è sufficiente salvare un qualsiasi documento Excel in formato Xml e aprirlo con un qualsiasi editor:

<?xml version="1.0" encoding="UTF-8"?>
<?mso-application progid="Excel.Sheet"?>
<Workbook xmlns:c="urn:schemas-microsoft-com:office:component:spreadsheet"
xmlns:html="http://www.w3.org/TR/REC-html40"
xmlns:o="urn:schemas-microsoft-com:office:office"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="urn:schemas-microsoft-com:office:spreadsheet"
xmlns:x2="http://schemas.microsoft.com/office/excel/2003/xml"
xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet"
xmlns:x="urn:schemas-microsoft-com:office:excel">
<OfficeDocumentSettings xmlns="urn:schemas-microsoft-com:office:office">
<Colors>
<Color>
...
</Color>
</Colors>
</OfficeDocumentSettings>
<ExcelWorkbook xmlns="urn:schemas-microsoft-com:office:excel">
...
</ExcelWorkbook>
<Styles>
<Style ss:ID="Default" ss:Name="Default"/>...
</Styles>
<ss:Worksheet ss:Name="Foglio1">
<Table ss:StyleID="ta1"><Column ss:Width="64.2614"/><Row ss:Height="12.8409"><Cell><Data ss:Type="String">Titolo</Data></Cell></Row><Row ss:Height="12.8409"><Cell><Data ss:Type="Number">12</Data></Cell></Row><Row ss:Height="12.8409"><Cell><Data ss:Type="Number">32</Data></Cell></Row><Row ss:Height="12.8409"><Cell><Data ss:Type="Number">43</Data></Cell></Row><Row ss:Height="12.8409"><Cell ss:Formula="of:=SUM([.A2:.A4])"><Data ss:Type="Number">87</Data></Cell></Row></Table><x:WorksheetOptions/>
</ss:Worksheet>
<ss:Worksheet ss:Name="Foglio2">
<Table ss:StyleID="ta1"><Column ss:Width="64.2614"/><Row ss:Height="12.8409"><Cell ss:Index="1"/></Row></Table><x:WorksheetOptions/>
</ss:Worksheet>
<ss:Worksheet ss:Name="Foglio3">
<Table ss:StyleID="ta1"><Column ss:Width="64.2614"/><Row ss:Height="12.8409"><Cell ss:Index="1"/></Row></Table><x:WorksheetOptions/>
</ss:Worksheet>
</Workbook>

L'ultima tecnica a disposizione è grazie all'uso dell'oledb. Proprio come fosse un database, possiamo creare un foglio di excel, i singoli fogli e il contenuto tabellare. E' sufficiente usare una stringa di connessione come la seguente per accedere in lettura o, se non esiste, per creare un documento Excel:

string conn="Provider=Microsoft.Jet.OLEDB.4.0;Data Source=Document.xls;Extended Properties = \"Excel 8.0;HDR=YES;\"";

Per leggere si usano i soliti comando sql-like:

select * from [Sheet1$]

Così anche per l'inserimento:

inert into [Sheet1$](NomeColonna1,NomeColonna2) values(1,2)

Per creare un nuovo sheet:

create table [AZFoglio](Colonna1 int, Colonna2 text)

Il problema è la cancellazione di un sheet. Questo comando non elimina lo sheet dal documento, ma semplicemente lo svuota:

drop table [AZFoglio]

Altra nota negativa non di poco conto? La cancellazione di righe non è supportata!

Inoltre, tutti gli sheet creati all'interno di Excel avranno il simbolo del dollaro in automatico alla fine del nome (importante saperlo perché il simbolo è necessario per le query in oledb), mentre quelli creati da Oledb, non sarà necessario.

Molto comodo questo tipo di accesso, ma ci mette subito di fronte all'impossibilità di inserire alcunché al di fuori di dati tabellari. Inoltre, l'Oledb ha un modo particolare per capire il tipo di dato presente in una colonna in un documento Excel: legge le prime otto righe per ogni colonna, e da un media tutta sua, valuta il tipo che sarà contenuto. Questo cosa comporta? Semplice, un macello se prepariamo un documento Excel contenente solo il nome delle colonne e senza alcun dato perché popolata dal nostro codice. Il perché? Intuibile. Oledb vedendo solo il nome di colonna - una stringa - penserà che il tipo è di tipo text.

Altro grave problema. Se il classico operatore che non sa distinguere Excel da un tostapane, inserisce i dati come numeri e poi testo, il tipo non corrispondente a quello calcolato dalla media all'apertura del documento, sarà ignorato.

Visto che sono saltato a piè pari alla lettura, qualsiasi persona potrebbe pensare di creare il documento Excel in formato Xml e poi leggerlo con Oledb... MAGARI! No, non è possibile. Oledb è in grado di accedere ai documenti Excel salvati nel suo formato originale. Bel casino. E per leggere un documento Excel salvato in formato Xml? Semplice, si usa il classo XmlDocument o classi simili! E sempre per aggiungere righe, modificare colonne e altro, ci si deve affidare a oggetti adatti alla trattazione di documenti Xml.

In rete sono disponibili vari oggetti per la lettura/scrittura di documenti Excel. Per esempio:

Il primo è in grado di leggere in modo perfetto (bel superiore all'Oledb) qualsiasi documento salvato in formato Excel, ma non documenti creati in Xml. La seconda classe crea un documento Excel in modo molto semplice e intuitivo, ma solo in formato Xml. Uomo avvisato...

Ma dopo tutto questo personale chiacchiericcio, qual è la morale? Innanzitutto ho voluto darei posteri questa mia esperienza in modo che altri possano perdere meno tempo in test come ho fatto io, e poi... Quando si butteranno via i formati proprietari di Excel, Word e - perché no? - Pdf, e non si usano definitivamente quelli aperti come quello di Office 2007 o di OpenOffice? E pensare come sarebbe bello! La fine dell'utilizzo di oggetti esterni e carissimi per gestire questi formati, basta installazioni di oggetti COM per la loro trattazione.

Questo è uno sfogo personale!

E non centra nulla con il fatto che oggi è il Linux Day. A proposito, sui miei computer ecco i sistemi operativi che uso:

Windows 2003 (in attesa di essere sostituito da Windows 2008 appena avrò una nuova macchina, i miei due SO preferiti made in Microsoft).
Arch Linux (la mia distribuzione Linux preferita).
Windows Xp SP3 (affidabilissimo anche sul quel mio catenaccio di portatile).
Ubuntu 8.4 (riesce a farmi funzionare tutto sul portatile).

Tags: Office

Io... e il mio tempo

2008-10-18T12:58:06+00:00

Sarà... avrà ragione la gente. Mi dicono che ho un caratteraccio. Qualcuno si stupisce di certi miei comportamenti. Eppure a me sembra chiaro. Vivo con il costrutto vivi e lascia vivere... Ma quello che non sopporto sono quelli che pensano di sapere i fatti degli altri, di avere titolo per elargire buoni consigli. Ma che ne sai di quello che penso, faccio, desidero e odio? Io accetto le critiche, ma da persone che sanno chi sono e che mi conoscono.

Faccio un esempio altrimenti non vengo capito. Prendiamo questa critica mossa su un mio blog precedente. Mi chiedo: costui che titolo ha di criticare ciò che scrivo il quel suo blog stantio alla ricerca del solito sensazionalismo, aggiungendo in coda la seguente frase?

PS per la serie.. c'è gente che ha tanto tempo da perdere in cose veramente poco utili e obiettive.

Così come io ho fatto dei test e ho dimostrato alcune cose, secondo me utili e motivate, mi piacerebbe che anche tu facessi lo stesso nei miei confronti, in modo che possa capire, se e dove, ho sbagliato nelle mie considerazioni. Ti ricordo inoltre che i prodotti, di qualsiasi azienda non solo di Microsoft, conquistano il mercato e si impogono, non tanto perchè c'è un Evangelist qualsiasi (che ho sempre considerato figura tecnica e non markettaro) che sostiene velatamente, "che i nostri prodotti sono i migliori e gli altri fanno schifo" ma perchè sono effettivamente, concretamente e oggettivamente migliori di altri. Sarebbe troppo facile se tutti i clienti abboccassero così all'amo.

P.S.
Io non sono obbiettivo e dico cose poco utili? Un evangelist Microsoft dice a me che non sono obbiettivo? Era una battuta, vero?

Tags: Off Topic

BackgroundWorker e le windows forms

2008-10-17T06:54:18+00:00

Apprezzo moltissimo questo oggetto introdotto nella versione 2.0 del framework quando devo scrivere delle windows forms tradizionali con il Framework. Chi ha esperienza di programmazione delle windows application con .net, saprà del famoso freezing che colpisce l'applicazione in caso di operazioni lunghe/pesanti se tale codice viene elaborato da un evento (click su un button o simile).

Fin dalla versione 1.0 per evitare questo inconveniente era necessario armarsi di delegate e pazienza, e con il classico inconveniente di non poter aggiorare l'interfaccia grafica in caso di utilizzo di questa tecnica se non con l'uso di altri artefizi. Ma veniamo al dunque. Creata una windows forms con un button e una label, voglio fare in modo che alla pressione del button venga visualizzato il messaggio di attesa, e solo alla fine dell'operazione vedere il risultato.

Con il BackgrounWorker la cosa è semplice, anzi, possiamo anche aggiornare l'interfaccia grafica durante l'elaborazione e con poco altro codice permettere il blocco dell'operazione.

backgroundWorker1.DoWork += backgroundWorker1_DoWork;
backgroundWorker1.RunWorkerCompleted += backgroundWorker1_RunWorkerCompleted;
backgroundWorker1.ProgressChanged += backgroundWorker1_ProgressChanged;

Nella prima riga specifico quale evento sarà chiamato quando dovrà essere avviata l'operazione pesante. La seconda sarà chiamata alla fine della pesante operazione. La terza, che possiamo invocare noi dal primo evento, per aggiornare eventualmente l'interfaccia grafica. Sì, perché solo questo evento e il secondo potranno aggiornare l'interfaccia grafica.

backgroundWorker1.WorkerReportsProgress = true;
backgroundWorker1.WorkerSupportsCancellation = true;

Queste righe, invece, attivano la possibilità di avviare il terzo evento e di poter bloccare le operazioni da interfaccia utente. Obbligatori, sono solo l'evento DoWork e RunWorkerCompleted.

Ma è ora di cominciare. Ecco l'evento del Button nella pagina:

private void button1_Click(object sender, EventArgs e)
{

    // Disabilito il button di avvio
    button1.Enabled=false;
    // Abilito il button di cancel
    button2.Enabled=true;
    backgroundWorker1.RunWorkerAsync(100);
}

Possiamo passare un parametro facoltativo al nostro codice, di qualsiasi tipo. Però innanzitutto disabilitiamo il button in modo che non si possa cliccare più volte sopra di esso. Con il method RunWorkerAsync, avviamo il codice presente nell'evento DoWork.

void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
    // Leggo il parametro
    int val = int.Parse(e.Argument.ToString());

    // Richiedo il Backgroundworker che ha richiamato l'evento
    // per poter richiamare l'evento per l'aggiornamento
    BackgroundWorker worker = sender as BackgroundWorker;

    for (int i = 0; i < val; i += 1)
    {
        // Richiama l'evento memorizzato in ProgressChanged
        // Questo evento accetta come parametro un valore
        // compreso da 0 a 100 (%)
        worker.ReportProgress(i);
        System.Threading.Thread.Sleep(40);

        // Controllo se è stato premuto il button di Cancel
        if (worker.CancellationPending)
        {
            e.Cancel = true;
            break;
        }
    }
    // Infine passo l'eventuale risultato all'evento finale
    e.Result = DateTime.Now;
}

Per aggiornare la window durante l'elaborazione viene utilizzato il method ReportProgress che accetta come parametro un intero compreso tra zero e cento (percentuale di elaborazione). Ecco il codice usato dall'esempio:

void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
// Visualizzo aggionamento percentuale nella label
label1.Text = string.Format("{0}%", e.ProgressPercentage);
}

Interessante, di questo evento, che possiamo aggiornare qualsiasi oggetto nella window, anche datagridview con il simpatico effeto grafico di popolamento dello stesso. Non potendolo passare come parametro è sufficiente definire la fonte dati dello stesso come property nella classe della pagina,

Ed ecco il codice eseguito automaticamente alla fine di questo codice:

void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    // Controllo se l'operazione è stata bloccata dall'utente
    if (e.Cancelled)
    {
        label1.Text = "Operation Cancelled";
    }
    else
    {
        // Visualizzo la data passata dalla elaborazione
        DateTime dt = DateTime.Parse(e.Result.ToString());
        label1.Text = dt.ToString();
    }

    // Riattivo il button di avvio
    button1.Enabled = true;

    // E disabilito il button di cancel
    button2.Enabled = false;
}

L'operazione di Cancel è collegato con un normale evento di button2:

private void button2_Click(object sender, EventArgs e)
{
backgroundWorker1.CancelAsync();
}

Banalmente, segnala al nostro oggetto che è stata richiesta la fine dell'elaborazione del nostro codice. Questo lo possiamo controllare, come si vede sopra, controllando l'evento CancellationPending. Ovviamente questo operazione è controllabile solo se è in elaborazione il nostro codice. Eventuale richieste pesanti al DB non potranno essere bloccate fino alla restituzione dei dati (senza scomodare ancora i delegate asincroni).

Me lo sono segnato.

Tags: .NET Framework, .NET Framework 2.0, Windows Client

Un po' di benchmark tra Linq, Entity Framework e Nhibernate

2008-10-12T12:46:17+00:00

In un blog di qualche tempo fa avevo messo a confronto le prestazioni tra Linq e l'Entity Framework in scrittura (e lettura). Anche in questo caso moltissime persone (una) mi hanno chiesto come si comportasse Nhibernate nel confronto.

Innanzitutto, prima di sentenziare verità assolute che non possiedo, premetto che NON sono affatto un esperto di Nhibernate: con esso ho solo giocato in piccole applicazioni di test per testare le prestazioni di questo famoso e ottimo ORM.

Per evitare discussioni riposto la struttura del database e i file di configurazione utilizzati nel mio test, in modo che gente più esperta di me di questo ORM, possa segnalarmi eventuali errori:

Ed ecco i file di mapping usati per Nhibernate. Per la tabella Padri:

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2"
assembly="EntitiesX"
namespace="EntitiesX"
default-lazy="false"
>
<class name="Padri" table="Padri">
<id name="Id" unsaved-value="0" >
<generator />
</id>
<property name="NomePadre" />
<bag name="Figli" cascade="all-delete-orphan"
generic="true" lazy="false" inverse="true"
fetch="join">
<key column="IdPadre" />
<one-to-many />
</bag>
</class>
</hibernate-mapping>

Per la tabella Figli:

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2"
assembly="EntitiesX"
namespace="EntitiesX"
default-lazy="false"
>
<class name="Figli" table="Figli">
<id name="Id" unsaved-value="0" >
<generator />
</id>
<property name="NomeFiglio" />
<many-to-one name="Padri" column="IdPadre" />
</class>
</hibernate-mapping>

Per l'inserimento ho usato questo banale codice:

using (ISession session =sessionFactory.OpenSession() )
{
foreach (var padre in coll) session.SaveOrUpdate(padre);
session.Flush();
}

Come nel blog precedente, innanzitutto sono state create cento entity Padri, con ognuna di essa cento entity Figli.

Ecco la tabella prestazionale definitiva (rifatta con il carico attuale del computer):

Stored procedure	Linq To Sql	Entity Framework	Nhibernate
6.85s	24,10	14,68	13,87

Nhibernate, dall'alto dei suoi anni di sviluppo, batte entrambe le tecnologie Microsoft anche se di poco.

Ora vediamo come si portano tutti in lettura. Il codice ripopola tutti gli oggetti con il contenuto delle tabelle. Nel caso di Nhibernate, il codice è il seguente:

using (ISession session = sessionFactory.OpenSession())
{
IList<EntitiesX.Padri> coll=session.CreateCriteria(typeof(EntitiesX.Padri)).List<EntitiesX.Padri>();
// Check collections
}

Ed ecco i risultati:

Linq To Sql	Entity Framework	Nhibernate
0,31s	0,91s	0,65s

L'Entity Framework ne ha da strada da fare sul suo diretto e storico rivale...

Tags: .NET Framework, .NET Framework 3.5, ADO.NET Entity Framework, LINQ to SQL, NHibernate, LINQ

[OT] Questa mattina...

2008-09-30T19:32:20+00:00

Capita a volte di risvegliarsi senza sapere non solo in quale casa siamo, ma neanche la città o paese! Tutto ciò dura per pochi secondi, quindi ritornano alla mente i ricordi di cosa ci ha condotto lì e tutto torna alla normalità. Al mio risveglio questo plumbeo paesaggio:

Mi ha fatto tornare alla mente, anche se non ne capisco il collegamento, una novella di Poe:

... Lo spettrale Pericolo cui ero
soggetto mi perseguitava notte e giorno. Nella prima le torture della
meditazione erano eccessive, nel secondo intollerabili. Quando le tetre
Tenebre avviluppavano la Terra, io allora rabbrividivo al solo terrore di
dover ancora pensare... rabbrividivo come rabbrividiscono sul carro
funebre gli ondeggianti pennacchi. Allorche' la Natura non riusciva piu'
a sopportare lo stato di veglia, era solo dopo uno sforzo violento che io
cedevo al sonno, poiche' mi agghiacciava il timore di trovarmi al
risveglio abitatore di una tomba. E allorche' infine cadevo in una specie
di sonnolenza, cio' era solo per sentirmi trasportato immediatamente in
un mondo di fantasmi, al disopra del quale si librava sovrana, unica,
sepolcrale, l'Idea...

Tags: Off Topic

Triplet class non è un oggetto curioso, è utilissimo!!!

2008-09-12T15:11:08+00:00

Esiste dalla versione 1.0 del Framework. Lo ritendo ~~l'oggetto più curioso all'interno dello stesso~~ un oggetto utilissimo per l'uso del viewstate e la creazione dei custom control così come spiegano nei commenti Cristian e Daniele.

Accetta tre parametri object. Esempio da MSDN:

Triplet circle = new Triplet(5, 7, 3);
lblCircle.Text = "X position: " + circle.First +
"<br />Y position: " + circle.Second +
"<br />Radius: " + circle.Third;

Triplet labels = new Triplet(Label1, Label2, Label3);
Label1.Text = "Type: " + labels.First.GetType().ToString();
Label2.Text = "ToString: " + labels.Second.ToString();
Label3.Text = "HashCode: " + labels.Third.GetHashCode();

~~Sono basito.~~

~~Essendo venerdì un po' di leggerezza, no?~~

Blog modificato per evitare il linciaggio! :)

Entity Framework e stranezze(*)

2008-09-12T07:11:33+00:00

Entity:

Codice:

// Step 1
var coll2 = (from c in context.Men.Include("Women")
             select c).First();
//
// Visualizza item;
//----------------------------------------------------------------
//
// Step 2
//
coll2.Age++;
coll2.Women.Age++;
//
// Visualizza item;
//-----------------------------------------------------------------
//
// Step 3
//
var coll3 = from c in context.Men.Include("Women")
            select c;
foreach (var item in coll3)
{
    // Visualizza item;
}

Nel primo caso come age della prima entity e della seconda, viene visualizzato il contenuto iniziale della tabella (viene eseguita la query visibile grazie al profiler):

1 e 1

Al secondo step viene visualizzato:

2 e 2

Domanda finale... Che cosa viene visualizzato allo step 3? Do un aiuto, con il profiler è visibile la query di select delle due entity.

Dunque?

Qual è la risposta?

Sto aspettando...

Be', si potrebbe pensare che visualizzi ancora 1 e 1 visto che esegue richiede le due tabella al database che ritornano i valori iniziali (proprio ciò che avviene), ma invece viene visualizzato:

2 e 2!!!

Ma perché esegue la query se alla finfine prende ancora i dati aggiornati in precedenza?

Un attimo di pensieri alterni...

Giungo alla conclusione che esegue queste query con controllare la consistenza dei dati, per vedere se eventualmente il record sul db è stato modificato da qualcosa d'altro. Anzi, oso di più, mi convinco che sia questo il motivo.

Avvio il profiler e l'enterprise manager.

Eseguo i due step, blocco, modifico il record esternamente, e eseguo l'ultimo passo. La query viene eseguita e presi i dati... ma non accade nulla!!! Nulla di nulla!

Non mi arrendo. Modifico le proprietà delle due entity. Imposto Age come Concurrency Mode a Fixed. Riprovo. Non cambia nulla... uff... Per avere aggiornati i dati dobbiamo forzare la cosa:

//
// Step 3
//
var coll3 = from c in context.Men.Include("Women")
            select c;
foreach (var item in coll3)
{
    context.Refresh(System.Data.Objects.RefreshMode.StoreWins, item);
    context.Refresh(System.Data.Objects.RefreshMode.StoreWins, item.Women);
    // Visualizzo dati
}

Buono a sapersi, ma perché la query non la fa in questo caso e solo questo?

(*) La parola strano, che vuol dì? Qualcosa che non è normale, qualcosa al di fuori di ogni schema? Ma in sé, che significa? E' una prola senza significato. Cos'è strano? Ciò che fuori dal normale senso civico e comportamentale? Chi ha creato l'Entity Framework saprà dirmi il perché di questo comportamento che riterrà normale... dunque è strano ciò che penso io! Strano è una parola inutile, da cancellare. Che parola odiosa.

Tags: .NET Framework, .NET Framework 3.5, ADO.NET Entity Framework, LINQ

Entity Framework. Una tabella due Entity senza discriminazioni

2008-09-06T08:52:04+00:00

In un blog precedente avevo parlato del Single Table Inheritance. Grazie ad un campo apposito è possibile decidere a quale entity farà parte il record di quella nostra tabella.

Il problema che sto cercando di risolvere in questi giorni si basa sul quesito:

E' possibile dividere una tabella in due entity senza questo campo?

Ma prima che subentri la confusione, il mio obbiettivo non è quello di creare due entity parallele come nel caso di quel blog (TextContents e LinkContents), ma una entity di base da cui deriva un'altra entity. Per esempio, da questa tabella:

*Nome campo*	*Tipo*
Id	int
Title	nvarchar(50)
LongDescriptions	ntext

Vorrei ottenere una struttura come questa (poi spiegherò il perché):

Il problema che mi ero posto è molto semplice: in caso volessi visualizzare tutti i record della tabella in un menu di scelta, la richiesta dei dati presenti in un'unica entity avrebbe richiesto tutti i campi anche quelli ntext (che potrebbero contenere, per assurdo, mega di documenti di testo), come si può evitare questo?

Ah, dimenticavo, visto che questi dati devono attraversare dei layer dell'applicativo, non voglio usare gli anonynous type, altrimenti sarebbe troppo facile scrivere:

var coll=from d in Context.Documents
select new { Id=d.Id, Title=d.Title };
return coll;

Anche se questa soluzione porta l'Entity Framework a inviare la giusta query al database:

SELECT
1 AS [C1],
[Extent1].[Id] AS [Id],
[Extent1].[Title] AS [Title]
FROM [dbo].[Descriptions] AS [Extent1]

Una soluzione che mi hanno suggerito è creare una classe che ospiti solo quei dati:

public class Elenco
{
public int Id { get; set; }
public string Title { get; set; }
}

var coll = from c in context.Descriptions
select new Elenco { Id = c.Id, Title = c.Title };
foreach (var item in coll)
{
Response.Write(string.Format(
"{0} {1} <br />",
item.Id,
item.Title
));
}

Può andare. Si potrebbe trovare un'altra soluzione con l'uso delle viste. Creata questa vista:

select Id,Title from Descriptions

Si possono creare due entity distinte all'interno dell'editor di Visual Studio 2008:

Lo schifo è che sono due entity distinte, ma risolvono in parte il problema. Segnalo che, importata questa vista nell'editor, i campi vengono visti entrambi come key. Non è sufficiente modificare le proprietà nell'editor, è necessario aprire il file .edmx con un editor xml e cancellare la doppia key:

Poco sopra nell'xml è possibile vedere com'è importata la vista:

<EntitySet Name="DescriptionsTitles" EntityType="TestEntitiesModel.Store.DescriptionsTitles" store:Type="Views" store:Schema="dbo" store:Name="DescriptionsTitles">
<DefiningQuery>SELECT
[DescriptionsTitles].[Id] AS [Id],
[DescriptionsTitles].[Title] AS [Title]
FROM [dbo].[DescriptionsTitles] AS [DescriptionsTitles]
</DefiningQuery>
</EntitySet>

Questo comporta, alla richiesta dei dati, l'esecuzione di questa query:

SELECT
[Extent1].[Id] AS [Id],
[Extent1].[Title] AS [Title]
FROM (SELECT
[DescriptionsTitles].[Id] AS [Id],
[DescriptionsTitles].[Title] AS [Title]
FROM [dbo].[DescriptionsTitles] AS [DescriptionsTitles]) AS [Extent1]

Alla fine c'è la soluzione compatibile con l'Entity Framework e la mia necessità. Ma si deve mettere mano alla struttura del database. Si deve dividere quella tabella in due, spostando il campo LongDescriptions nella seconda naturalmente collegando il tutto. L'EF non farà una piega e vedrà il tutto in modo corretto e otterrei ciò che voglio.

Posso avere tutto ciò che voglio? No, non è possibile.

Tags: .NET Framework, .NET Framework 3.5, ADO.NET Entity Framework, LINQ