A DotNet Raider

My adventures in the .NET world!
posts - 34, comments - 12, trackbacks - 0

My Links

News

View Martino Bordin's profile on LinkedIn XBOX 360 AVATAR - BORD1986
Locations of visitors to this page

Archives

Post Categories

Arch

BlogRoll

Codeplex

Google code

MSDN

Sites

martedì 9 agosto 2011

Blendability con Moq e NBuilder

Che il vostro progetto sia sviluppato in WPF, Silverlight o Silverlight per WP7 un aspetto fondamentale (direi quasi un requisito non funzionale) da soddisfare è il supporto ai designer di Visual Studio/Blend, identificato con il termine “Blendability”.

Anche se può sembrare banale, in realtà la faccenda si complica man mano che i nostri ViewModel prendono forma e utilizziamo IoC.

In soldoni il Designer non è in grado di rappresentare graficamente una View collegata ad un ViewModel di questo tipo:

  1. public MainViewModel(IPersonService personService)
  2. {
  3.     People = new ObservableCollection<Person>(personService.GetAll());
  4.  
  5.     ShowPersonDetailCommand = new RelayCommand(PerformShowPersonDetail, CanShowPersonDetail);
  6. }

 

Tra le soluzioni possibili troviamo:

  1. utilizzare un ViewModelLocator che restituisce istanze diverse dei ViewModel se siamo a design-time o a run-time (es: link)
  2. utilizzare ViewModel che si comportano in modo diverso se siamo a design-time o a run-time (es: link)
  3. utilizzare file XAML in cui definire i dati fake (es: link)

Personalmente, anche se funzionanti, non mi piace nessuna delle soluzioni proposte in quanto:

  • vado ad inserire logica completamente estranea ai ViewModelLocator\ViewModel (punti 1, 2)
  • mi ritrovo a manutenere file XAML satelliti che andranno ad appesantire il refactoring (punto 3)

Da un po' di tempo a questa parte sto adottando la strategia che da il titolo a questo post: uso Moq e NBuilder.

Per chi non li conoscesse, sono 2 librerie che facilitano la scrittura di test automatici, essendo rispettivamente un framework di mocking e un tool per la generazione dinamica di oggetti.

Nonostante siano strumenti nati per altri scopi, ho deciso di provarli per ottenere ViewModel “blendabili”.

In pratica:

  • Vado a creare, possibilmente in un assembly a parte, un MainViewModelDesign  che eredita dal MainViewModel visto in precedenza.
  1. public class MainViewModelDesign : MainViewModel
  2. {
  3.     public MainViewModelDesign()
  4.         : base(GetMockedService())
  5.     {
  6.     }
  7. }
  • Il Metodo GetMockedService mi ritorna un mock che implementa IPersonService e va a definire i metodi utilizzati dal ViewModel in questione. In questo caso ho instrumentato Moq in maniera tale che, quando viene invocato il metodo GetAll, mi restituisca, tramite la classe Builder di NBuilder, un elenco di Person.
  1. private static IPersonService GetMockedService()
  2. {
  3.     var mockedService = new Mock<IPersonService>();
  4.     mockedService
  5.         .Setup(s => s.GetAll())
  6.         .Returns(Builder<Person>.CreateListOfSize(5).Build());
  7.  
  8.  
  9.     return mockedService.Object;
  10. }
  • Per collegare il nostro nuovo ViewModel useremo il Databinding e la proprietà d: DataContext, utilizzando la markup extension {d: DesignInstance} (maggiori info qui),  passando il nome del ViewModel che vogliamo venga creato automaticamente dal designer  (riga 12):
  1. <Window
  2.     x:Class="Blendability.Views.MainWindow"
  3.     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  4.     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  5.     xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
  6.     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
  7.     xmlns:viewModels="clr-namespace:Blendability.ViewModels.Design"
  8.     Title="People"
  9.     Height="350"
  10.     Width="525"
  11.     mc:Ignorable="d"
  12.     d:DataContext="{d:DesignInstance viewModels:MainViewModelDesign, IsDesignTimeCreatable=True}"
  13.     DataContext="{Binding Source={StaticResource locator}, Path=MainViewModel}">

Ovviamente possiamo ancora impostare la “solita” proprietà DataContext che verrà effettivamente utilizzata a runtime (riga 13).

A questo punto se apro Visual Studio o Blend avrò pieno supporto del designer:

image      image

 

Riassumendo:

  • ho definito un ViewModel che eredita dal ViewModel reale, e si preoccupa solo di visualizzare i dati (e che andrò a mettere su un assembly a parte) ed eventuale logica di generazione dei dati fake (tra l’altro NBuilder è abbastanza versatile e posso definire regole del tipo “le prime 5 Person devono avere Name = “Nome123abc” e DateOfBirth = “01/02/2003”, le restanti Name = “blablabla")
  • se farò refactoring non dovrò cambiare file XAML se non la View vera e propria
  • ho il pieno supporto dei designer: editing di stili\template con preview instantanea, animazioni, property window, etc
  • funziona per progetti WPF\ SL e WP7!

Ho preparato un esempio un pò più articolato di quello illustrato che potete scaricare qui. Ovviamente tutto quello che vedrete aprendo il designer NON lo vedrete a runtime A bocca aperta.

Cosa ne pensate? Come ottenete la blendability di solito nei vostri progetti?

posted @ martedì 9 agosto 2011 14.59 | Feedback (0) | Filed Under [ WPF SILVERLIGHT VISUAL STUDIO WP7 Blend ]

Powered by: