di .NET e di altre amenità

Non so ancora esattamente a cosa mi potra' servire, ma esplorando l'entity framework ho scoperto che e' possibile generare le classi sulle quali sono mappate le entita' con poche righe di codice. Ho fatto la scoperta andando a disassemblare con Reflector il tool edmgen.exe che di solito viene usato per generare le entita' a partire dal modello concettuale, ovvero dal file con estensione CSDL.

Una volta che abbiamo aggiunto un riferimento a System.Data.Entity.Design possiamo accedere ad una classe EntityClassGenerator che con poche customizzazioni e' in grado di generare appunto il codice delle suddette classi. Ecco come:

   1: class Program

   2: {

   3:     static void Main(string[] args)

   4:     {

   5:         LanguageOption options = LanguageOption.GenerateCSharpCode;

   6:  

   7:         EntityClassGenerator generator = new EntityClassGenerator(options);

   8:  

   9:         generator.GenerateCode(@"C:\Files\Entities.csdl", @"C:\Files\Generated.cs");

  10:     }

  11: }

Il metodo Generate() dispone anche di altri overload che consentono ad esempio di generare il file di destinazione in memoria per poi magari inserirlo in un assembly da compilare.

Come gia' detto al momento non ne vedo una utilita' pratica ma suppongo che pensandoci bene una la possiamo anche trovare. E se non fosse cosi' perlomeno qualcosa di nuovo lo ho imparato...

Una delle cose che capitano piu' spesso realizzando l'interfaccia di un software e' la necessita' di estrarre delle coppie nome-valore per popolare oggetti quali le DropDownList, ma anche CheckBoxList e altri tipi di controllo. Quello che succede spesso e' che ci vediamo costretti a scrivere delle query ad-hoc, magari piu' di una per ogni tabella in modo tale da ottenere solo ed esclusivamente i due campi che ci servono.

Mediante l'uso di Linq2SQL e di Linq2Entities questo compito puo' essere semplificato notevolmente scrivendo un metodo che ci permette di personalizzare la lista estratta nelle sue varie "dimensioni".

Tipicamente abbiamo bisogno di:

1. Estrarre solo due campi da una tabella che potenzialmente ne contiene molti. Ad esempio solo ID e Nome da una tabella di Province escludendo i dati di estensione, popolazione, etc...
2. Filtrare gli elementi secondo semplici criteri. Ad esempio solo le Provincie di una determinata Regione
3. Ordinare gli elementi in modo arbitrario. Ad esempio per Nome visualizzato piuttosto che per Estensione  o numero di abitanti

Grazie all'uso di Lambda Expression con il Framework 3.5 e' possibile esporre le caratteristiche elencate come parametri di un metodo e unendo a questo le potenzialita' dei generics ottenere facilmente qualunque lista in tempo pressoche' nullo. Ecco le due versioni del metodo

   1: // LINQ To SQL

   2:  

   3: static IEnumerable<Item> GetItems<T>(

   4:     Func<T, string> keyFunc,

   5:     Func<T, string> textFunc,

   6:     Func<T, bool> whereSelector,

   7:     Func<T, object> sortFunc)

   8:     where T : class

   9: {

  10:     using (ClassesDataContext dc = new ClassesDataContext())

  11:     {

  12:         return (from entity in dc

  13:                     .GetTable<T>()

  14:                     .Where(whereSelector)

  15:                     .OrderBy(sortFunc)

  16:                 select new Item

  17:                 {

  18:                     Key = keyFunc.Invoke(entity),

  19:                     Value = textFunc.Invoke(entity)

  20:                 }).ToArray();

  21:     }

  22: }

  23:  

  24: // LINQ TO Entities

  25:  

  26: static IEnumerable<Item> GetItems<T>(

  27:     Func<T, string> keyFunc, 

  28:     Func<T, string> textFunc, 

  29:     Func<T, bool> whereSelector, 

  30:     Func<T, object> sortFunc)

  31:     where T : EntityObject

  32: {

  33:     using (Entities entities = new Entities())

  34:     {

  35:         return (from entity in entities

  36:                     .CreateQuery<T>("[" + typeof(T).Name + "]")

  37:                     .Where(whereSelector)

  38:                     .OrderBy(sortFunc)

  39:                 select new Item

  40:                 {

  41:                     Key = keyFunc.Invoke(entity),

  42:                     Value = textFunc.Invoke(entity)

  43:                 }).ToArray();

  44:     }

  45: }

