Gli shortcut di Resharper

Per chi non lo conoscesse Resharper è un’estensione per Visual Studio per aumentare la produttività nella scritture del codice, effettuare refactoring, avere una naming convention uniforme, muoversi agilmente all’interno della soluzione ed eseguire i test unitari direttamente nell’IDE (solo per citare alcune delle feature).

Resharper

Un amico mi ha chiesto quali sono secondo me gli shortcut principali da utilizzare con Resharper.

I principali che uso sono:

  • ctrl+t per cercare un tipo
  • ctrl+shift+t per cercare un file
  • shift+alt+l quando ho un file aperto per trovarlo all’interno della solution
  • alt+enter un po’ ovunque sull’editor per accettare i suggerimenti/refactoring di default
  • ctrl+tasto sx del mouse su un tipo per andare alla sua definizione
  • ctrl+shift+r per attivare il menù di refactoring
  • ctrl+e+u per “circondare” un pezzo di codice con parentesi o try-catch

L’elenco di tutti i gli shortcut si trova qui:

http://www.jetbrains.com/resharper/webhelp/Reference__Keyboard_Shortcuts.html

Share

Trovare gli errori di binding in WPF e generare un’eccezione

Tip veloce che può fare risparmiare parecchio tempo.

Quando si effettua il binding in WPF è molto facile commettere errori di battitura (sempre che non si usi il designer o Blend) oppure è possibile modificare o eliminare la property nel ViewModel senza aggiornare lo XAML.

Ad esempio se credo un binding sbagliando la sintassi della property Description nel Path:

<GridViewColumn DisplayMemberBinding="{Binding Path=Descrition}" Header="Last name" Width="140" />

a runtime non viene visualizzato nulla ma soprattutto non viene sollevata nessuna eccezione.

Il metodo più veloce per visualizzare gli errori di binding è quello di eseguire l’applicazione in debug da Visual Studio: in questo modo tutti gli errori di binding vengono loggati nella finestra di Output.

Nell’esempio mi ritrovo un errore di questo tipo:

System.Windows.Data Error: 40 : BindingExpression path error: ‘Descrition’ property not found on ‘object’ ”Product’ (HashCode=55303339)’. BindingExpression:Path=Descrition; DataItem=’Product’ (HashCode=55303339); target element is ‘TextBlock’ (Name=”); target property is ‘Text’ (type ‘String’)

A questo punto potrebbe essere utile loggare questi errori sotto forma di eccezione anche a runtime (magari con Log4net).

In questo post viene spiegato come creare un listener sui binding di WPF per generare un’eccezione: Making WPF Binding Errors Exceptions

Share

Usare il metodo Find di Entity Framework con le chiavi composte

Il metodo Find di Entity Framework 4.3 consente di recuperare un entità dal contesto in base alla chiave primaria.

Se l’entità è già presente nel contesto viene immediatamente restituita senza nessun round-trip al server in caso contrario viene effettuata una query di SELECT sul database.

L’oggetto recuperato viene collegato al contesto. Se l’oggetto non è presente nel contesto o nel database il metodo Find restituisce null.

Ad esempio:

_dbContext.Products.Find(1);

restituisce il prodotto con chiave 1 (int)

Supponiamo adesso di avere un prodotto con chiave primaria composta (composite key):

public class Product
    {
        public string StyleCode { get; set; }
        public string MaterialCode { get; set; }
        public string ColorCode { get; set; }
    }

Il mapping sarà di questo tipo:

public ProductMap()
        {
            HasKey(product => new { product.StyleCode,
                                       product.MaterialCode,
                                       product.ColorCode });
        }

Inseriamo nel db un prodotto in questo modo:

_dbContext.Products.AddOrUpdate(p => 
new { p.MaterialCode, p.StyleCode, p.ColorCode },
                                     new Product
                                         {
                                             StyleCode = "1",
                                             MaterialCode = "2",
                                             ColorCode = "3"
                                         });

 

ed invochiamo il metodo Find in questo modo:

_dbContext.Products.Find(1, 2, 3);

Molto probabilmente il risultato sarà null.

Questo perchè la firma del metodo Find è Find(params object[] keyValues) e quindi Entity Framework a questo punto non è ancora in grado di mappare i valori della chiave nell’ordine corretto.

Il mapping della classe Product va quindi modificato utilizzando il metodo HasColumnOrder:

