MVP Wannabe!

"Lesser" less per c# e asp.net MVC

2009-06-18T20:31:18Z

Come integrare facilmente un preprocessor per css in asp.net MVC premessa: Tutto è nato da questo post su EDIT (il blog di html.it): http://blog.html.it/18/06/2009/less-estendere-i-css Ho pensato che sarebbe stato comodo avere una specie di pre-compilatore per i css che facesse esattamente quello che Cesare Lamanna ha esposto, ovvero aggiungere ai css le costanti e i mixins integrato nel mio sito in asp.net mvc ...

Sort su un' interfaccia di una lista generica utilizzando una lambda per definire il campo da filtrare su un oggetto qualsiasi

2009-01-29T21:50:26Z

Giocherellando un po su stackoverflow, ho notato la seguente domanda:

http://stackoverflow.com/questions/485567/avoiding-code-repetition-when-using-linq

In pratica viene chiesto un parere su come separare la logica di selezione di un campo da ordinare all' interno di una funzione di sort generica in maniera da evitare la riscrittura dello stesso codice, che differisce, sostanzialmente, solo ed esclusivamente per il campo in cui la sort agisce.

La soluzione proposta da Matt Hamilton và più che bene, se non che è fortemente legato ad una lista definita privatamente nella classe e che comunque è legata ad una classe di selezione che è a sua volta fortemente legata all' oggetto a cui si fa il sorting, nulla di male in tutto ciò, se uno vuol far il sorting, conosce l' oggetto del quale vuol ordinare un determinato campo.

Ho comunque voluto cimentarmi con un astrazione maggiore del Sort richiesto, aggiungendo un metodo Sort all' interfaccia generica IList<T>

http://stackoverflow.com/questions/485567/avoiding-code-repetition-when-using-linq/491449#491449

public static class extIList { public static IList<T> Sort<T, TKey>(this IList<T> list, SortOrder sortOrder, Func<T, TKey> keySelector) { if (sortOrder == SortOrder.Descending) { return list.OrderByDescending(keySelector).ToList(); } else { return list.OrderBy(keySelector).ToList(); } } }

In questa maniera si può utilizzare la funzione di sort su un qualsiasi oggetto,

nell' esempio ho usato un oggetto Person che ha due proprietà Name e Surname:

IList<Person> list = new List<Person>(); list.Add(new Person("David","Beckham")); list.Add(new Person("Gennaro","Gattuso")); list.Add(new Person("Cristian","Carlesso")); list = list.Sort(SortOrder.Descending, X => X.Name);

Comunque siccome la logica di sorting è delegata alla parte evidenziata e siccome è slegata completamente dal tipo di oggetto che le viene passato, è possibile utilizzare la sort su un qualsiasi altro campo di un qualsiasi altro oggetto ;-)

Object To Generic Pattern

2008-07-08T06:07:41Z

Ultimamente sto usando Ninject che usa i generics in un modo che mi ha fatto ripensare al mio codice, in particolare mi sono imbattuto in un pattern che può essere riassunto cosi:

Ogniqualvolta un metodo ritorna un object è molto probabile che possa tornare un generics

Perchè?

Se un metodo ritorna un oggetto è molto probabile che si tratti di un metodo di una classe di factory, visto che object è il padre di tutti gli oggetti, fino all avvento dei generics risultava naturale, ritornare o un interfaccia nota, o un object generico.

Per esempio mi è capitato di usare questa metodologia quando ho creato uioc, un container ioc per cf2.0 ( http://codeplex.com/uIoC ) , che piu che un container ioc è una superfactory che richiama gli oggetti tramite stringa anzichè nome.

Comunque indipendentemente da questo, ritornare un object comporta il quasi sicuramente dovere fare un cast dove si richiama il metodo, esempio:

public class Pippo{

    public object Get(string id){

        return this.container[id];


....

Pippo p = new Pippo();

p.initialize();


IList lista = (IList)p.get("Lista di sviluppatori javascript");

se volessimo aggiungere uno sviluppatore dovremo fare o un 

lista.add("Andrea Giammarchi");

oppure il scomodissimo

((Ilist)p.get("Lista di sviluppatori javascript")).add("Andrea Giammarchi");

se invece cambiassimo il metodo in

public T Get<T>(string id){

    return this.container[id];

potremo scrivere

p.get<IList>("Lista di sviluppatori javascript").add("Andrea Giammarchi");

non abbiamo quadagnato molto in termini di codice scritto, ma abbiamo 2 vantaggi,
il primo è che l intellisense ci fornisce direttamente i metodi una volta chiusa la parentesi, senza dover esplicitare il cast
il secondo abbiamo eliminato il ~~boxing/unboxing~~ Cast dell IList che ci permette di non avere cast non validi a runtime
e nel contempo dovrebbe ottimizzare un po la velocità di esecuzione ( a scapito di un maggiore grandezza dell'eseguibile )

...e se dovessimo ritornare null?

potrebbe essere in metodi che ritornano un object che in caso di errore in creazione e affini si voglia tornare null..
usando un generics ovviamente non è possibile tornare null, ci viene in soccorso la keyword default

esempio:

if(hoAvutoUnProblema){

    // return null

    return default(T);

che ritorna un valore di default.

Potremo applicare questa metodologia anche quando, per esempio, si deve passare un oggetto Type come parametro ad un metodo, che ci costringe a scrivere

typeof(NostraClasse)

esempio anzichè:

public void register(string id, Type type){

    this.container.add(id, type);

..

p.register("lista di programmatori",typeof(List<string>));

avremo:


public void register<T>(string id){

    this.container.add(id,typeof(T));

..

p.register<List<string>>("lista di programmatori");

questo ci permette di scrivere qualche carattere in meno.

Eliminazione dei for in c# 3.5

2008-06-25T04:59:37Z

Recentemente ho assistito ad una serie di incontri organizzati dall' XPLabs, introduttivi al mondo dell XP.
Indipendentemente dall effettivo o meno miglioramento che si ottiene seguendo certi canoni ho voluto un attimo approfondire alcuni punti che erano rimasti in sospeso.
In particolare non avevamo approfondito la metodologia da applicare per eliminare i for dal codice,
e cosi ho trovato questa presentazione in powerpoint che spiega come farlo in Java.

Sinceramente prima di leggerlo mi ero già fatto un idea di come si potessero eliminare in c# e la soluzione illustrata non dista molto da quella che avevo pensato io che a uso dei delegati.

Comunque siccome quella slide ha ispirato questo articoletto, ho voluto citarla per correttezza.

Una soluzione piu simile a quella proposta si può ottenere molto semplicemente usando le nuove estensioni del linguaggio offerte dal nuovo compilatore c#
in particolare in questa prima parte vedremo come utilizzare le lambda expression e gli extension method per ottenere un codice "parlante" ,
libero da cicli, che ricorderà molto da vicino un listato ruby :D

prendiamo il seguente codice:

    public static void DoSomething(){

        // inizializzazione e popolamento di una collezione
        string[] pippo = new string[]{"a","b","c"};

        // per ogni elemento (iterazione)
        for(int i=0,max=pippo.Length;i<max;i++){

            // selezione
            if(pippo[i] != "b"){

                // output
                MessageBox.Show(pippo[i]);
            }
        }
    }

in poche righe abbiamo del codice che fa tante cose, ovvero
1) inizializzazione di una collezione
2) iterazione all interno della collezione
3) selezione di determinati elementi della collezione
4) output a video

Partiamo con generalizzare la funzione anzichè usare un array di stringhe (in futuro potrei volere un altro contenitore di stringhe...)

    public static void DoSomething()
    {
        // inizializzazione e popolamento di una collezione
        IEnumerable pippo = (IEnumerable)new string[] { "a", "b", "c" };

        // iterazione
        for (IEnumerator iter = pippo.GetEnumerator(); iter.MoveNext(); )
        {
            // fetch
            string tmp = iter.Current as string;

            // selezione
            if (tmp != "b")
            {
                // output
                MessageBox.Show(tmp);
            }
        }
    }

ok fino a qui nulla di strano, il codice è piu generico e abbiamo introdotto uno step aggiuntivo che è il fetch del dato corretto dalla collezione.
Vorrei partire da questo codice per migliorarlo, eliminando il for...

Mi viene in mente che tra le novità introdotte nel javascript 1.8 c'è una funzione aggiunta agli Array che si chiama reduce e che prende in input una funzione che torna vero o falso,
a cui reduce passera ogni elemento dell array e ritorna una Array scremato in base al risultato,
mi piacerebbe ottenere un qualcosa di simile..

il codice che vorrei ottenere è un qualcosa di simile a:

IEnumerable collection = pippo.Reduce(mioDelegatoDiSelezione);

...già che ci siamo ci vorrebbe un metodo Each che per ogni elemento facesse qualcosa..

Il codice che vorrei ottenere e' dunque somigliante a :

pippo.Reduce(mioDelegatoDiSelezione).Each(mioDelegatoDiOutput);

Qui un classico programmatore OO penserebbe a come poter estendere pippo senza violare l' information hiding...

"Il Vero Programmatore" C# invece è al corrente delle innovazioni apportate al compilatore 3.0,
in particolare delle "extension method", che permettono di estendere una classe base ... senza realmente estenderla,
infatti gli extension method non sono null' altro che del "syntactic sugar" introdotto nel compilatore che permette di scrivere anzichè:

MetodoStatico (istanzaOggettoBase, parametri...);

direttamente

istanzaOggettoBase.MetodoStatico(parametri...);

dando dunque l impressione di aver esteso una classe :D

quindi creeremo in un diverso namespace una classe statica e pubblica (che chiameremo ad esempio ExtensionMethods):

public static class ExtensionMethods{
    public static IEnumerable Reduce(this IEnumerable me, Func<object,bool> rule){

        // creo una lista che conterra' l IEnumerable risultante
        List<object> result = new List<object>();

        // itero sulla collezione (non sto eliminando il for, ma a mio avviso non occorre :D )
        for(IEnumerator iter = me.GetEnumerator();iter.MoveNext(); ){

            // salvo l oggetto in una variabile temporanea per caching e comodita' ;D
            object tmp = iter.Current;

            // controllo se l oggetto passa la regola
            if(rule(tmp)){

                // aggiungo nella collezione finale l oggetto
                result.Add(tmp);
            }
        }

        // ritorno la lista scremata
        return result;
    }
}

adesso abbiamo esteso IEnumerable aggiungendo un metodo Reduce che vuole in ingresso un oggetto di tipo
Func<object,bool>, ovvero un delegato di un metodo che vuole in ingresso un oggetto e restituisce un valore booleano

In questo momento utilizzando le lambda expression possiamo scrivere:

    public static void DoSomething()
    {
        IEnumerable pippo = (IEnumerable)new string[] { "a", "b", "c" };

        //per ogni elemento della lista scremata
        foreach (string tmp in pippo.Reduce(
            meBoxed =>{
                var me = meBoxed as string;
                return me != "b";
            })
        ){
            //mostralo a video
            MessageBox.Show(tmp);
        }

    }

Ora pero' aggiungiamo anche un extension Method Each

public static void Each(this IEnumerable me, Action<object> action){

    //ciclo sulla lista
    for(IEnumerator iter = me.GetEnumerator();iter.MoveNext(); ){

        //applico l azione all elemento della lista
        action(iter.Current);
    }
}

..da notare che ora volendo potremo riscrivere Reduce come:

public static IEnumerable Reduce(this IEnumerable me, Func<object,bool> rule){
    List<object> result = new List<object>();

    me.Each(item=>{
        if(rule(item)){
            result.Add(item);
        }
    });
    return result;
}

..si commenta da sola!

bene ora il codice di DoSomething diventerà :

public static void DoSomething(){

    IEnumerable pippo = (IEnumerable)new string[]{"a","b","c"};

    pippo.Reduce(meBoxed =>{
        var me = meBoxed as string;
        return(me != "b");
    }).Each(item =>{MessageBox.Show(item);});

}

E ancora meglio:

    private Func<object,bool> excludeStringB = meBoxed =>{
        var me = meBoxed as string;
        return me != "b";
    };

    private Action<object> showMessageBox = item =>{MessageBox.Show(item);};

    public static void DoSomething()
    {
        IEnumerable pippo = (IEnumerable)new string[] { "a", "b", "c" };
        pippo.Reduce(excludeStringB).Each(showMessageBox);
    }

volendo si possono spostare le 2 lambda in 2 classi diverse (ad esempio Filter e Action), ma per questo esempio credo possano bastare cosi :D

svantaggi di questa tecnica?
Stiamo ciclando 2 volte sulla stessa collection, quindi c'e' sicuramente uno svantaggio in termini di prestazioni
gli oggetti tra di loro hanno ancora un legame forte, vedremo nel prossimo post riguardante la IOC come poter separare
la logica di creazione definendo le dipendenze esternamente (utilizzando NInject ;) )

Inferring, extension method and spaghetti 2.0

2008-03-06T09:12:09Z

A volte una discussione tra due veri programmatori può essere una discussione veramente terra a terra anche quando si parla di argomenti complessi, per esempio ieri ero in chat con un amico che per mantenere anonimo chiamerò Giammarchi A.
(anzi no, così mi sa che si capisce) dicevo, per farlo restare anonimo lo chiamerò Andrea G, è iniziato un discorso di cui vi posto un piccolo estratto (leggermente modificato) :

[... si parlava del linguaggio cobra ...]

me: ...anche in c# 3.0 hanno aggiunto l'inferenza :p
e si ottiene usando var
var pippo = new String("andr3a");
Andrea: lo so, me l'hanno rubata
questo in ESharp posso già farlo ma su C# 1,2 e non sul 3...
class var {} è l'abstract di Object,
che è la base di Array, String, Number, Function, etc
in ESharp ho già tutto
[..segue discussione semiseria su come sostituire la sua classe var con un altra che non diventi una parola chiave in futuro :D..]
me: inferred praticamente puoi creare una variabile senza esplicitarne il tipo
e il compilatore lo assegna alla prima volta in cui gli dai un valore
... tipo
var a= "Fregna"; il compilatore dice "Fregna" è string dunque traduce in
string a = "Fregna";
questo in fase di compilazione
[..segue discussione su come questo sia banale, ovvio scontato e già presente in n linguaggi con n tendente all infinito.. :geek:]
me: si, ma sai che vantaggio
ieri avevo un metodo che tornava stringhe
e elaborava l'array con un foreach su string[],
per esigenze mi son accorto che non andava bene,
ho cambiato il metodo ora torna un ArrayList
e non ho modificato altro codice :d

Andrea: si ma se poi alla variabile fai usare metodi di altra classe ...
non va piu nulla
var a = "Fregna";
a.pow(2);
:LOL:

me: ma è ovvio! a quel punto devi usare un interfaccia
...ah beh! Però C# ti viene in contro se proprio non vuoi modificare il codice...
si perchè hanno pure introdotto gli extension method
ora puoi fare in una classe publica e statica una cosa del genere volendo :

public static string pow(this string s,int i){
    if(i>0){
        var sb = new System.Text.StringBuilder();
        for(int a=0;a<i;a++)
            sb.Append(s);
        return sb.toString();
    }
    return "";
}
In poche parole ho appena effettuato uno spaghetti code 2.0 :D :lol:
Andrea: si
mi piace C# perchè ti crei il tuo linguaggio per i fatti tuoi

I am so high, I can hear heaven.

2008-02-29T08:40:19Z

Son tornato a casa da Milano, dall'evento Heroes di presentazione ufficiale di VS , SQL Server e Windows 2008.
L'evento si svolgeva in due giornate ma ho potuto assistere solo a quella di oggi..
per fortuna non abbiam trovato coda a Mestre... ci è andata bene sia in andata che in ritorno,
anche perchè stamattina la nebbia ha fatto lo scherzetto di fingere di esserci ;D

Oddio dire di esserci stato oggi è un po troppo, visto che ieri non ho potuto dormire (in totale ho dormito la bellezza di 4 ore) ed essere riuscito ad addormentarmi durante un paio di talk (..) comunque è stato sicuramente interessante, ho avuto modo di ripassare cose già viste (che non fa mai male) e di scoprire un paio di spunti interessanti... ed ora veniamo alle pagelle, ho seguito il filone MSDN e su questo dirò la mia modestissima opinione:

Un nuovo approccio allo sviluppo e all'accesso ai dati
Speakers: Paolo Pialorsi e Marco Russo.

Il miglior Talk della giornata, nonchè il motivo principale della mia presenza a Milano (ok, pure la NFR di VS2008 era tra i motivi principali ;D) un talk eccellente che avrei veramente approffondito per un altro paio di orette :d
comunque molto bravi i relatori voto 9 a tutti e 2

Realizzare applicazioni web innovative
Speaker: Pietro Brambati

Anche questo talk è stato molto interessante, se non fosse per qualche orrore che ho visto nell utilizzo di javascript non nella maniera corretta... ma son piccolezze che solo uno come me che ha studiato tutte le best e worst practice di javascript può comprendere (in particolar modo mi riferisco a un href="javascript: che mi ha fatto rizzare i capelli e a un altra sciocchezza che però non ricordo...)
tra l' altro in questo talk c'è stato il momento più bello della giornata, quando per qualche millesimo di secondo lo schermo è diventato nero, e l'espressione del relatore faceva intravedere il suo pensiero in quel momento :D
voto 8

Coffee Break voto 7 :D

Sviluppo di applicazioni per Microsoft Office System
Speaker:Giuseppe Guerrasio
Questo talk non era di mio interesse, e mi sono appisolato un po, quindi non posso esprimere un giudizio in tal proposito

Lunch Break voto 6 :p

La nuova frontiera delle applicazioni per l'accesso, la gestione e l'analisi dei dati
Speaker. Silvano Coriani

Un talk molto interessante riguardante SQL server, che spiegava le maggiori innovazioni apportate, ho seguito questo talk quasi fino alla fine, mi son perso gli ultimi minuti
voto: 7

La nuova interfaccia utente nelle applicazioni smart client
Speaker: Luca Regnicoli

Sinceramente non ho ben capito cosa c'entrassero gli smart client con questo talk, anche perchè son stato uno tra le 10 persone ad alzare la mano quando si è chiesto chi lavorava con gli smart client ..ma era senza dubbio interessante :D
siamo dovuti andar via un po prima della fine per evitare la coda in autostrada, comunque per quel che ho visto posso dare un 7.5 a questo talk.

Ed eccoci!

2008-02-12T06:14:26Z

Il mio blog stava diventando troppo un acrocchio di tecnologie, onde per cui ho optato per una suddivisione logica che mi permettesse di metter un po di ordine in quello che scrivo...
Ho ben pensato di creare un l' ennesimo blog su .NET qui su Ugi, la notizia forte è che questo blog sarà rigorosamente in italiano !!!

Di cosa parlerò qui? non ne ho idea, forse un po del mio progetto www.codeplex.com/uIoC
oppure di come funzioni Castle, visto che a lavoro l'ho usato un bel po, probabilmente posterò qualche esperimento con Linq e .net 3.5... insomma non ho idea di cosa ma qualcosa mi inventerò :D

per chi non mi conoscesse(ovvero il 99.9% delle persone che leggeranno questo post) , beh il mio nome è Cristian, piacere!

vi allego un po di link a ciò che ho fatto in passato:

piccolo container IoC che funziona con il compact framework 2.0: www.codeplex.com/uIoC
piccolo container IoC per JS : code.google.com/p/jsioc/downloads/list con relativo esempio: mykenta.blogspot.com/2008/01/simple-js-ioc-example-code.html

mini script per standardizzare un po il comportamento di set/getAttribute di IE:mykenta.blogspot.com/2006/07/standardise-ie-setattribute-part-2.html

links a varie pillole sul C scritte per HTML.it:
mykenta.blogspot.com/2005/06/go-go-blog.html

ah si! come tesina per gli esami delle superiori ho pure scritto un compilatore(..in pascal):
freeforumzone.leonardo.it/cartella.aspx

:lol: