Alessandro Del Sole's Blog

Windows Phone 7: beta dei tool di sviluppo + risorse

Alessandro Del Sole — Thu, 29 Jul 2010 15:01:00 GMT

Da qualche giorno è disponibile la prima Beta dei tool di sviluppo per Windows Phone 7, che è possibile scaricare da questo indirizzo dell'area Download di Microsoft. Tra i vari tool disponibili, si annoverano:

emulatore del dispositivo
XNA Game Studio 4.0 beta
Estensioni per Visual Studio 2010
Expression Blend con estensioni per Windows Phone
VS 2010 Express per Windows Phone

Microsoft ha inoltre rilasciato le "UI Design and Interaction guide lines 2.0", ossia le specifiche per la realizzazione della UI di applicazioni per Phone, disponibili qui. Fondamentale anche il Training Kit aggiornato proprio per la Beta dei tool, disponibile a questo indirizzo.

Alessandro

Windows Azure passa da 8 a 16 mesi per abbonati MSDN

Alessandro Del Sole — Thu, 29 Jul 2010 14:55:00 GMT

Microsoft ha deciso di prolungare il periodo di utilizzo di Windows Azure da 8 a 16 mesi, incluso in uno degli abbonamenti MSDN Ultimate, Premium e BizSpark. Per cui se siete sottoscrittori di uno di questi abbonamenti avrete la possibilità di prolungare l'utilizzo di Azure sfruttando i benefici inclusi nell'abbonamento stesso.

Tutti i riferimenti utili li potete trovare in questo post.

Alessandro

ASP.NET MVC 3 Preview 1 disponibile per VS 2010

Alessandro Del Sole — Thu, 29 Jul 2010 14:53:00 GMT

Riporto quanto pubblicato da Pietro Brambati sul blog di MSDN Italia, inerente la disponibilità della prima preview di ASP.NET MVC 3 da utilizzare con Visual Studio 2010 e basata su .NET Framework 4. Ci sono alcune novità tra cui:

Supporto al un nuovo ViewEngine (“razor”), che offre una sintassi semplificata basata sull’uso di template per la scrittura di pagine HTML.

La classe View e ViewModel supportano l’aggiunta di proprietà dinamiche che rendono più semplice la scrittura del codice.

E’ ora possibile usare più View Engine, anche nella finestra di dialogo per l’aggiunta di una view.

Supporto migliorato per l’uso di tecniche di Dependency Injection (DI) via servizi di IoC che utilizzano l’interfaccia Service Locator.

Global Fillter: filtri che possono essere applicati globalmente a tutti gli Action Method di un controller.

Gli Action method possono ora ricevere e fare il bind di dati in formato JSON rendendo più semplice l’uso di client template nella View.

Supporto al modello di validazione e dei metadati migliorato, sfruttando quanto offerto da .NET 4.

Le classi del controller ora possono fare delle Permanent Redirect.

Per scaricare la preview si può andare a questo indirizzo.

Alessandro

Promozione MSDN: VS 2010 Professional upgrade per utenti delle Standard

Alessandro Del Sole — Tue, 27 Jul 2010 23:11:00 GMT

MSDN Italia ha realizzato una nuova promozione per coloro che hanno una licenza di Visual Studio 2005/2008 Standard e vogliono fare un aggiornamento, a prezzo ridotto, alla edizione Professional di Visual Studio 2010. Ecco i dettagli:

"Microsoft annuncia una promozione speciale dedicata a tutti gli utenti di Visual Studio Standard Edition 2005 e 2008.

In occasione del lancio di Visual Studio 2010 e in conseguenza del fatto che non esiste una edizione Standard per la famiglia di prodotti Visual Studio 2010, è stata annunciata la possibilità di passare a Visual Studio 2010 Professional al prezzo della Standard!

L’offerta è valida fino al 12 ottobre 2010

Il passaggio a Visual Studio 2010 Professional aiuta tutti gli sviluppatori a ricercare e navigare il codice in meno tempo, lavorare con monitor multipli e trovare velocemente i bug risparmiando tempo e denaro nel lavoro di tutti i giorni.

Ecco qui di seguito i benefici principali di Visual Studio 2010 Professional.

Nuovo supporto Multi-Targeting

· In Visual Studio 2010 il supporto multi-targeting è stato migliorato in modo da includere versioni di IntelliSense, elenchi API del Visualizzatore oggetti e finestre delle proprietà appositamente progettati per la versione del framework selezionata.