public ProductMap()
        {
            HasKey(product => new { product.StyleCode, 
                                       product.MaterialCode,
                                       product.ColorCode });
            Property(p => p.StyleCode).HasColumnOrder(0);
            Property(p => p.MaterialCode).HasColumnOrder(1);
            Property(p => p.ColorCode).HasColumnOrder(2);
        }

In questo modo i parametri della chiave primaria vengono mappati in ordine.

Share

Completata l’agenda della sessione ASP.Net 4 e IE9

CommunitTour2010Ho completato l’agenda della sessione che terrò martedi 16 novembre nell’ambito del Community Tour organizzato dalle community DotDotNet e SharePointCommunity.

Powerful ASP.Net 4.0

  • Core services
    • Web.config File Refactoring
    • Auto-Start Web Applications
    • Permanently Redirecting a Page
    • Shrinking Session State
  • AJAX
    • jQuery out of the box
    • Content Delivery Network Support
    • ScriptManager Explicit Scripts
  • Web forms
    • Meta Tags con Page.MetaKeywords e Page.MetaDescription
    • ViewState e ViewStateMode
    • Routing in ASP.NET 4
    • Gestire i Client ID
    • Persisting Row Selection nei Data Controls
    • ASP.NET Chart Control
    • Html Encoded Code Expressions
    • CSS e rendering improvements
      • div Elements e Hidden Fields
      • Rendering delle tabelle per i controlli template
      • ListView Control Enhancements
      • CheckBoxList e RadioButtonList Control Enhancements
      • Menu Control Improvements
  • Visual Studio 2010 Web Development Improvements
    • HTML e JavaScript Snippets
    • JavaScript IntelliSense
  • Web Application Deployment
    • Web.config Transformation

Internet Explorer 9

  • HTML 5
    • Canvas
    • Audio
    • Video
    • Semantic tags
    • Client side storage
  • Accelerazione tramite GPU
  • Pinned sites
  • Developer Tools (aka F12)

Iscrizioni

Ricordando quali sono i temi trattati:

  • Sviluppo di Windows Phone 7
  • Migliorare la User Interface
  • Conoscere le novità di ASP.NET 4.0 e Internet Explorer 9
  • Il framework di sviluppo di SharePoint 2010
  • Sviluppare applicazioni silverlight per SharePoint 2010

rinnovo l’invito a partecipare all’evento. Per maggiori informazioni ed iscrizioni: http://dotdotnet.org/content/Tour2010Nov.aspx

Share

log4net, il Framework .Net 4.0 e il Client Profile

Questa settimana un cliente mi ha segnalato un problema relativo all’utilizzo di log4net con Visual Studio 2010 e il Framework 4.0.

In pratica creando un’app

licazione console e referenziando log4net in versione 1.2.10 in fase di build si riceve questo errore:

“The referenced assembly “log4net” could not be resolved because it has a dependency on “System.Web, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a” which is not in the currently targeted framework “.NETFramework,Version=v4.0,Profile=Client”. Please remove references to assemblies not in the targeted framework or consider retargeting your project.”

Come esplicitato d

al messaggio il problema risiede nel fatto che la console application targettizza il Framework 4 Client Profile.

Framework-Client-Profile

Il Client Profile è il target predefinito per i nuovi progetti Windows Forms, Console Application, WPF e Window Service. L’idea di base del Client Profile è quella di ridurre le dimensioni del Framework .Net rimuovendo tutte le assembly che in certi progetti non servono.
Nello specifico il client profile non contiene:

  • ASP.NET
  • alcune funzionalità avanzate di Windows Communication Foundation (WCF)
  • il .NET Framework Data Provider per Oracle
  • MSBuild
log4net utilizza l’assembly System.Web tramite l’AspNetTraceAppender e quindi non è possibile compilare i progetti che targettizzano il Framework 4 Client Profile.
La soluzione più rapida è quella di modificare le proprietà del progetto selezionando come target framework “.Net Framework 4”.
La domanda a questo punto però è: “E’ corretto scegliere come target il framework in versione full?”
Se la risposta fosse solo nelle dimensioni direi che si potrebbe utilizzare direttamente la versione full.
Queste sono le dimensioni del framework 4 come riportato sul blog di Scott Hanselman:
3.5 SP1 4.0 RTM
32 bit Client Profile Online: 28 MB
Offline: 255MB
28.8 MB
32 + 64 bit Client Profile N/A 41 MB
32 bit Full N/A 35.3 MB
32 + 64 bit Full N/A 48.1 MB
32 + ia64 bit Full N/A 51.7 MB
32 + 64 + ia64 bit Full 231 MB N/A