Il metodo, in entrambe le versioni espone 4 parametri che ci suggeriscono l'uso di una Lambda Expression:

• KeyFunc specifica la chiave
• textFunc specifica il valore
• whereSelector ci consente di selezionare gli elementi.
• sortFunc specifica il campo con cui ordinare gli elementi

L'unica sostanziale differenza tra i metodi per L2S e L2E e nel metodo che usiamo per ottenere accesso alla "tabella" grezza degli elementi. Mentre il DataContext di L2S espone un metodo GetTable<T>() con L2E dobbiamo creare una semplice query che ha come parametro il nome della entity stessa e per questo dobbiamo usare CreateQuery<T>(query);

Ecco come usare il metodo:

   1: static void Main(string[] args)

   2: {

   3:     foreach (Item item in GetItems<Course>(

   4:         a => a.CourseID.ToString(), 

   5:         b => b.Title, 

   6:         c => true, 

   7:         d => d.Title))

   8:     {

   9:         Console.WriteLine(item.Key + " - " + item.Value);

  10:     }

  11:  

  12:     Console.ReadLine();

  13: }

I parametri specificati otterranno una lista di Item - definiti come classi con una proprieta' Key e una Value - dove la chiave sia il valore di CourseID e il testo e' dato da Title. Specificando "true" come terzo parametro otterremo tutti gli elementi della tabella. Infine con il quarto parametro chiediamo di ordinare per Title.

Ho usato questa tecnica in un progetto recente in cui avevo molte form zeppe di DropDownList e devo dire che mi ha fatto risparmiare un bel po' di tempo. Il bello e' che scrivere i parametri e' molto semplice perche' l'intellisense si accorge del tipo che stiamo usando e quindi ci propone i membri della classe tra i quali possiamo comodamente scegliere.

Qualche giorno fa sono riuscito finalmente a sistemare un po' il mio studio a casa e quindi da un po' ho iniziato a lavorare su tastiera e monitor separati e non piu' direttamente sul portatile che invece rimane a fianco come secondo monitor.

Ecco che mi sono trovato di fronte l'ardua scelta di adottare una tastiera il cui feedback soddisfi il mio esigente tatto. Purtroppo mi sto rendendo conto che scegliere una tastiera adeguata e' un compito difficile. Nonostante abbia acquistato ben tre tastiere (2 Microsoft e 1 Logitech), l'unica che mi da la necessaria soddisfazione e conseguente velocita' e' quella "originale" del portatile. Il problema e' sempre lo stesso. La mia mano ha necessita' di una tastiera che non "opponga resistenza". Questo purtroppo non e' vero per 2 su 3 delle tastiere e tra esse la Logitech e' in assoluto la peggiore che oltre a "dimenticarsi" di rispondere alle mie dita un po' troppo spesso dato che richiede una notevole pressione, mi infastidisce con un clack-clack odioso. L'ultima tastiera, la Microsoft Natural Ergonomic Keyboard 4000 ha un feedback decisamente migliore ma non ancora quello che mi aspetterei. Pero' il suo uso mi regala un fastidioso affaticamento alle mani che probabilmente ormai sono assuefatte alle tastiere normali e rifiutano l'ergonomicita'.

Ora, reduce da tre tastiere e impossibilitato a continuare a provare tastiere dato il loro non irrisorio costo mi chiedo quale sia la tastiera migliore che si puo' trovare sul mercato. Sono anche disposto a spendere un po' dato che la qualita' del mio lavoro dipende in gran parte da questo strumento. Chissa se qualcuno di voi non abbia qualche preziosa indicazione da darmi...

