Maurizio Tammacco's blog

Mediante JavaScript è possibile eseguire programmaticamente un post della pagina mediante il richiamo della funzione

   1: __doPostBack( 'EventName', 'EventArgs' );

In questo caso il post generato è sincrono, ma, come ben spiegato in questo post, è anche possibile effettuarlo asincrono mediante l'utilizzo di un array della classe PageRequestmanager, in questo modo:

   1: function doPostBackAsync( eventTargetName, eventArgs )

   2: {

   3:     var prm = Sys.WebForms.PageRequestManager.getInstance();

   4:  

   5:     if( !Array.contains( prm._asyncPostBackControlIDs, eventTargetName) )

   6:     {

   7:         prm._asyncPostBackControlIDs.push(eventTargetName);

   8:     }

   9:  

  10:     if( !Array.contains( prm._asyncPostBackControlClientIDs, eventTargetName) )

  11:     {

  12:         prm._asyncPostBackControlClientIDs.push(eventTargetName);

  13:     }

  14:  

  15:     __doPostBack( eventTargetName, eventArgs );

  16: }

  17:  

Mediante poi l'utilizzo dell'UpdatePanel otteniamo che a livello programmatico (quindi senza necessariamente l'interazione dell'utente mediante un controllo), possiamo generare un post asincrono con refresh parziale della pagina, mediante il richiamo esplicito della funzione di cui sopra.

Inoltre, poichè in Javascript è anche possibile, richiamare esplicitamente una funzione definita dall'utente in una pagina mentre ci si trova in un altra pagina (esempio popup), mediante il seguente costrutto:

   1: window.opener.nomeFunzioneCustom(parametri); 

otteniamo che, stando un una pagina secondaria come un popup, riusciamo ad aggiornare con il partial rendering la pagina chiamante.

L'utilizzo degli add-in di Visual Studio 2008 consente di incrementare a volte notevolmente la produttività di chi sviluppa, ad esempio rendendo possibile effettuare con pochi click operazioni ripetitive e lunghe. Tratto da Visual Studio Gallery, ecco la serie di add-in, rigorosamente free, che utilizzo giornalmente durante l'attività di sviluppo del software:

Regionerate, permette di creare in automatico le regioni di codice su un intero file, applicando un layout predefinito o scelto tra i layout forniti. Uno dei layout a corredo addirittura effettua il conteggio automatico degli items presenti in ogni regione e lo inserisce nel nome della stessa. E' anche possibile crearsi propri layout o scaricarli. Davvero utile.