In pratica la differenza di dimensioni si attesta sui 7 mega quindi secondo me non sostanziale.

L’accento probabilmente va posto su due punti:

  • concettualmente gli applicativi desktop è corretto che non abbiano riferimenti ad assembly relative al mondo web
  • il Framework 4 Client Profile è il framework che viene distribuito sui desktop tramite Windows Update
In base a questi punti direi che si può targettizzare il framework full in ambienti ben controllati o enterprise e preferire il Client Profile per tutti gli applicativi desktop.
Per quanto riguarda log4net nello specifico nelle versioni future potrebbe essere rilasciata una build compatibile col client profile senza riferimenti a System.Web altrimenti è necessario ricompilarlo rimuovendo l’AspNetTraceAppender.
Riferimenti:

.NET Framework Client Profile
Towards a Smaller .NET 4 – Details on the Client Profile and Downloading .NET
What’s new in .NET Framework 4 Client Profile RTM

Share

Community Tour Autunno 2010 a Bologna

Sono aperte le iscrizioni al prossimo evento di Community che si terrà a Bologna il 16 novembre 2010 organizzato dalla SharePointCommunity.it e DotDotNet, lo User Group Emiliano-Romagnolo dedicato a Microsoft .NET in collaborazione con Microsoft Italia,

L’evento è gratuito, si articolerà nell’arco dell’intera giornata e sarà suddiviso in due track parallele per IT Pro (meglio noti come sistemisti) e per sviluppatori.

Si parlerà di SharePoint, di Windows Phone 7, di SQL Server 2008 R2, delle novità di ASP.NET 4 e di IE 9

Agenda track sviluppatori

L’agenda della track per sviluppatori è la seguente:

Ora Sessione Speakers
09.30 – 10.00 Registrazione
10.00 – 10.30 Keynote

Lorenzo Barbieri
Microsoft Italia

10.30 – 11.45 Windows Phone 7: Sviluppare applicazioni per il Marketplace
In questa sessione vedremo come sviluppare applicazioni per il Marketplace di WP7, con esempi presi da applicazioni reali. 
Lorenzo Barbieri
Microsoft Italia
11.45 – 13.00

Migliorare la UX nelle applicazioni Silverlight e Windows Phone 7 con Expression Blend
Expression Blend 4 è lo strumento che permette di realizzare User eXperiences accattivanti e di forte impatto verso l’utente finale. In questa sessione vedremo come realizzarla con Silverlight  e Windows Phone 7,

Alessandro Scardova
DotDotNet 
13.00 – 14.00

Break

14.00 – 18.00

Windows Phone 7 Lab 
Un intero pomeriggio a disposizione per toccare con mano gli smartphone e per provare le proprie applicazioni. Il lab si terrà in una saletta parallela. Per iscriversi occorre mandare una mail a itamsdn@microsoft.com specificando data, città e applicazioni da testare.

14.00 – 15.15

Powerful ASP.NET 4.0 & Internet Explorer 9
NET Framework versione 4 include miglioramenti per ASP.NET 4 in aree mirate. Anche Visual Studio 2010 include miglioramenti e nuove funzionalità per ottimizzare lo sviluppo di risorse Web. In questa sessione verrà fornita una panoramica di numerose delle nuove funzionalità incluse nella nuova versione. 
Vedremo anche le novità per gli sviluppatori introdotte da Internet Explorer 9

Stefano Benedetti
DotDotNet
15.15- 16.30

Introduzione allo sviluppo con Sharepoint 2010.
SharePoint 2010 è un framework di sviluppo maturo e aperto all’integrazione, che ogni sviluppatore .NET può utilizzare per creare soluzioni di integrazione. In questa sessione vedremo le novità e gli strumenti offerti dalla piattaforma. In particolare concentremo la nostra attenzione sugli strumenti offerti da Microsoft Visual Studio 2010 e sul modello di accesso ai dati offerto da SharePoint 2010 

Paolo Pialorsi
SharePoint Community 

16.30 – 16.45

Break

16.45 – 18.00

Sviluppare applicazioni Silverlight per Sharepoint
Per capire i vantaggi che Visual Studio 2010 e Sharepoint 2010 portano ai developer, attraverso demo live, svilupperemo una piccola applicazione Silverlight che visualizzerà i nostri dati su Sharepoint 2010 tramite servizi e vedremo come testare le nostre applicazioni Sharepoint tramite Pex & Mole