Sono reduce di una di quelle giornate altamente improduttive, anche se in effetti ho lavorato più (e più intensamente) del solito… Quest’oggi in azienda abbiamo scoperto che un PC su cui abbiamo recentemente installato Visual Studio 2008 (e non ancora la SP1) improvvisamente non riusciva più a connettersi ad un processo in debug su un Device Windows CE.

Partendo con il classico F5 il problema non si pone, il processo viene agganciato e il debug va a buon fine. Invece, dal menù di Debug>Attach to a process... si ottiene un errore criptico per quanto stringato e inutile: "Unable to attach to the process". Io e i colleghi Andrea e Mirco abbiamo perso l'intera giornata cercando di capire cosa non funzionasse e alla fine ci siamo resi conto che il problema non affliggeva solo una macchina ma anche altre nella rete. Alla fine, stremato dagli inutili tentativi la soluzione si è presentata così inattesa da risultare inverosimile.

La chiave che accomuna le macchine che presentavano il problema è la presenza dei "Silverlight 2.0 Tools for Visual Studio 2008" e l'aver notato questa peculiarità è stata la chiave per risolvere il problema. Il fatto è che questi Tools (che sono tuttora in beta) installano una patch per Visual Studio 2008 (KB950630). Tale patch è così fantomatica che non se ne trova nemmeno traccia sul sito Microsoft. Il link alla Knowledge base che si trova nell'About box di VS2008 è semplicemente bucato. Inoltre il disinstallare i tools non è sufficiente a risolvere il problema; infatti la patch rimane installata.

Disinstallate a mano la KB950630 e tutto magicamente tornerà a funzionare.

Morale? Se sviluppate con Silverlight 2.0 non potete fare l'attach dei processi con Windows CE e naturalmente se sviluppate con Windows CE non potete installare i necessari tools di Silverlight.

Non ho commenti in merito (o meglio quelli che mi vengono non si possono scrivere...). Lascio a voi trarre le conclusioni e magari dire due parole al figuro che ha scritto quanto vi riporto nel suo piu' recente post... (grazie a Marco per la segnalazione)

Link: Honesty as a comparative advantage: Italy vs Spain

Dal blog di Somasegar arriva la notizia che in questi giorni Codeplex compie 2 anni. Con più di 1000000 di hit al giorno, 5000 progetti e ben 7 server TFS direi che il compleanno va festeggiato con tutti gli onori.

http://blogs.msdn.com/somasegar/archive/2008/08/06/codeplex-celebrates-its-2nd-birthday.aspx

Pare che sia stato aperto un blog dal team di DeepZoom

http://blogs.msdn.com/lutzg/

Stiamo a vedere.

Sto seriamente pensando se sia il caso di guardare le Olimpiadi in televisione quest'anno.

Credo che di tutte le manifestazioni sportive televisive le Olimpiadi siano le uniche che riescono a catalizzare la mia attenzione, nonostante la inutile dose di campanilismo che nel nostro paese si portano dietro. Quest'anno però c'è il fatto che partecipare all'evento, anche solo guardandolo alla televisione può suonare come l'essere complice di uno dei peggiori regimi dei tempi moderni: la Cina.

Devo dire perciò che sono molto indeciso. Mi piace l'idea di cogliere l'occasione per mostrare a mia figlia gli innumerevoli sport che vi fanno parte, anche i più esotici, e considerato che la prossima volta avrà 10 anni, potrebbe essere un'occasione irripetibile nella sua precocità. Ma questo giustifica il chiudere un occhio sul mancato rispetto dei diritti umani di almeno un miliardo di persone?

E non va nemmeno dimenticato che il Dalai Lama ha chiesto ufficialmente di non boicottare le Olimpiadi...

Ci penso su... ma mi piacerebbe sapere come la pensate voi.