· Se il progetto utilizza una vecchia versione del framework, come ASP.NET 2.0 o 3.0, è possibile scegliere quale framework utilizzare per la build.

· In Visual Studio 2010 è possibile gestire contemporaneamente progetti creati in Visual Studio 2008, 2005 e 2003.

Sviluppo Web più potente

· Migliore qualità, manutenzione più semplice

· Visual Studio 2010 fornisce ora eccellente supporto per il pattern di programmazione Model-View-Controller (MVC). Questa tecnica estremamente diffusa per separare e suddividere i componenti dell'applicazione consente di generare codice riutilizzabile, più semplice da gestire e da testare.

· Da oggi è possibile concentrare l'attenzione sulla logica dell'applicazione: tutto il codice necessario per la compilazione e l'esecuzione degli unit test verrà infatti generato da Visual Studio rendendo più semplice la creazione e la gestione di siti Web di qualità.

· Supporto JavaScript avanzato

· Visual Studio 2010 Professional semplifica la compilazione di applicazioni Web basate su standard grazie a framework AJAX ottimizzati, al supporto IntelliSense per JavaScript di base e all'integrazione del noto framework jQuery, una libreria JavaScript open-source.

· Creazione di user experience avanzate con Silverlight 4

· Sono ora disponibili nuovi designer visuali per Windows Presentation Foundation e Silverlight ottimizzati per Windows®7 e per il Web.

· Visual Studio 2010 Professional include modelli e designer integrati che consentono di sviluppare e distribuire applicazioni moderne in modo facile e veloce.

· Meno tempo a fare Deployment e meno errori

· Con un solo clic è possibile fare il doployment delle applicazioni Web al server di produzione insieme a tutte le impostazioni del Web server, gli shemi di database e la configurazione corretta.

Supporto di Monitor multipli

Visual Studio 2010 incorpora molteplici miglioramenti IDE, tra cui il supporto per più monitor e una migliore leggibilità, caratteristiche che rendono l'ambiente ancora più produttivo.
Il supporto di monitor multipli consente di gestire meglio il codice e il debug, eventualmente anche grazie ad aiuti esterni visualizzabili sul secondo monitor.

Nota importante

È importate segnalare che questa versione non include MSDN Essentials. Se quindi volete trarre vantaggio dai benefici della nuova sottoscrizione associata a Visual Studio Professional 2010, è necessario acquistare la versione Visual Studio 2010 Professional Upgrade non in promozione."

Tutti i dettagli sulla promozione e le modalità di acquisto sono disponibili a questo indirizzo del sito Microsoft Store.

Alessandro

WPF: Introduzione al pattern Model-View-ViewModel per sviluppatori Visual Basic 2010 - sesta parte

Alessandro Del Sole — Mon, 26 Jul 2010 16:35:00 GMT

Nel post precedente abbiamo iniziato a trattare l'utilizzo del pattern MVVM nei confronti di ADO.NET Entity Framework come Model, all'interno di applicazioni WPF create con Visual Basic 2010.

Quick recap

La volta scorsa abbiamo:

creato l'Entity Data Model
discusso come questo costituisca il nostro Model, ossia la rappresentazione dei dati
implementato regole di validazione lato Model sfruttando IDataErrorInfo

In questo post scriviamo un po' più di codice relativo al pattern in questione, sebbene il grosso debba ancora venire ma impareremo a trovare la soluzione per un grosso problema che vi illustrerò di seguito.

La logica dei comandi

In un precedente post della serie abbiamo parlato di come ritrasmettere la logica di gestione dei command attraverso la classe RelayCommand e la sua variante generica RelayCommand(Of T). Nello scenario che stiamo trattando ora le cose non cambiano minimamente, per cui all'interno della cartella del progetto chiamata Commands, aggiungiamo un nuovo file di codice chiamato RelayCommand.vb e copia-incolliamo il codice relativo a entrambe le versioni della classe citata di cui, per comodità, riporto il codice completo:

Public Class RelayCommand

Implements ICommand

Private ReadOnly _execute As Action(Of Object)

Private ReadOnly _canExecute As Predicate(Of Object)

Public Sub New(ByVal execute As Action(Of Object))

Me.New(execute, Nothing)

End Sub