PowerCommands, add-in abbastanza conosciuto e molto utile, anche se responsabile di un crash documentato di Visual Studio, di cui ho già parlato qui e qui. Trattasi di una serie di comandi aggiuntivi sistemati in diversi punti dell'IDE. I principali comandi che uso sono:
-Show All Files (Solution Explorer, a livello di nodo solution)
Questo comando mostra tutti i file per tutti i progetti caricati nella soluzione attiva, e non solo invece per il progetto attivo, come opera invece il comando omonimo a livello di progetto;
-Collapse Projects. Questo comando collassa il nodo selezionato e contemporaneamente tutti i suoi sottonodi. La funzionalità fornita dalla Treeview del Solution Explorer invece collassa solo il nodo selezionato, lasciando invariato lo stato dei suoi sottonodi;
-Copy Class. Come si può intuire, questo comando copia una intera classe o nodo nella Clipboard, permettendo di incollarla altrove (comando Paste Class) dopo averla opportunamente rinominata per evitare errori di compilazione;
-Copy References (e Paste References). Copia una reference o un set di reference nella Clipboard, per poi incollarla altrove;
-Open Containing Folder (davvero utile). Dal nodo di un progetto o item, apre una finestra di Windows Explorer che punta al path fisico del progetto (o dell'item) puntato;
-Open Command Prompt, simile a Open Containing Folder, ma apre un prompt dei comandi invece che una finestra di windows explorer;
-Remove and Sort Usings, altro comando utilissimo, elimina tutti gli using inutili e ordina quelli indispensabili, in un colpo solo, per singola classe o per tutte le classi di un progetto;
-Extract Constant, dall'editor di codice, crea la definizione di costante per la stringa selezionata;
-Clear Recent Project List, elimina la lista degli ultimi progetti aperti, permettendo di selezionarli.

Sticky Notes, fornisce una windows dockable nella quale scrivere appunti, una per ogni file. Funzionalità sinceramente non utilissima perchè è comunque possibile inserire i propri appunti in un file sorgente a mo' di commento oppure utilizzare la window Task List. L'unico vantaggio è la possibilità di eliminare i propri appunti in un colpo solo o di inviarli per posta elettronica;

Clone Detective, ho già parlato qui di questo tool. Consente di cercare facilmente codice duplicato all'interno della propria solution.

Export code as Code Snippet, add-in scritto dall'MVP Alessandro Del Sole, consente di esportare facilmente blocchi di codice nel formato .snippet, e quindi riutilizzarli come Snippet Code direttamente attraverso la funzionalità presente nell'IDE

Code Style Enforcer. Questo add-in permette di ottenere segnalazioni evidenti nel proprio codice nel caso in cui siano violate regole di naming e di best practices (visibilità membri e interfacce esplicite o no), configurabili mediante file XML;

OxyProjectMetrics, estrae informazioni inerenti la metrica del codice e le mostra in un formato tabellare;

ResourceRefactor, estrae la stringa selezionata e cablata nel codice sorgente e la invia ad un apposito file di risorse;

AutoCode, add-in per automatizzare attività ripetitive di scrittura di codice mediante la creazione di comandi parametrici, come da esempio sotto.  

TytanNET, insieme di utili tool windows che incrementano le possibilità di refactoring del codice, e forniscono ulteriori visualizers per il debugging. Decisamente molto utile.

Su Visual Studio Gallery sono presenti decine e decine di altr utili add-in, sia gratuiti che non, per tutte le esigenze.

Mi appunto questo post molto interessante di Luca Minudel a proposito della attività di refactoring sul codice sorgente, molto spesso sottovalutata o ignorata del tutto in progetti reali.

Minudel elenca le seguenti 6 attività di refactoring che ritengo personalmente indispensabili ed utili.

* Estrae codice dai metodi troppo lunghi (>> 30 linee di codice)
* Cerca i commenti e modifica il codice in modo che si spieghi da solo
* Scorre i nomi di metodi e variabili e rinomina quelli poco chiari e quelli  poco descrittivi
* Guarda i blocchi condizionali (If, switch, for, ...) e vede se li può eliminare
* Trova parti di codice duplicate e le elimina
* Scopre cosa fa ogni metodo e si chiede se si trova sulla classe giusta Inizia ogni punto mostrando come fare e quindi lascia continuare al suo collega, interviene quando serve

L'extender CalendarExtender presente nell'Ajax Toolkit presenta un bug se si cerca di globalizzarlo, ovvero adattarlo ad una specifica cultura. Infatti, la label presente in basso con l'indicazione della data odierna non viene globalizzata ma rimane impostata fissa alla cultura inglese, per cui apparirà sempre la scritta "Today". Affinchè i controlli dell'Ajax Toolkit possano essere personalizzati sulla base delle varie culture non basta impostare la specifica cultura nel file di configurazione dell'applicazione web (tag globalization), oppure impostarla tramite browser, ma occorre anche abilitare il rendering dello script al supporto di culture specifiche, tramite la proprietà EnableScriptGlobalization dello ScriptManager, che deve essere ovviamente impostata a True (il valore di default è False).

Clone Detective for Visual Studio è una integrazione dell'ambiente Visual Studio (completamente free) in gradi di rilevare porzioni di codice duplicato tra i vari progetti che compongono una solution. Il fine è ambizioso, poichè come dice la stessa presentazione del prodotto presente su CodePlex

"Having duplicates can easily lead to inconsistencies and often is an indicator for poorly factored code"

Un componente del genere può davvero essere utilissimo, anche oltre lo scopo che si prefigge. Ad esempio, conoscendo accuratamente il numero di cloni presenti all'interno di un software con parecchie linee di codice, è possibile valutarne il costo di manutenzione, ovvero il costo a cui si va incontro se si decidesse di apportarvi delle modifiche.

Il componente si basa su ConQAT (Continuous Quality Assessment Toolkit) per rilevare le parti di codice duplicato. Questo toolkit fornisce una serie di tools e linee guida per il controllo della qualità del software

Mi appunto questo ottimo sito per uso futuro: VisualCv.

Consente di inserire il proprio cv online ed arricchirlo di contenuti multimediali: immagini, audio, video, grafici. Inoltre consente di pubblicarlo nel rispetto della politica di privacy scelta, di inviarlo via mail, di convertirlo automaticamente in formato PDF, di ottenere una URL unica da inviare a chi può essere interessato alla sua visualizzazione. Sul sito sono presenti diversi esempi di cv, fatti davvero bene e con un alto indice di usabilità. Se si aggiunge che il tutto è pure gratuito...

Il Data Access Application Block, contenuto all'interno della Enterprise Library 4.1 consente di richiamare store procedures passando esclusivamente il valore dei singoli parametri richiesti (mediante l'utilizzo del metodo GetStorepProcCommand dell'oggetto DatabaseFactory), nello stesso ordine con cui questi sono espressi nella firma della procedura. Poichè ADO .NET richiede comunque che ogni informazione in merito ai parametri della store sia obbligatoria (quindi tipo di dato, dimensione, precisione, scala, ecc), il metodo effettua internamente una chiamata al metodo DeriveParameters di ADO .NET che, attraverso un round-trip al database server, consente di recuperare tutte le informazioni necessarie sui parametri. Poichè come detto, questa chiamata richiede un round-trip verso il server, il data access application block fornisce anche un meccanismo di caching delle informazioni sui parametri recuperate dal server.

Oracle e SqServer hanno un meccanismo differente circa il ritorno di un resultset da una store procedure. Oracle infatti richiede, a differenza di Sql Server, l'utilizzo di un cursore come parametro di output per recuperare il resultset derivante da procedure che lo ritornano, fornendo anche un tipo speciale di dato, cursor appunto, nel suo provider nativo per .NET.

Se si usa il Data Access Application Block per invocare store procedure Oracle che ritornano un resultset attraverso l'uso di un cursore come parametro di output, non è necessario indicare quest'ultimo tra i parametri (anche perchè, pur provando ad indicarlo esplicitamente, non si troverebbe il tipo di dati cursor disponibile tra i tipi di dati in quanto viene usato l'enum System.Data.DbType che rappresenta genericamente i tpi di dati  per qualsiasi .NET Data Provider).

Basta infatti passare un generico parametro di output avente il valore null come primo parametro della store procedure Oracle e l'oggetto OracleDatabase farà il lavoro per noi. Questo oggetto infatti assume che il primo parametro di una store procedure sia un cursore di output per la restituzione del resultset

Se si usano le sessioni ASP .NET coockieless, ovvero sessioni in cui il SessionID viene inserito nell'url nella seguente forma:

/App/(S(avsbnbml2n1n5mi5rmfqnu65))/default.aspx

il metodo ApplyAppPathModifier della classe HttpResponse risulta estremamente utile, poichè, passandogli come parametro stringa un path virtuale, restituisce lo stesso path con il SessiondID inserito correttamente nell'url, sollevando lo sviluppatore dalla costruzione manuale dello stesso. Ciò risulta evidente ogni qual volta è necessario utilizzare url caricati dinamicamente.

Tra le guidelines da seguire circa la scrittura del costruttore di una classe questa assume una certa importanza:

Evitare di richiamare all'interno di un costruttore un metodo virtuale.

Questa guidelines è dovuta al fatto che in presenza di un metodo che ridefinisce un metodo virtuale (ne fa l'override insomma), viene richiamato sempre il metodo esposto dalla classe derivata, ovvero il metodo più specifico della implementazione, a prescindere se il costruttore della classe che espone il metodo derivato sia stato richiamato.  L'esempio sotto, tratto dalla documentazione MSDN, chiarisce bene questo concetto.

La creazione della classe DerivedFromBad, cioè il richiamo del suo costruttore, provoca la chiamata immediata  al costruttore della sua classe di base, ovvero BadBaseClass, il quale prima inizializza una variabile (state) e poi richiama il metodo virtuale SetState. Peccato che poiche l'oggetto che si sta cercando di costruire (DerivedFromBad) ridefinisce il metodo SetState, all'interno del costruttore della classe BaseClass il metodo effettivamente chiamato è l'implementazione fornita dalla classe DerivedFromBad, e non quella della classe base BadBaseClass. L'esecuzione  del metodo ridefinito SetState avviene a prescindere se il costruttore della classe derivata sia o no stato richiamato. In questo caso, poiche non  viene richiamato, l'inizializzazione della variabile state non  avviene ed il suo contenuto resta fermo a quello impostato dalla classe base, ovvero "BadBaseClass".

   1: public class tester

   2:     {

   3:         public static void Main()

   4:         {

   5:             DerivedFromBad b = new DerivedFromBad();

   6:         }

   7:     }

   8:     

   9:     

  10:     public class BadBaseClass

  11:     {

  12:         protected string state;

  13:         public BadBaseClass()

  14:         {

  15:             state = "BadBaseClass";

  16:             SetState();

  17:         }

  18:         public virtual void SetState()

  19:         {

  20:  

  21:         }

  22:     }

  23:  

  24:     public class DerivedFromBad : BadBaseClass

  25:     {

  26:         public DerivedFromBad()

  27:         {

  28:             state = "DerivedFromBad ";

  29:         }

  30:         public override void SetState()

  31:         {

  32:             Console.WriteLine(state);

  33:         }

  34:  

  35:     }

Gli Snippet Code possono davvero far risparmiare tempo di sviluppo, soprattutto su operazioni ripetitive. Visual Studio, come è noto, fornisce un add-in per la gestione degli stessi su PC, e codificati in un file xml. Chi come me non usa sempre lo stesso PC per lavorare è costretto a sincronizzare gli snippet code su tutti i PC su cui sviluppa, operazione molto noiosa e anche molto soggetta ad errori. Sarebbe comodo in questi casi non avere il repository in  locale, ma averli centralizzati all'esterno.

<Code:Keep> fornisce appunto uno storage centralizzato  da cui attingere snippet code suddivisi per categoria ed in cui inserire i propri, ovviamente rendendoli usufruibili anche agli altri visitatori del sito, previa registrazione. Inoltre, viene messo a disposizione il download di un add-in per Visual Studio 2008, ovviamente gratuito, che permette di consultare ed utilizzare gli Snippet Code presenti nel sito direttamente dall'IDE, senza neanche aprire il browser.

In Visual Studio 2008 la pressione del tasto F12 rappresenta la scorciatoia da tastiera del comando Edit.GoToDefinition, che, come è noto, permette di "saltare" direttamente alla dichiarazione del simbolo selezionato nel codice. Non è però cosi evidente che il simbolo selezionato potrebbe anche risiedere nella pagina aspx. Ad esempio, se selezioniamo la classe CSS associata ad un controllo in una pagina aspx, o se semplicemente posizioniamo il puntatore del mouse all'interno della stringa della classe CSS, alla pressione del tasto F12 verrà automaticamente  aperto il file CSS contentente la definizione del simbolo selezionato e verrà interamente evidenziata la classe stessa con tutti gli attributi grafici associati, come da esempio.

Decisamente molto utile!

Avevo già parlato qui (post immediatamente sotto :-)) di uno strano crash di Visual Studio 2008 SP1, a seguito dell'esecuzione comando "Choose items" della toolbox.

Il problema sembrava essere dovuto alla presenza dei PowerCommands e di una loro presunta incompatibilità con il Service Pack 1. Infatti per poter tornare alla "normalità" era necessario un'azione estrema, ovvero rimuovere i PowerCommands, ed a quel punto il problema spariva.

Oggi scopro che attraverso un assemply redirection nel file di configurazione di Visual Studio (devenv.exe.config) il problema si risolve definitivamente, e che il crash si verificava anche nell'editor XAML. Maggiori info qui.

Quindi la soluzione è inserire questo frammento XML nel file di configurazione di Visual Studio:

<dependentAssembly>
<assemblyIdentity name="Microsoft.PowerCommands"   publicKeyToken="null" culture="neutral"/>
<codeBase version="1.1.0.0" href="C:\Program Files (x86)\PowerCommands\Microsoft.PowerCommands.dll"/>
</dependentAssembly>

Qualche giorno fa mi sono imbattuto in uno strano crash di Visual Studio 2008, dopo aver installato il Service Pack 1, vale a dire che il comando "Choose items" della toolbox era capace di mandare in crash l'intero IDE, scrivendo un laconico messaggio nell'Event viewer, del tipo

NET Runtime version 2.0.50727.3053 - Fatal Execution Engine Error (7A035E00) (80131506)

di nessuna utilità per la risoluzione del problema,  senza possibilità di scampo quindi. Dopo aver cercato invano per la rete per evitare di perdere ulteriore tempo ho evitato di disporre del controllo che mi interessava nella toolbox (precisamente una PropertyGrid) e l'ho inserito direttamente nel markup XAML della mia applicazione (una XBAP application).

Oggi ho letto questo post di Nazareno e speravo veramente di risolvere il problema, anche perchè questa volta la toolbox era indispensabile poichè dovevo inserire una intera suite di controlli.

Purtroppo non c'è stato niente da fare. Il problema sparisce solo dopo aver disinstallato i Power Commands, senza più reinstallarli.  Ma sono abituato ai Power Commands  e li trovo veramente utili.

Vale a dire che li disintallerò solo per utilizzare la toolbox, e poi li reinstallerò di nuovo...:-)

Il prossimo 13 settembre parteciperò ad una conferenza internazionale, precisamente la SQLBits, dedicata ai professionisti di Sql Server, in quel di Londra.

Se qualche sqlellaro vuole accodarsi non ha che da contattarmi.

Questa è la mia agenda:

Qualche suggerimento ?

Come chi programma in WPF ben sa, una applicazione WPF browser, meglio nota come XBAP application, gira all'interno del browser in un ambiente partial trust, oppure in una sandbox di sicurezza, come meglio si preferisce, per evitare appunto che il codice di una tale applicazione possa accedere a informazioni confidenziali oppure effettuare azioni non autorizzate. In particolari scenari, tuttavia, ad esempio in applicazioni Intranet, può nascere l'esigenza di dotare tali applicazioni di un maggior numero di permessi, oppure addirittura farle girare in ambiente full trust.

Bene, visto che per default una XBAP application viene eseguita in modalità partial trust, quali sono i passaggi necessari per farla funzionare invece in un ambiente full trust ?. Questo è il motivo di questo post. Di seguito elenco i passaggi che ho dovuto effettuare per raggiungere tale obiettivo, anche se alcuni sono un pò contorti e mi fanno dubitare di aver intrapreso la strada migliore, ma alla fine comunque il tutto ha funzionato:

• Occorre far si che il processo che ospita la XBAP application non venga eseguito con un process token povero di privilegi. Per far questo è necessario intervenire sul Registry (non sono però certo che non esistano metodi più comodi).  Occorre posizionarsi sulla chiave:

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework\Windows Presentation Foundation\Hosting

e creare un valore DWORD denominato RunUnrestricted ed assegnargli il valore 1.

• Nella scheda Security, accessibile dalle proprietà del progetto, occorre scegliere come zona il valore "Custom" al posto di "Internet". Lasciare il valore di default "This is a partial trust application" e non spuntare "This is a full trust application" come invece la logica vorrebbe. Se si sceglie "full trust" senza cambiare la zona (lasciando il valore di default) il meccanismo non funzionerà. Dopo aver fatto questa modifica, riaprendo la scheda Security, si noterà come sia spuntato il valore "full trust" e la zona sia impostata a "Custom" e non modificabile. 

• Nel file app.manifest dell'applicazione occorre aggiungere l'attributo Unrestricted="true" come evidenziato sotto:

• Se si vuol lanciare la propria applicazione mediante un url http, occorre firmare il manifest con un certificato digitale X.509. Quando creiamo la nostra applicazione XBAP Visual Studio genera un file con estensione "pfx". Questo file rappresenta un certificato digitale temporaneo da usare a scopo di test. Occorrerà solo registrare tale certificato in Internet Exporer, scegliendo da menù Tools l'opzione "Options", la scheda "Content" ed il pulsante "Certificates". A questo punto click sul pulsante "Import" e partirà il wizard di importazione del certificato, dove attraverso vari passaggi il certificato di test sarà registrato (occorre scegliere come store  "Trusted root Certification Authorities"). E' comunque possibile generare un certificato di test direttamente da Visual Studio, scegliendo la scheda "Signing" dalle proprietà del progetto e successivamente cliccando il pulsante "Create Test Certificate". A questo punto partirà un wizard che permetterà la creazione e la esportazione del certificato in un file "pfx", onde consentire la successiva importazione in Internet Explorer.

A questo punto eseguendo l'applicazione via web essa funzionerà con tutti i permessi assegnati (full trust).