Salvatore Di Fazio
SharePoint Community   

Iscrizioni

Per maggiori informazioni e per iscriversi all’evento: http://dotdotnet.org/content/Tour2010Nov.aspx

Track per IT Pro

La track relativa agli IT Pro è organizzata dalla SharePointCommunity in collaborazione con UGISS (User Group Italiano SQL Server).

Per maggiori dettagli e per l’iscrizione vi rimando al sito della SharePointCommunity.

Share

Visual Studio 2010 Community Tour @ Cesena

Venerdì 28 maggio 2010 si terrà a Cesena una nuova cena di DotDotNet un nuovo evento organizzato da DotDotNet in collaborazione con DotNetMarche e DotNetUmbria dal titolo “Presentazione di Visual Studio 2010 e del Framework 4“.

L’evento sarà gratuito come al solito e durerà una giornata intera.

Il calendario è il seguente:

  • Team Foundation Server 2010
  • Windows Presentation Foundation 4
  • Managed Extensibility Framework
  • Smooth Streaming
  • Windows Phone 7
  • Silverlight 4
  • RIA Services
  • ASP.NET 4.0
  • MVC 2
Ah e comunque a seguire ci sarà la cena…
Share

Programmazione parallela: pensieri sparsi

Venerdì scorso ho partecipato all’evento DotDotNet (grazie ancora a chi organizza gli eventi e le cene!) sui temi F# e Continous Integration.

Durante la discussione su F# è stata evidenziata la sua innata abilità nel semplificare notevolmente la parallelizzazione dei task (aspetto secondario del tema in quanto F# è principalmente un linguaggio dinamico e funzionale).

A parte lo scontato utilizzo di F# in ambito matematico/scientifico/fisico il tema della parallelizzazione mi ha fatto pensare ai concetti di performance (ovviamente) ma soprattutto ad un qualcosa che mi piace chiamare “Codice Predittivo“, similmente alla prediction branch delle CPU.

Il trend di mercato per quanto riguarda le CPU è oggi meno indirizzato sulla velocità pura di clock ma piuttosto nell’integrazione di un numero sempre maggiore di core sullo stesso chip.

La sfida a livello software per i prossimi anni è quindi quella dello sfruttamento multithread di tutti questi core.

Uno scenario che mi incuriosisce è questo: ho un’applicazione che effettua alcune operazioni (A(x), B(x), C(x) ecc) e ogni operazione può essere applicata indistintamente al risultato di qualsiasi altra.

Ipotizziamo di eseguire A(x) e magari di fermarci per osservare il risultato ottenuto e decidere quali altre operazioni eseguire.

In questo momento potremmo pensare di sfruttare tutti i core inattivi della macchina per eseguire ad esempio B(A(x)) oppure C(A(x)) o ovviamente qualsiasi altra operazione in background e multithread.

A questo punto l

‘utente decide che vuole eseguire l’operazione B(A(x)) e voilà, il risultato è già disponibile.

Una user experience non male direi.

A questo punto scarto i risultati non utilizzati e proseguo allo stesso modo. Ho solo sprecato un po’ di cicli di qualche core che non faceva niente…

Il più immediato esempio concreto è nel settore del fotoritocco. Applico un filtro ed intanto l’applicazione ne applica altri che potrei usare in futuro (o addirittura potrebbe applicare i filtri che utilizzo con maggiore frequenza).

Microsoft stà lavorando alacremente nel settore della parallelizzazione per fornire agli sviluppatori un set di librerie per rendere il più semplice e trasparente l’esecuzione di codice su più core. Il risultato si chiama PLINQ che è l’implementazione parallela del pattern LINQ.

Allo stesso modo di LINQ, PLINQ è un insieme di extension method che operano su un IEnumerable<T> in memoria e sfruttano la deferred execution. La principale differenza stà nel fatto che PLINQ suddivide la sorgente dati in segmenti e cerca di eseguire l’operazione in parallelo su tutti i processori/core presenti nel sistema.

Il tutto partendo da un livello veramente base: basta invocare l’extension method AsParallel() per richiedere l’esecuzione in parallelo fino ad un massimo di 64 processori.

Reference:

PLINQ: http://msdn.microsoft.com/en-us/library/dd460688(VS.100).aspx

http://en.wikipedia.org/wiki/Plinq#PLINQ

F# : http://msdn.microsoft.com/en-us/fsharp/default.aspx

http://en.wikipedia.org/wiki/F_Sharp_(programming_language)

net-framework-stack-plinq

Share

DevCon 2009 – Giorno 1

Dopo il corso TDD seguito presso Overnet qualche mese fa, l'annata formativa prosegue con le 3 giornate di DevCon che ogni anno il gruppo di Devleap propone con tutte le novità più recenti o di prossima diffusione di Microsoft nel settore sviluppo ed a seguire una giornata del Basta! Italia on tour.

La prima giornata della DevCon 2009 non si è focalizzata su di un singolo aspetto tecnologico ma sugli aspetti architetturali di una applicazione completa a partire dal database su su fino alla UI.

Molto fluida la sessione a 4 mani di Rob e Paolo, che in maniera molto affiatata hanno affrontato una intera giornata alternandosi ogni 2-3 minuti circa senza soluzione di continuità.
Allo stesso modo hanno mostrato tutta la loro esperienza di speaker passando continuamente da slide a codice e viceversa (peccato per le bizze del proiettore…)

La giornata ha avuto come base l'applicazione Estate Management che DevLeap utilizza come strumento formativo fino dalla versione 1 di .Net e ne ha ripercorso l'evoluzione fino ad oggi per poi mostrare le novità applicabili a partire dal Framework 3.5 in poi.

Ho trovato molto interessante tutta la parte incentrata sul DAL che ha mostrato come evolvere il data access layer a partire dai recordset arrivando fino a Entity Framework passando attraverso LinqTo2SQL.
Questa evoluzione sul DAL è la stessa che ho percorso negli ultimi 5 anni. Tutti temi noti per me quindi ma, dato che la giornata voleva essere di tipo architetturale, è stato interessante vedere dove vengono messe le classi e come vengono strutturati i progetti da chi sviluppa quotidianamente applicazioni enterprise. Ma soprattutto vedere tanti piccoli e grandi accorgimenti utilizzati dal gruppo che sicuramente fanno la qualità di una applicazione.
Particolare attenzione è stata posta su come mantenere astratto, isolato e pluggable il DAL per poterlo sostituire semplicemente modificando il file config.

Molto belle ed eleganti anche le soluzioni proposte negli ambiti di autenticazione, autorizzazione e validazione dei dati.
In questo ambito lo spunto fornito di utilizzare le regole di WF senza utilizzare tutto WF sarà di sicuro oggetto di un mio approfondimento.

Meno profiquo è stato il pomeriggio soprattutto nella parte incentrata su SOA e WCF su cui mi sono decisamente perso, probabilmente a causa del mix di stanchezza mia da un lato, di accelerazione degli speaker e di proliferazione esponenziale dei progetti della soluzione (85…)

Di sicuro l'applicazione vista oggi rappresenta ad un elevatissimo livello il concetto fondamentale di DISACCOPPIAMENTO ed è una base architetturale che affronta tutti gli aspetti di un applicazione con tutte le tecnologie disponibili fino ad oggi: datareader, linq, linq to sql, entity framework, WF, WCF, Asp.net, MVC, SOA, Ado.Net Data Services…

Share

Listview, Entity framework e navigation property

Stavo creando una semplice ListView utilizzando Entity Framework sulla tabella Clienti.

Premetto che la tabella Clienti è in relazione con la tabella Agenti e quindi EF crea correttamente la Navigation Property tra l'entity clienti e l'entity agenti.

Creo la ListView, aggiungo il LinqDataSource e faccio il binding tra listview e datasource.

Fin qui tutto ok, anche il designer funziona correttamente e mi mostra tutte le colonne.

A runtime ricevo invece l'errore:

DataBinding: '[Agenti' is not a valid indexed expression.



Description: An
unhandled exception occurred during the execution of the current web
request. Please review the stack trace for more information about the
error and where it originated in the code.

Exception Details: System.ArgumentException: DataBinding: '[Agenti' is not a valid indexed expression.

Source Error:

Line 230: </td>
Line 231: <td>
Line 232: <asp:Label ID="Agenti_IDAgenteLabel" runat="server"
Line 233: Text='<%# Eval("[Agenti.IDAgente]") %>' />
Line 234: </td>

Tramite la navigation il designer ha generato una colonna per mostrarmi l'ID dell'agente collegato al cliente.

Il problema è nelle parentesi quadre che sono state aggiunte all'interno del metodo Eval.

Modificato il tag rimuovendo le parentesi quadrate

Text='<%# Eval("Agenti.IDAgente") %>' />

tutto funziona correttamente

Share