Public Sub New(ByVal execute As Action(Of Object), ByVal canExecute As Predicate(Of Object))

If execute Is Nothing Then

Throw New ArgumentNullException("execute")

End If

_execute = execute

_canExecute = canExecute

End Sub

<DebuggerStepThrough()> _

Public Function CanExecute(ByVal parameter As Object) As Boolean Implements ICommand.CanExecute

Return If(_canExecute Is Nothing, True, _canExecute(parameter))

End Function

Public Custom Event CanExecuteChanged As EventHandler Implements ICommand.CanExecuteChanged

AddHandler(ByVal value As EventHandler)

AddHandler CommandManager.RequerySuggested, value

End AddHandler

RemoveHandler(ByVal value As EventHandler)

RemoveHandler CommandManager.RequerySuggested, value

End RemoveHandler

RaiseEvent(ByVal sender As System.Object, ByVal e As System.EventArgs)

End RaiseEvent

End Event

Public Sub Execute(ByVal parameter As Object) Implements ICommand.Execute

_execute(parameter)

End Sub

End Class

Public Class RelayCommand(Of T)

Implements ICommand

Private ReadOnly _execute As Action(Of T)

Private ReadOnly _canExecute As Predicate(Of T)

Public Sub New(ByVal execute As Action(Of T))

Me.New(execute, Nothing)

End Sub

Public Sub New(ByVal execute As Action(Of T), ByVal canExecute As Predicate(Of T))

If execute Is Nothing Then

Throw New ArgumentNullException("execute")

End If

_execute = execute

_canExecute = canExecute

End Sub

<DebuggerStepThrough()> _

Public Function CanExecute(ByVal parameter As Object) As Boolean Implements ICommand.CanExecute

Return If(_canExecute Is Nothing, True, _canExecute(CType(parameter, T)))

End Function

Public Custom Event CanExecuteChanged As EventHandler Implements ICommand.CanExecuteChanged

AddHandler(ByVal value As EventHandler)

AddHandler CommandManager.RequerySuggested, value

End AddHandler

RemoveHandler(ByVal value As EventHandler)

RemoveHandler CommandManager.RequerySuggested, value

End RemoveHandler

RaiseEvent(ByVal sender As System.Object, ByVal e As System.EventArgs)

End RaiseEvent

End Event

Public Sub Execute(ByVal parameter As Object) Implements ICommand.Execute

_execute(CType(parameter, T))

End Sub

End Class

Un grosso problema: aprire finestre

Se vi ricordate la figura nel post precedente che illustra l'applicazione completa che stiamo creando, notate la presenza di un pulsante chiamato View Details il cui scopo è lanciare una nuova Window all'interno della quale visualizzare tutti i dettagli dell'ordine selezionato nella finestra principale. In un contesto non-MVVM, niente di più semplice: gestisco l'evento Click del pulsante, istanzio la Window, la mostro, la distruggo. In un contesto MVVM, invece, è tutto molto più complicato. Non posso gestire l'evento Click di un pulsante, perchè il pulsante è collegato a un comando esposto dal ViewModel. Al tempo stesso, quando si invoca tale comando, non posso istanziare una View da un ViewModel e mostrarla da lì perché questo è totalmente contrario ai principi di MVVM, secondo cui nel ViewModel non si gestisce la UI e secondo cui nelle View ci deve essere solo codice che gestisca la UI. Non solo: come potrei rimandare alla View il risultato di una dialog attraverso un ViewModel?

La soluzione si realizza attraverso un principio basato su un sistema di scambio di messaggi che vengono inviati, intercettati e gestiti. Per capire meglio il discorso, proviamo a pensare agli eventi classici: clicco un pulsante sulla View, a questo punto un comando nel ViewModel scatena un evento. La View intercetta il verificarsi dell'evento e a questo punto istanzia e mostra una dialog secondaria. Stessa cosa potrebbe avvenire al chiudersi della dialog secondaria. In realtà, sebbene funzionante e semplicistico, l'approccio basato su eventi funziona ma non è il top. I maggiori esponenti e conoscitori di MVVM implementano un pattern chiamato Mediator che funziona in questo modo:

al suo avvio, l'applicazione definisce alcuni messaggi che saranno inviati agli oggetti
le View (in genere, ma non necessariamente solo loro) si "iscrivono" al servizio di messaggi cosicchè saranno informate quando i messaggi stessi saranno inviati
i ViewModel, quando i comandi vengono eseguiti, inviano il messaggio desiderato
le View vengono notificate dell'invio del messaggio e agiscono di conseguenza

Con un esempio "empirico" riferito alla nostra applicazione, la View principale si iscrive al servizio di messaggi per sapere quando è stato cliccato il pulsante. Quando viene fatto clic, viene invocato l'apposito comando nel ViewModel il cui compito sarà quello di inviare il messaggio. Quando la View riceve la notifica del messaggio inviato, mostra la dialog secondaria attraverso un delegate che viene invocato in tale momento. E' più difficile a dirsi che a farsi, come vedremo parlando attraverso il codice.

La classe Messenger

Sebbene l'idea di fondo sia quella del pattern Mediator, anche in questo caso ci sono tante implementazioni e differenze. Personalmente mi rifaccio a quelle fornite da Josh Smith e Karl Shifflett, due veri guru di MVVM e WPF. Il sistema di messaggistica viene implementato attraverso la definizione di una classe chiamata Messenger e che agisce come un c.d. message broker. Tra i vari membri e le varie sotto-classi che questa espone, due sono quelli fondamentali:

metodo Register
metodo NotifyToColleagues

Il primo si invoca per iscriversi al servizio di ricezione di un certo messaggio, il secondo si usa per inviare il messaggio stesso. Per necessità espositiva riporto il codice dell'intera classe, ma non la descriverò per intero. A tal fine vi segnalo il blog di Karl Shifflett che ha proposto tale classe nel suo framework chiamato Ocean. Ecco il codice, di cui faremo qualche commento dopo:

Imports System.Reflection

''' <summary>

''' Provides loosely-coupled messaging between

''' various colleague objects. All references to objects

''' are stored weakly, to prevent memory leaks.

''' </summary>

Public Class Messenger

Public Sub New()

End Sub

''' <summary>

''' Registers a callback method to be invoked when a specific message is broadcasted.

''' </summary>

''' <param name="message">The message to register for.</param>

''' <param name="callback">The callback to be called when this message is broadcasted.</param>

Public Sub Register(ByVal message As String, ByVal callback As [Delegate])

If String.IsNullOrEmpty(message) Then

Throw New ArgumentException("'message' cannot be null or empty.")

End If

If callback Is Nothing Then

Throw New ArgumentNullException("callback")

End If

Dim parameters As ParameterInfo() = callback.Method.GetParameters()

If parameters IsNot Nothing AndAlso parameters.Length > 1 Then

Throw New InvalidOperationException("The registered delegate can have no more than one parameter.")

End If

Dim parameterType As Type = If((parameters Is Nothing OrElse parameters.Length = 0), Nothing, parameters(0).ParameterType)

_messageToActionsMap.AddAction(message, callback.Target, callback.Method, parameterType)

End Sub

''' <summary>

''' Notifies all registered parties that a message is being broadcasted.

''' </summary>

''' <param name="message">The message to broadcast.</param>

Public Sub NotifyColleagues(ByVal message As String)

If String.IsNullOrEmpty(message) Then

Throw New ArgumentException("'message' cannot be null or empty.")

End If

Dim actions = _messageToActionsMap.GetActions(message)

If actions IsNot Nothing Then

actions.ForEach(Function(action) action.DynamicInvoke())

End If

End Sub

''' <summary>

''' Notifies all registered parties that a message is being broadcasted.

''' </summary>

''' <param name="message">The message to broadcast</param>

''' <param name="parameter">The parameter to pass together with the message</param>

Public Sub NotifyColleagues(ByVal message As String, ByVal parameter As Object)

If String.IsNullOrEmpty(message) Then

Throw New ArgumentException("'message' cannot be null or empty.")

End If

Dim actions = _messageToActionsMap.GetActions(message)

If actions IsNot Nothing Then

actions.ForEach(Function(action) action.DynamicInvoke(parameter))

End If

End Sub

''' <summary>

''' This class is an implementation detail of the Messenger class.

''' </summary>

Private Class MessageToActionsMap

' Stores a hash where the key is the message and the value is the list of callbacks to invoke.

ReadOnly _map As New Dictionary(Of String, List(Of WeakAction))()

Friend Sub New()

End Sub

''' <summary>

''' Adds an action to the list.

