novembre 2006 - Posts
Gli
"Extension Methods" sono una caratteristica sintattica introdotta dai
compilatori C# 3.0 e VB 9.0 (che NON è .NET 3.0, e qui scusatemi l'excursus ma
siamo alle solite, si rischia sempre di fare confusione con questi numeri di
versione "sovrapposti").
Sottolineo
il termine "sintattica" perchè non hanno nulla a che vedere con il
runtime, nè strutturalmente nè funzionalmente.
Molto
semplicemente, invece, sono state aggiunte regole di risoluzione.
Mi spiego,
prendendo ad esempio il codice qui sotto:
String[]
codici = new String[] {"11", "12", "13"};
Object
soloQualcheCodice = codici.Where(.....)
Quando
incontra lo statement codici.Where(), il compilatore segue le consuete regole
di lookup in modo da individuare il metodo corretto da invocare.
Regole
che, per come siamo abituati a conoscerle, in questo caso falliscono !
Non esiste
alcun metodo public instance Where in String[], nè in alcuna delle sue classi
di base in gerarchia.
Gli
extension methods sfruttano, fondamentalmente, nuove regole di lookup aggiunte
al compilatore: il quale, falliti i tentativi “standard”, va a verificare che
non esista un metodo “valido” in qualche altro posto.
L’altro
posto è una qualche classe statica, avente un metodo statico “compatibile”, e
in scope dal punto di chiamata (nel namespace corrente e su a salire in base
alle direttive using).
“Compatibile”
in questo contesto significa che, data l’invocazione (pseudo-codice):
T
istanza = ...
Int32
i = istanza.Metodo()
se non
esiste un metodo utilizzabile il compilatore cerca (in base alle regole
accennate in precedenza) un metodo con firma:
static
Int32 Metodo(this T istanza, )
E se lo
trova emette la chiamata ad esso.
Da notare che
comunque, in caso di overload, i metodi di istanza hanno la precedenza
Per
esempio, dati:
class
Esempio
{
public void Scrivi (Object o) {}
}
e
public
static class Estensione
{
public static void Scrivi(this Esempio e, Int32 numero) {}
}
Una
chiamata a:
Esempio
e = new Esempio();
e.Scrivi(10);
viene
risolta invocando la versione instance, per quanto meno “specializzata”.
E, piccola
considerazione per rispondere ad una domanda che mi è stata posta in più di un’occasione:
gli extension methods NON sono un modo per ereditare da classi sealed !
Sono
concetti parecchio differenti.
A mio
parere (si accettano ovviamente critiche e suggerimenti) farne un uso estensivo
per, che so, definire mille nuove funzionalità della classe String non è la
migliore delle cose.
Soprattutto
dal punto di vista della leggibilità e della chiarezza del codice per chi, quel
codice, non lo ha scritto.
Continuo a
preferire una chiamata esplicita, tipo
StringHelpers.DecodeString(“ciao”)
Piuttosto che
“ciao”.Decode()
Ovvio che
il secondo metodo è più conciso e diretto, ma forse è anche meno leggibile per il
lettore “occasionale” del nostro codice.
E tutti promettenti, devo dire ...
Sto giocando con LINQ da qualche tempo ormai, è un argomento che meriterebbe altro che un post (un libro ? già ce ne sono un paio in stampa, look@amazon).
Beh, comunque il fiocco azzurro (o rosa, come preferite) questa volta è per LINQ-to-XSD, come da fonte:
http://blogs.msdn.com/xmlteam/archive/2006/11/27/typed-xml-programmer-welcome-to-linq.aspx
Ho scaricato la documentazione, devo ancora installare il tutto.
Quanta roba da studiare in questo periodo ...
In a big company it's often hard to figure out who knows the answers to the questions you have.
In a small company, it's obvious who has the answers to the questions you have, but they're too busy on 5 other projects to help you.
Quanto è vero ...
Fonte:
Jeremy Miller's Blog
Nell’ultimo periodo la mia carriera professionale sta subendo una svolta abbastanza radicale (e tanto attesa quanto benvenuta).
Mi sto ritrovando a fare il docente fulltime.
Attività, quella delle docenza, che perseguivo e perseguo tuttora come obiettivo, ma che nel passato è sempre stata relegata ad occasioni spot, non per mio volere ma per volere del “mio mercato”.
Devo dire che sono molto soddisfatto dell’esperienza fatta finora.
Ho
già parlato degli aspetti che amo della docenza, mi viene oggi di parlare di metodo.
Con la consapevolezza di fare affermazioni scontate, forse: scusate in anticipo la mia inseperienza :).
Il mio primo post della categoria “Training” è dedicato al mio amico-nemico numero 1: Appunti.txt.
E’ un file di testo, preferibilmente editato col notepad o con qualche sua simpatica e funzionale variante (notepad2, pspad, ...).
E viene incontro ad un’esigenza piuttosto basilare e consueta, tanto che nei vari “train the trainer” è uno dei punti maggiormente discussi: cosa fare quando una domanda ti porta più o meno completamente fuori discorso ?
Quello che si suggerisce (o, almeno, quello che è stato suggerito più volte a me) è di valutare di volta in volta l’entità (in termini di complessità e di disomogeneità) della risposta, delegandola, eventualmente, ad un successivo momento di discussione.
Piuttosto ovvio.
Nella pratica, durante l’introduzione al corso, dedico una decina di minuti al “metodo”: il “come” e non il “cosa” (quanti risvolti ha questa affermazione !).
Creo un file di testo vuoto, lo chiamo Appunti.txt e lo presento come il "nostro" fedele block-notes, che ci accompagnerà durante l’intero percorso e nel quale scriveremo, via via che si presentano, brevi memo relative a quanto, per fluidità didattica, non è possibile inserire nei discorsi correnti.
Esempio pratico: durante l’ultimo MOC che ho tenuto, all’inizio di questa settimana a Bologna, descrivendo l’IDE di VS ha destato curiosità la combo “Debug/Release”. Che differenza c’è fra debug e release ?
Il mio approccio, in questa occasione, è stato: breve accenno alla questione, quello che basta come propedeuticità, quindi memo in Appunti.txt per successive delucidazioni più esaustive.
Sicuramente invento l’acqua calda, ma devo dire che questo metodo si sta rivelando interessante da diversi punti di vista.
Primo fra tutti, ovviamente, la possibilità di effettuare, se il tempo lo permette, una mini sessioncina di Q&A al termine del corso, mirata sulle esigenze dei partecipanti.
Secondo, motivo per cui odio Appunti.txt, tutti mi hanno sempre chiesto di completare la discussione via mail, inviando per lo meno riferimenti o brevi rimandi per ogni argomento che è rimasto fuori, come inevitabilmente accade, dalla Q&A. Lo odio perchè mediamente un Appunti.txt mi porta via 4 o 5 ore di follow-up, di notte.
Terzo, e più interessante, punto di vista.
E’ una magnifica raccolta di requisiti didattici !
Ancora più valida nel momento in cui, cosa che faccio sempre, chiedo ai partecipanti (votazione se necessario) di dare una priorità agli argomenti ivi indicati.
Ne vengono fuori considerazioni interessanti: ad esempio le tematiche più strettamente tecniche sono generalmente nelle ultime posizioni, a fronte di un grande interesse per questioni maggiormente “architetturali”, se vogliamo. Andate a leggere, se vi va, il
thread su Architettura e Formazione su
GUISA, dove trovate, oltre alle mie considerazioni in merito, le risposte di
Riccardo Golia.
Insomma, in fin dei conti ho una speranza: raccogliere tanti “Appunti.txt” (sì sì, questo vuol dire continuare a tenere tanti corsi ;-)) ed utilizzarli come strumento aggiuntivo nell’analisi di percorsi didattici.
Chiaramente non sono autoritativi, ma decisamente uno spunto in più che viene dal mondo reale.
Ho un po’ di idee, anche pratiche, a riguardo.
Stay tuned.
Bene ... Così si è conclusa oggi la WPC 2006 !
La stanchezza ha iniziato a fare i suoi effetti (a dire il vero lo fa già da parecchio tempo, ma l'accumulo in queste cose è determinante), sono realmente distrutto e ho bisogno di riposare perchè mi aspettano alcune settimane piuttosto intense.
Oggi, giusto per continuare la serie degli "scontri diretti", OO vs. SOA. Che poi scontro non è, basta saper utilizzare ciascuno dei due paradigmi per fare le cose che gli competono. Non tutto SOA solo perchè è la buzzword del momento (lo è da un po', in effetti), non tutto OO perchè, all'esterno, magari non siamo in grado di esporre la nostra logica tramite entità complesse. Ed ecco che il servizio prende la forma di facciata (Remote Facade) posta fra la logica interna e il consumer.
Due chiacchiere tra una sessione e l'altra, e ADO vNext a completare la 5 giorni.
L'ultima sessione, onestamente, mi ha un po' deluso. Spero che sia solo disorientamento (di LINQ sto leggendo e ho letto diverse cose, ma le ADO vNext ed EDM li ho visti oggi per la prima volta in azione). L'idea che mi è rimasta è quella di una grossa confusione nella scelta della tecnologia e dell'approccio, per noi developer sicuramente, non ho capito quanto però in Microsoft le idee siano chiare e definite. Oh, magari cambio parere dopo 2 giorni di giochini ... vedremo.
Closing session con tanti premi ad estrazione, dal libro al corso all'ingresso a WPC 2007.
Con vignette davverò carine degli speaker (ma le mettete online ?).
Soprattutto, last but not least, closing session con tanti, tanti applausi per tutto lo staff (docenti, organizzatori, personale tecnico, reception, tutti !).
Applausi che sottoscrivo e rinnovo virtualmente con questo post.
C U Next ;-)
Ormai prossimi alla conclusione, questi 5 giorni di WPC.
Oggi un po' di AJAX, un po' di architettura, un po' di WF, un'altro po' di architettura, SharePoint Designer 2007 e ...
Custom Entities vs Datasets by Raffaele Rialdi !
Non vorrei svelare il colpevole a chi non ha letto il libro, ma si capisce, è sempre il maggiordomo ... ehm ... il dataset !
Battute (stupide) a parte, la sessione di questo pomeriggio è stata interessante, avrei voluto registrarmela così le prossime volte che mi sento dire "che figata il dataset" lancio la cassettina e mi evito lunghi discorsi.
Quello che mi è rimasto da stopomeriggio è soprattutto l'approccio alla questione.
Il dataset è, alla fine, comodo ! Comodo nel senso di veloce, quasi immediato da utilizzare. Perchè integrato in VS, coi suoi wizard e i suoi drag&drop. Cosa che non è necessariemente male !
I difetti saltano fuori quando non scriviamo codice "usa e getta" (x una demo o, come si diceva oggi, per qualche tool dall'utilità limitata nel tempo), quindi questioni tipo manutenibilità e prestazioni assumono il loro spessore fino a diventare, giustamente, imprescindibili.
In una frase: "Cosa usare dipende, come sempre, dal contesto".
Adattarsi al contesto ! Questo è un concetto applicabile in generale. E personalmente credo sia anche una delle cose più difficili da mettere in pratica.
Terza giornata, abbastanza "orientata al web", per quel che mi riguarda.
Stamattina sessione su WSE 3.0 con Sandro Vecchiarelli: una panoramica su WS-*, quindi un giro per i tool .NET side, che rendono veramente agevole la scrittura di codice altrimenti piuttosto complicato, dal momento che nascondono il protocollo.
Che poi questo sia un bene è tutto da vedere. Come sempre (e allargo il discorso ai wizard, molto in generale) sapere quello che succede sotto può non sembrare indispensabile, ma secondo me alla lunga si rivela tale.
Fine mattina con le pagine asincrone in ASP.NET by Dino Esposito.
Una valida panoramica sul concetto di "asincronia" applicato al web: quindi AJAX e chiamate asincrone lato client, da una parte, e pagine (HttpHandler) asincrone dall'altra. E come usare una tecnica talvolta preclude l'altra (leggi chiamate a WS locali via AJAX).
Pomeriggio con Daniele Bochicchio alla scoperta di IIS 7.0, di cui onestamente sapevo molto poco, al di là di qualche lettura rapida sul web.
Le potenzialità mi sembrano veramente enormi: tutto dato dall'integrazione sempre maggiore fra IIS e .NET Fx, che rende ad esempio possibile l'utilizzo di moduli managed anche nella gestione di risorse unmanaged (pagine ASP e non solo).
Cambia il modello di estensibilità, anche perchè viene meno l'utilità delle ISAPI extensions ... facciamolo con .NET, no ?
E anche un gran miglioramento a livello di gestione, con la configurazione del web server a carico di un file XML stile web.config, e il metabase che rimane (per retrocompatibilità, almeno, poi non so se e quali feature siano rimaste solo lì), ma viene sincronizzato con il file di configurazione.
Per la gioia dello sviluppatore, del sistemista e di chi, magari, si trova a fare entrambe le cose quando fa il deploy di un'applicazione web su un server in produzione.
Poi un po di DataBinding con Windows Forms (Nino Crudele). Sessione molto, molto introduttiva come livello tecnico, ma ben presentata, devo dire. E intanto abbiamo scoperto un curioso comportamento del DataGrid con BindingList ...
Prima dell'ATE con gli usergroup INETA, spazio ancora per la seconda di due sessioni su "Windows Troubleshooting".
Uno spasso, complimenti allo speaker che ha intrattenuto la platea mostrando i log di FileMon e RegMon ... e qualche esempio reale di utilizzo, che so, per capire come mai Word crasha ... perchè, a voi non è mai capitato ???
Ask The Expert non affollatissimo, ma abbiamo sollevato e discusso questioni interessanti, sia di architettura che più strettamente di tecnologia.
Alcuni di questi argomenti rimandati per approfondimento alle sessioni di domani e dopo (Custom Entities vs DataSet, Pattern di Accesso ai Dati, ...).
Infine, cena!
In compagnia di diverse persone che conoscevo solo per nome e finalmente ho potuto incontrare.
Niente nomi perchè eravamo una dozzina, a occhio, e come minimo ne scrivo 11 ...
Quindi per non far torto al dodicesimo, un saluto generale per tutti :)
Plenaria, plenaria, perchè sei tu, plenaria ?
Oggi track in sala unica (piena di gente devo dire) e di stampo completamente diverso da ieri.
D'altra parte era ampiamente preventivato: oggi è stata una overview delle novità che ci attendono per il prossimo anno (in realtà già ora disponibili in RTM): quindi Vista e Office, sulla base del .NET Frmaework 3.0.
Durante la sessione su Vista è stato dato risalto (giustamente) alle caratteristiche del sistema che vanno al di là delle trasparenze e dei gadget: security in primis, ma anche deployment e management.
Per Office l'enfasi è stata data alla parte "server", che è quella che realmente porta innovazione nell'iniziativa Office System.
I prodotti della suite passano da essere uno strumento meramente client a rappresentare un'interfaccia di accesso alle caratteristiche collaborative del sistema nel suo insieme.
Cosa già intravista, almeno in parte, nella versione 2003 (leggi Shared Workspace, integrazione con SharePoint e via dicendo) e assolutamente primaria nella versione 2007.
Presa singolarmente, ogni applicazione ha sicuramente subito migliorie più o meno marcate. Ma ovviamente è l'integrazione il punto di forza: integrazione "intra-moenia" e interazione verso tool esterni, grazie all'adozione di formati aperti utilizzabili tanto da altri vendor quanto, ovviamente, dagli sviluppatori e dai system integrator.
Insomma, cose già viste e già sentite, ma questo non le priva certo di rilevanza.
Tra una demo e l'altra, quindi, oggi ho dedicato un po' più di spazio ad un giro per gli stand.
Potevo non fermarmi nel padiglione libri ? Noooo, come un bambino con le caramelle (solo un po' più costosi delle caramelle).
Mi è cascato l'occhio su un testo di Mondadori, "Ingegneria del Codice".
Apro, sfoglio e mi accorgo che altro non è che Code Complete di Steve McConnell, che non sapevo avessero tradotto in italiano (e la versione, o controllato, è del 2005, segno che devo documentarmi di più sull'editoria informatica made in italy e un po' di meno, o per lo meno non solamente, su Amazon).
Gran libro, Code Complete.
Lo lessi per la prima volta un paio di anni fa, poi a spezzoni di tanto in tanto ... accidenti, avere il tempo !
Vabbè, l'ho preso, anche se ovviamente è un doppione della versione in lingua originale.
Giusto quindi rendere omaggio all'autore (e al traduttore in via indiretta), una citazione che sottoscrivo al 2000% (e che peraltro a sua volta cita Kernighan e Plauger in The Elements of Programming Style):
"Non documentare il codice pessimo: riscriverlo !"
Sì sì, mi piaceva e mi piace tuttora di più il nome in codice, da cui il titolo del post.
Comunque trattasi di Windows Power Shell, nuova shell da linea di comando ora disponibile in RTM qui.
Fonte: questo post di Stefan Demetz.
O forse day 0, giacchè di Tutorial si tratta.
Domani l'inizio della conferenza, con tanto di plenaria (a occhio mi sembra molto di stampo "marketing", ma vedremo).
Oggi, invece, tutorial, appunto.
Il problema, come accennavo ieri, è la scelta che viene imposta (giocoforza) dalla sovrapposizione delle sessioni.
4 track, oggi, così come i prossimi giorni.
E si deve scegliere il "cappellino" da indossare.
Oggi a dire il vero ho fatto un po' il "trasformista" e ho zompato dalla track su ASP.NET, speaker Dino Esposito, a quella sull'architettura, speaker Andrea Saltarello.
Mi interessavano entrambe, anche se per ragioni differenti.
Da un lato (ASP.NET) si parla di una tecnologia che conosco piuttosto bene e sulla quale ho tenuto, e terrò nel prossimo periodo, alcuni corsi.
Quindi, al di là dell'aspetto contenutistico (si può dire ?), ero curioso di vedere "come" questi contenuti vengono esposti (anche se una sessione non è un corso, sia chiaro) da una persona ... beh ... dire esperta mi sembra poco, dal momento che, lato teorico per lo meno, più della metà delle cose che conosco su ASP.NET le ho apprese leggendo i suoi libri :)
Dall'altro lato (Architettura) un argomento trasversale che sto affrontando da meno tempo, e che comunque, data la sua peculiarità (non si parla di tecnologia ma di design, per quanto applicato alla tecnologia questo sia), andrebbe approfondito più di quanto io non riesca a fare, in questo momento. Tra parentesi, anche in questo caso lo speaker non è esattamente l'ultimo arrivato, nè !!!
Ci ho pure provato, stamattina, ma ho scoperto con mia grande insoddisfazione che la clonazione ancora non funziona.
Ergo: un po' di architettura, un po' di ASP.NET.
Inizio dal fondo, cioè dalla track che ho seguito fino a stasera, quella di Andrea.
Molto interessante e fluida, anche se (ovviamente) il tempo è ristretto rispetto alla portata dell'argomento.
Ho ritrovato esattamente la stessa filosofia e lo stesso approccio degli Architecture Days. Non nel senso che è stato un CTRL-C CTRL-V !
Intendo dire che sono emersi, anche in questa occasione, gli aspetti che reputo salienti. Tra cui:
1) I pattern come "modello", lo dice il nome, e non come snippet di codice. E come tali, non perfetti o comunque non adatti a tutte le situazioni (dal "codice al vole che devo farlo vedere al cliente" all'applicazione enterprise ce ne passa).
2) Lo scopo del tutto (cito: "non morire in un bagno di sangue"), cioè creare software migliore: più efficace, più estensibile, più manutenibile, tutte questioni che alla fine si riducono a "spendere meno", in termini di tempo e di risorse (e anche il tempo, ovviamente è una risorsa). Giacchè l'architetto deve scegliere, ma tenendo ben presente il contesto dell'applicazione che progetta (leggi Presenter First e sovraingegnerizzazione).
3) Il test come first-class-citizen di ogni progetto software. E cito di nuovo: "mandare in esecuzione un'applicazione non sinifica testarla", che è come dire che i test vanno automatizzati e fatti fare dalle macchine, e almeno per quel che riguarda gli unit test direi che non fa una piega.
Insomma, riassumendo: una track molto bella e molto ben esposta, che solamente con i riferimenti alla pagine del PoEAA ci sarebbe da leggere per ore e ore e ore, e poi ore ancora.
La sessione di Dino.
Ho seguito una mezza mattinata, con la presentazione dell'architettura di ASP.NET: dalla richiesta del browser, ad IIS ed estensioni ISAPI, per arrivare all'HttpRuntime, moduli e handler compresi. In un'oretta e rotti. Mica male anche qui !
Mi piacerebbe che l'agenda di un corso su ASP.NET seguisse sempre un approccio di questo tipo: "Parliamo di ASP.NET seguendo il percorso del nostro pacchetto TCP dall'URL nella address bar del browser alla risposta che torna indietro all'utente", così è bello !.
Non è detto che lo faccia, non sempre per lo meno.
Complimenti a Dino per la chiarezza e l'efficacia nell'esposizione !
Che altro, l'inizio è stato promettente senza dubbio, e chi ben comincia ...
a.k.a. come postare dall'albergo con la connect card UMTS che non dà segni di vita e il wi-fi dell'hotel, invece, sì, eccome (se non lo tengo attivo giusto e solo nei momenti necessari finisce che spendo di più di connettività che di camera ...)
Domani WPC, Day One, Tutorial.
Da diversi giorni mi guardo l'agenda e cerco di scegliere il percorso giusto fra le track. Solito discorso, meglio troppo che troppo poco, però ...
Vedremo sul momento !
Chi c'è, ci vediamo domani.
Mancava "lui".
Eccolo.
Windows Vista in RTM.
It's time !
a.k.a. Gruppo Utenti Italiani Solution Architect.
E' attivo da alcuni giorni, ne ha dato l'annuncio Andrea Saltarello agli Architecture Days di ottobre, e ora in questo post. Riccardo Golia ne aveva parlato qui.
Inutile che vi descriva io l'iniziativa, gli scopi, le modalità, l'organizzazione, le persone.
Buttate un occhio al sito e al forum.
Da parte mia un in bocca al lupo per tutto e la speranza di avere il tempo per partecipare attivamente.
Difficile imitare i Quiz di Adrian (già è difficile rispondere, idearne uno poi ...).
Però scrivo questo post sotto forma di domanda (ma niente paura, è molto più facile dei QuizSharp).
Prendete un assembly .NET (Componente.dll) che contenga una classe Libreria con un metodo public static [mscorlib]System.Collections.ArrayList GetList(), di cui conosciamo solo la signature che è quella appena indicata.
In un assembly (che referenzia Componente.dll) generato compilando codice C#, abbiamo quanto segue:
System.Collections.ArrayList list = Libreria.GetList();
foreach (string item in list)
{
System.Console.WriteLine(item);
}
In un assembly (che referenzia Componente.dll) generato compilando codice VB.NET, abbiamo quanto segue:
Dim list As System.Collections.ArrayList = Libreria.GetList()
For Each item As String In list
System.Console.WriteLine(item)
Next
Tutti gli assembly sono scritti indifferentemente con una o l'altra versione del framework (salvo ovvia compatibilità fra di loro).
Sapreste scrivere il corpo del metodo GetList, in modo tale che i due snippet scritti abbiano risultati differenti ?