''' </summary>

''' <param name="message">The message to register.</param>

''' <param name="target">The target object to invoke, or null.</param>

''' <param name="method">The method to invoke.</param>

''' <param name="actionType">The type of the Action delegate.</param>

Friend Sub AddAction(ByVal message As String, ByVal target As Object, ByVal method As MethodInfo, ByVal actionType As Type)

If message Is Nothing Then

Throw New ArgumentNullException("message")

End If

If method Is Nothing Then

Throw New ArgumentNullException("method")

End If

SyncLock _map

If Not _map.ContainsKey(message) Then

_map(message) = New List(Of WeakAction)()

End If

_map(message).Add(New WeakAction(target, method, actionType))

End SyncLock

End Sub

''' <summary>

''' Gets the list of actions to be invoked for the specified message

''' </summary>

''' <param name="message">The message to get the actions for</param>

''' <returns>Returns a list of actions that are registered to the specified message</returns>

Friend Function GetActions(ByVal message As String) As List(Of [Delegate])

If message Is Nothing Then

Throw New ArgumentNullException("message")

End If

Dim actions As List(Of [Delegate])

SyncLock _map

If Not _map.ContainsKey(message) Then

Return Nothing

End If

Dim weakActions As List(Of WeakAction) = _map(message)

actions = New List(Of [Delegate])(weakActions.Count)

For i As Integer = weakActions.Count - 1 To -1 + 1 Step -1

Dim weakAction As WeakAction = weakActions(i)

If weakAction Is Nothing Then

Continue For

End If

Dim action As [Delegate] = weakAction.CreateAction()

If action IsNot Nothing Then

actions.Add(action)

Else

' The target object is dead, so get rid of the weak action.

weakActions.Remove(weakAction)

End If

' Delete the list from the map if it is now empty.

If weakActions.Count = 0 Then

_map.Remove(message)

End If

End SyncLock

Return actions

End Function

End Class

''' <summary>

''' This class is an implementation detail of the MessageToActionsMap class.

''' </summary>

Private Class WeakAction

ReadOnly _delegateType As Type

ReadOnly _method As MethodInfo

ReadOnly _targetRef As WeakReference

''' <summary>

''' Constructs a WeakAction.

''' </summary>

''' <param name="target">The object on which the target method is invoked, or null if the method is static.</param>

''' <param name="method">The MethodInfo used to create the Action.</param>

''' <param name="parameterType">The type of parameter to be passed to the action. Pass null if there is no parameter.</param>

Friend Sub New(ByVal target As Object, ByVal method As MethodInfo, ByVal parameterType As Type)

If target Is Nothing Then

_targetRef = Nothing

Else

_targetRef = New WeakReference(target)

End If

_method = method

If parameterType Is Nothing Then

_delegateType = GetType(Action)

Else

_delegateType = GetType(Action(Of )).MakeGenericType(parameterType)

End If

End Sub

''' <summary>

''' Creates a "throw away" delegate to invoke the method on the target, or null if the target object is dead.

''' </summary>

Friend Function CreateAction() As [Delegate]

' Rehydrate into a real Action object, so that the method can be invoked.

If _targetRef Is Nothing Then

Return [Delegate].CreateDelegate(_delegateType, _method)

Else

Try

Dim target As Object = _targetRef.Target

If target IsNot Nothing Then

Return [Delegate].CreateDelegate(_delegateType, target, _method)

End If

Catch

End Try

End If

Return Nothing

End Function

End Class

ReadOnly _messageToActionsMap As New MessageToActionsMap()

End Class

Essenzialmente il metodo Register riceve il messaggio del quale gli oggetti "iscritti" riceveranno le notifiche e un delegate il cui compito è quello di eseguire l'azione desiderata al verificarsi dell'invio del messaggio. Il metodo NotifyToColleagues, invece, invia il messaggio a tutti gli oggetti in ascolto. Lo vedremo comunque in pratica nei post successivi, per cui non temete se al momento il discorso non vi sembra chiaro.

Fine della sesta parte

Per ora ci fermiamo qui. Abbiamo implementato una classe Messenger per lo scambio di messaggi tra oggetti "colleghi" e la classe RelayCommand. Ci manca ancora un bel po', per realizzare quella che è un'applicazione M-V-VM abbastanza ben strutturata e nel prossimo post inizieremo a parlare di uno strato di servizi che permetterà al ViewModel di dialogare con i dati, senza sapere che al di sotto c'è Entity Framework. Cose decisamente interessanti.

Alessandro

WPF: Introduzione al pattern Model-View-ViewModel per sviluppatori Visual Basic 2010 - quinta parte

Alessandro Del Sole — Sun, 25 Jul 2010 16:57:00 GMT

Dopo aver fatto una pausa più o meno lunga sulla trattazione del pattern Model-View-ViewModel con WPF 4 e Visual Basic 2010, riprendiamo il discorso al punto in cui vi avevo promesso di continuare, ossia parlare di questo pattern nell’ambito di un contesto sicuramente più interessante come quello di adottarlo nei confronti di ADO.NET Entity Framework. Prima di addentrarci nel codice, sono opportune alcune illustrazioni discorsive.

Dove vogliamo arrivare

Alla fine della serie di post arriveremo a realizzare questo:

Quindi una semplice applicazione master-details, che permetterà di lanciare anche una finestra. Banale, indubbiamente, se si ragiona per gestori di eventi e click invece che per command binding, data binding e ViewModel. Ci renderemo infatti conto di come sia complesso questo pattern ma anche del perché ha i suoi benefici. Parleremo di message broker, di service locators e altro. Non ho l'obiettivo nè tanto meno la pretesa di illustrare un'applicazione reale. L'obiettivo che mi pongo, non solo come "relatore" ma come "studioso" del pattern, se volete, è quello di capirne i concetti, capire come funziona, capire il livello di astrazione da raggiungere. E' una precisazione che tenevo a fare.

Non sono esente da errori

Considerato quanto affermato al paragrafo precedente, non sono esente da errori. Ribadisco di non essere un guru di MVVM, semplicemente condivido con chi ha voglia di seguirmi quello che è il percorso che sto personalmente facendo nello studio del pattern. Per tale ragione non tutto potrebbe essere perfetto e ben vengano le correzioni e i feedback di chi, invece, padroneggia la materia.

Quante possibilità, quante "non regole"...

Già in precedenza abbiamo detto che MVVM è un pattern, non una regola. E' un insieme di linee guida che ha una finalità ben precisa, certo, ma ci sono tante, tantissime varianti e questo può portare a confusione. La verità è che nel momento in cui stavo per iniziare la serie di post dedicata a MVVM con Entity Framework, ho capito che non era poi così tutto scontato e studi ulteriori mi hanno permesso di capire quanto invece fosse il vero lavoro da fare per arrivare a un certo livello di astrazione, in questo aiutato dalle indicazioni di Corrado, Andrea, Raf, Davide, Karl Shifflett. Banalmente basterebbe far interagire il ViewModel con il DAL; funziona, senz'altro, ma non è "pulito". Ho scovato esempi su Internet in cui si faceva in questo modo, oppure esempi molto più complessi e "astrattivi" ma poco calzanti, a mio avviso. Mi sono convinto della bontà delle indicazioni ricevute dai "colleghi" MVP e su questa falsariga sono andato avanti. Il tutto, ripeto, può contenere degli errori che prontamente saranno fixati. Ora basta ciance, mettiamoci all'opera.

Creazione del progetto

Dopo aver avviato Microsoft Visual Studio 2010, creiamo un nuovo progetto WPF 4 con Visual Basic 2010. In questo primo post ci sarà poco di MVVM, prepareremo infatti la base di quanto ci servirà nei prossimi post. All'interno di Solution Explorer creiamo le seguenti folders: Models (che conterrà i nostri dati), ViewModels (per tutti i ViewModel), Views (per tutte le View), Commands (che conterrà le logiche di implementazione dei comandi), Helpers (che conterrà classi di supporto) e Services (che conterrà interfacce e classi di servizio che vedremo successivamente).

L'Entity Data Model, ovvero il nostro Model

ADO.NET Entity Framework è una tecnologia complessa per l'accesso ai dati. Non ci addentriamo in discorsi di tipo "domani model" et similia, semplicemente utilizzeremo Entity Framework come strato di accesso ai dati nei confronti del database dimostrativo Northwind, basato su SQL Server, del quale mapperemo come oggetti .NET tre tabelle tipiche: Customers, Orders e Order Details. Ciò premesso, tasto destro sul nome del progetto -> Add|New Item -> scheda Data e template ADO.NET Entity Data Model. Assegnamo all'EDM il nome Northwind.edmx e procediamo tramite il wizard selezionando il db Northwind e lasciando inalterate le impostazioni di default, accertandoci di selezionare le tabelle richieste come in figura:

Al termine della procedura guidata il designer di Entity Framework mostrerà in Visual Studio 2010 la rappresentazione grafica del mapping ottenuto, visibile in figura:

A questo punto abbiamo delle classi che rappresentano i nostri dati e per tale ragione possono essere considerate il nostro Model.

Considerazioni sulle Entities come Model

Come detto, le entità possono essere considerate come il nostro Model. Di default le entità implementano l'interfaccia INotifyPropertyChanged e questa è una ragione in più per considerarle come Model. In realtà, nei primi post su MVVM tale interfaccia è stata implementata nel ViewModel al fine di inviare notifiche alle View. Non è di certo un male se essa è implementata anche nel Model, fornendo un punto di notifica eventuale anche verso oggetti esterni come può essere per l'appunto un ViewModel.

Implementare la validazione dei dati

In questo post non parlerò di ViewModel. Piuttosto passeremo ad un qualcosa che precedentemente abbiamo visto solo nell'ultimo post, ossia prevedere delle regole di validazione. Facendo riferimento alla figura iniziale dell'applicazione che vogliamo realizzare, notiamo come sia possibile gestire gli ordini di ciascun cliente. Ipotizziamo che un ordine, nuovo o esistente, possa essere accettato solo qualora venga immesso lo Stato di destinazione, che nel nostro codice è rappresentato dalla proprietà ShipCountry della classe Order. Se avete un po' di dimestichezza con Entity Framework, sapete che il runtime genera due metodi utili allo scopo, OnXXXChanging e OnXXXChanged dove XXX è il nome della proprietà da validare. Nel nostro caso, avremo OnShipCountryChanging e OnShipCountryChanged. A noi interessa in modo particolare quest'ultimo, che viene richiamato quando la proprietà subisce una modifica. Poiché è buona regola di programmazione quella di non toccare i file autogenerati da Visual Studio, possiamo sfruttare le caratteristiche delle classi parziali e dei metodi parziali. In parole povere, creiamo una classe parziale Order che estenda quella autogenerata. Detto ciò, nella cartella Models del nostro progetto aggiungiamo una nuova classe e chiamiamo il file di codice come Order.vb. In questa classe:

l'intestazione sarà di Partial Class
implementeremo l'interfaccia IDataErrorInfo per la validazione dei dati
implementeremo la logica di validazione
all'interno del metodo OnShipCountryChanged invocheremo l'aggiunta o la rimozione di un errore alla collezione degli errori di validazione, a seconda della validità del valore immesso.

Il codice della classe è il seguente, opportunamente commentato:

Imports System.ComponentModel

Partial Public Class Order

Implements IDataErrorInfo

'Collezione di errore/descrizione

Private m_validationErrors As New Dictionary(Of String, String)

'Aggiunge un errore alla collezione, se non già presente

'con la stessa chiave

Private Sub AddError(ByVal columnName As String, ByVal msg As String)

If Not m_validationErrors.ContainsKey(columnName) Then

m_validationErrors.Add(columnName, msg)

End If

End Sub

'Rimuove un errore dalla collezione, se presente

Private Sub RemoveError(ByVal columnName As String)

If m_validationErrors.ContainsKey(columnName) Then

m_validationErrors.Remove(columnName)

End If

End Sub

'Estende la classe con una proprietà che determina

'se l'istanza ha errori di validazione

Public ReadOnly Property HasErrors() As Boolean

Get

Return m_validationErrors.Count > 0

End Get

End Property

'Restituisce un messaggio di errore

'In questo caso è un messaggio generico, che viene

'restituito se l'elenco di errori contiene elementi

Public ReadOnly Property [Error] As String Implements System.ComponentModel.IDataErrorInfo.Error

Get

If m_validationErrors.Count > 0 Then

Return "Order data is invalid"

Else

Return Nothing

End If

End Get

End Property

Default Public ReadOnly Property Item(ByVal columnName As String) As String _

Implements System.ComponentModel.IDataErrorInfo.Item

Get

If m_validationErrors.ContainsKey(columnName) Then

Return m_validationErrors(columnName).ToString

Else

Return Nothing

End If

End Get

End Property

'Metodo parziale che esegue la validazione

Private Sub OnShipCountryChanged()

If String.IsNullOrEmpty(Me.ShipCountry) Then

Me.AddError("ShipCountry", "You need to specify the ship country")

Else

Me.RemoveError("ShipCountry")

End If

End Sub

Public Sub New()

'Gestendo quest'evento possiamo notificare alla UI

'che l'associazione con il Customer è cambiata

AddHandler Me.CustomerReference.AssociationChanged, AddressOf Customer_AssociationChanged

'Imposta un valore di default

Me.ShipCountry = String.Empty

'Aggiunge subito l'errore quando un nuovo ordine viene creato,

'di modo che l'utente sia obbligato a fixare il problema

Me.AddError("ShipCountry", "You need to specify the ship country")

End Sub

'Evento che viene generato nel caso in cui l'utente cambia

'l'associazione tra ordine e cliente

Private Sub Customer_AssociationChanged(ByVal sender As Object, _

ByVal e As CollectionChangeEventArgs)

If e.Action = CollectionChangeAction.Remove Then

OnPropertyChanging("Customer")

Else

If e.Action = CollectionChangeAction.Add Then

Me.RemoveError("Customer")

End If

OnPropertyChanged("Customer")

End If

End Sub

End Class

Di interessante rileviamo il gestore di evento Customer.AssociationChanged che ci permette di verificare che sia cambiata l'associazione tra ordine corrente e cliente.

Fine della prima parte

Per il momento ci fermiamo qui, potendo dire di aver completato l'aggiunta del Model. Nel prossimo post vedremo come implementare uno strato di servizi che consenta ai ViewModel di lavorare con i dati, pur non sapendo che sta interagendo con Entity Framework, al fine di favorire un adeguato livello di astrazione. Come sempre, vi invito a lasciare i vostri commenti/suggerimenti/critiche/segnalazioni di imprecisioni. Non rilascio codice da scaricare, lo farò al termine della serie di post con il download dell'applicazione completa, così vi costringo a seguirmi :-)

Alessandro

WPF 4: "WPF Tracing"

Alessandro Del Sole — Thu, 22 Jul 2010 15:30:00 GMT

Un'altra novità in WPF 4, anche se per essere precisi è una novità di Visual Studio 2010 che interviene verso WPF, è il cosiddetto WPF Tracing, che permette di ottenere informazioni di debug molto più dettagliate, che si rivelano molto utili soprattutto nel risolvere problemi legati al data-binding (ma non solo, ovviamente). Per attivare il tracing andiamo in Tools|Options|Debugging, quindi selezioniamo la voce Output Window. Basta andare nel gruppo chiamato WPF Trace Settings e selezionare quale area del runtime di WPF si desidera conoscere dettagliatamente in fase di debug ed è possibile specificare il livello di informazione da ottenere attraverso le apposite combobox a fianco di ciascuna voce, come si può vedere dalla seguente figura:

In questo modo quando l’applicazione è eseguita attraverso il debugger, nella finestra di output verranno mostrati i messaggi rilevati dal debugger in merito alla specifica categoria selezionata.

Alessandro

WPF 4: Bindable runs

Alessandro Del Sole — Wed, 21 Jul 2010 12:00:00 GMT

Una delle novità introdotte in WPF con .NET Framework 4.0 è costituita dai c.d. "bindable Runs". Un oggetto Run consente di mostrare testo formattato (o meno) all'interno di documenti dinamici, come ad esempio i FlowDocument. La novità è che ora il testo può provenire da un altro controllo, risorsa od origine dati collegata in data-binding. Tralasciando come il contenuto di un Run possa essere formattato (il link precedente alla documentazione MSDN mostra tutti i dettagli del caso), vediamo un semplicissimo esempio di codice in cui un oggetto Run è in grado di mostrare, tramite binding, il contenuto della digitazione all'interno di una TextBox, riflettendo il contenuto stesso all'interno del FlowDocument:

</Paragraph>

</FlowDocument>

</FlowDocumentReader>

</StackPanel>

In sostanza si utilizza la già nota markup extension Binding. Gli usi veri e propri saranno chiaramente diversi, quello che è interessante è che questo tipo di tecnica potrà influenzare a runtime i documenti dinamici a seconda del variare degli oggetti "bindati" al Run.

Alessandro