Voor degenen voor wie het niet duidelijk is wat Model View Presenter doet, zal ik het even toelichten.

Model staat voor het Model Domain: Het (business) probleem dat je op probeert te lossen.
View staat voor de UI waarmee je met de gebruiker gaat communiceren.
Presenter staat voor de laag tussen die je Model fysiek van de View scheidt. Deze laag zorgt ervoor dat je Model niet afhankelijk is van je UI. In de praktijk blijkt deze laag ook uitermate geschikt voor unittesting. Je bent immers niet langer afhankelijk van je UI om je businesslogic te kunnen testen.

In de praktijk zal bestaat het Model vaak uit een of meer data entiteiten en businessrules. De view bestaat uit een interface die de mogelijkheden die de UI heeft omschrijft. De UI (Windows/WPF/Silverlight/Web/???) implementeert de view interface. De presenter zorgt voor de communicatie tussen de view interface en het model.

MVP Schematic Model

Voorbeeld:
Als voorbeeld gebruik ik een zeer vereenvoudigde manier om persoonsgegevens te muteren.

UI wordt geladen en roept op de Presenter een Initialize method aan. De presenter gebruikt het Model om de juiste gegevens te verzamelen. Vervolgens roept de presenter op de View de FillFields method aan en geeft de data als parameter mee. De UI die de View implementeert weet hoe de data weergegeven moet worden.

Vervolgens wordt er op OK geklikt. De OK button roept op de Presenter de SaveData method aan met de data, waarna de Presenter aan het Model opdracht geeft om eventuele wijzigingen op te slaan. Als hierbij een regel overtreden wordt, dan ontvangt de Presenter van het Model een validatie waarschuwing. De Presenter roept op de View een method aan aan met het validatiebericht, waarop de UI zorgt dat de melding getoond wordt.

Op deze manier is het zelfs mogelijk om twee hele verschillende UI’s dezelfde taak te laten uitvoeren. Als de UI de View inteface implementeert en de juiste calls op de presenter maakt zal het gewoon werken. De UI is in feite nog maar een heel dun schilletje dat geen enkele logica meer bevat.

Klinkt makkelijk he?

Is het deels ook. Deels ook helemaal niet. Dat komt door de fundamenteel verschillende manieren waarop een UI platform kan werken.
Als je je namelijk bij het ontwerp van je MVP classes en interfaces alleen richt op Windows Forms applicaties dan kom je jezelf onherroepelijk tegen als je deze classes wil gebruiken in een ASP.NET Webforms applicatie. Je hebt namelijk waarschijnlijk je hele ontwerp erop gebaseerd dat je state hebt. En dat heb je in ASP.NET niet op dezelfde manier zoals je dat in een Windows Forms applicatie. ASP.NET is in de basis zo stateless als maar zijn kan. ‘Gewoon’ even wat data in memory houden is er dus niet bij. Met statics moet je in ASP.NET Webforms rekening houden met multithreading.

Ok, dan vliegen we het toch aan vanuit de hoek van ASP.NET Webforms? Als je je bij het ontwerp van je MVP classes en interfaces alleen richt op ASP.NET Webforms dan kom je jezelf waarschijnlijk ook tegen. Je hebt het state probleem namelijk zojuist waarschijnlijk opgelost door gebruik te maken van je SessionState of Cache, wat het gebruik van deze classes en interfaces in een Windows Forms applicatie (bij het gebrek aan deze twee middelen) op zijn zachtst gezegd tot een uitdaging maakt.

I bring to you: Stateless Windows Forms.
Als je dus geen gebruik mag maken van de ‘statehulpmiddelen’ van ASP.NET, dan is ASP.NET WebForms tot nu toe helaas stateless. Daar doe je weinig aan. Bij Windows Forms heb je, hoewel het in het begin misschien wat vreemd aanvoelt, de keuze. Als je er rekening mee houdt dat je MVP classes en interfaces geen gebruik mogen maken van de state die Windows Forms biedt, maar ook niet van de technieken die ASP.NET biedt om het state(less) probleem op te lossen, dan kom je al een heel eind. Om jezelf te dwingen om hier rekening mee te houden doe je er goed aan om je Views en Presenters in een apart project onder te brengen waarbij je System.Windows.?? en System.Web.?? weigert te referencen. Bij je Model (data en businesslogic) hield je hier (als het goed is) al rekening mee.

Oplossing in het Driessen Framework
Met  bovengenoemde uitdaging in het achterhoofd hebben we in het framework een kleine ‘MVP Suite’ gebouwd die het voor de develpers makkelijk moet maken om applicaties standaard op MVP op te tuigen. Zo is straks een eventuele overstap van Windows Forms naar WPF ook eenvoudiger.

Het klinkt misschien vrij complex maar de daadwerkelijke implementatie is eigenlijk een lachertje, als je het concept maar snapt.

Model
Voor het Model hebben we in het Driessen Framework een BaseModel class gebouwd. De specifieke model class zal hiervan inheriten en bevat, naast de data entiteit en eventuele gerelateerde gegevens, de businesslogic voor het domain model. Deze class is gebouwd volgens stateless sessions, maar zonder gebruik te maken van SessionState of Caching. In Web gebruik je wel het SessionId om de sessie voor de dataclass te identificeren. In Windows bepaald het entry form een SessionId door een GUID hiervoor te genereren. De data wordt gecached via een custom caching systeem dat dus multi-platform werkt. Dit systeem zorgt er bijvoorbeeld ook automatisch voor voor dat disposes op het juiste moment plaatsvinden.

 /// <summary>
/// Base model for MVP projects that is able to work stateless/cross-session
/// Inherit: MyModel:BaseModel<MyModel>
/// </summary>
/// <typeparam name="TModelType">The type of the model that inherits this BaseModel</typeparam>
/// <example>
/// How to implement:
/// MyModel:BaseModel<MyModel>;
/// {
///    OtherEntityGrid otherEntityGrid;
///
///     public override Init(IBaseClass baseClass, IList<RelatedItem>relatedItems)
///     {
///         base.Init(baseClass, relatedItems);
///
///         otherEntityGrid = new OtherEntityGrid(baseClass.Core);
///         AutoDispose.Add(otherEntityGrid);
///     }
/// }
///
/// How to retrieve an instance:
/// MyModel myModel = MyModel.GetInstance(sessionId);
///
/// if (!myModel.Initialized)
/// {
///     myModel.Init(baseClass);
/// }
/// </example>
public class BaseModel<TModelType> : IDisposable
where TModelType : IDisposable
{
   #region Instance Members

    private readonly DisposableList autoDispose = new DisposableList();

    /// <summary>
   /// Auto dispose list for the Model to use to automatically dispose resources
   /// </summary>
   protected IList<IDisposable> AutoDispose
   {
      get
      {
         return autoDispose;
      }
   }

   /// <summary>
   /// True after the Init method was called
   /// </summary>
   public virtual bool Initialized
   {
      get;
      private set;
   }

   /// <summary>
   /// The baseclass used for editing
   /// </summary>
   public virtual IBaseClass BaseClass
   {
      get;
      private set;
   }

   /// <summary>
   /// The related items of the class
   /// </summary>
   public virtual IList<RelatedItem> RelatedItems
   {
      get;
      private set;
   }

   /// <summary>
   /// Initializes the model
   /// </summary>
   /// <param name="baseClass">The main baseclass of the model (optional)</param>
   /// <param name="relatedItems">Related items for the model (optional)</param>
   public virtual void Init(IBaseClass baseClass = null, IList<RelatedItem> relatedItems = null)
   {
      Initialized = true;
      BaseClass = baseClass;
      RelatedItems = relatedItems;
   }

   #endregion

   #region Static Members

   /// <summary>
   /// The default cache session id
   /// </summary>
   private const string defaultSesionId = "[DefaultSession]";

   /// <summary>
   /// The cache for session support
   /// </summary>
   private static volatile DisposableDictionary<string, TModelType> cache = new DisposableDictionary<string, TModelType>();

   /// <summary>
   /// Gets an instance from the cache for the provided session (or for the default session)
   /// Creates a new instance if no instance exists for the session yet
   /// </summary>
   /// <param name="sessionId">The session to get an instance for (optional)</param>
   /// <returns>The instance for the provided session (or the default session instance)</returns>
   public static TModelType GetInstance(string sessionId = defaultSesionId)
   {
      EnsureCache();

      TModelType returnValue;
      if (!cache.TryGetValue(sessionId, out returnValue))
      {
         returnValue = Activator.CreateInstance<TModelType>();
         cache.Add(sessionId,returnValue);
      }
      return returnValue;

   }

   /// <summary>
   /// Disposes the content for the session
   /// </summary>
   /// <param name="sessionId">The session to dispose the content for (optional)</param>
   public static void Dispose(string sessionId = defaultSesionId)
   {
      TModelType itemToDispose;

      if (cache != null && cache.TryGetValue(sessionId, out itemToDispose))
      {
         itemToDispose.Dispose();
         cache.Remove(sessionId);
      }
   }

   /// <summary>
   /// Disposes the entire content of the cache
   /// </summary>
   public static void DisposeAll()
   {
      if (cache != null)
      {
         cache.Dispose();
         if (cache.Count > 0)
               cache.Clear();
      }
   }

   /// <summary>
   /// Ensures the existance of the cache
   /// </summary>
   private static void EnsureCache()
   {
      if (cache == null)
         cache = new DisposableDictionary<string, TModelType>();
   }
   #endregion

   #region IDisposable

   /// <summary>
   /// Disposes the instance
   /// </summary>
   public void Dispose()
   {
      Dispose(true);
      GC.SuppressFinalize(this);
   }

   /// <summary>
   /// Disposes the instance
   /// </summary>
   /// <param name="disposing">Disposes managed objects</param>
   protected virtual void Dispose(bool disposing)
   {
      if (disposing)
         autoDispose.Dispose();
   }
   #endregion

   }
}

View
Voor communicatie vanuit de businessrules naar de UI hebben we een 2-tal simpele call mechanismen in een standaard View interface gegoten waarmee een eenvoudig bericht of een validation result naar de UI doorgegeven kan worden. De UI bepaalt op welke manier dit weergegeven wordt, afhankelijk van het platform waarop gewerkt wordt.

/// <summary>
/// The MVP view base
/// </summary>
public interface IViewBase
{
   /// <summary>
   /// Shows a message
   /// </summary>
   /// <param name="messageText">The message text</param>
   /// <param name="icon">The message icon</param>
   void ShowMessage(string messageText, ShowMessageIcon icon = ShowMessageIcon.Information);
   /// <summary>
   /// Shows the validation result
   /// </summary>
   /// <param name="validationResult">The validationreuslt</param>
   void ShowMessage(ValidationResult<ValidationMessage> validationResult);
}

Presenter
Voor de presenters hebben we in het framework een base class gemaakt die het BaseModel kan managen en initialiseren. De presenter zorgt zelf dat hij steeds de juiste data voor de huidige session paraat heeft staan als hij een call ontvangt.

/// <summary>
/// Base Presenter class
/// </summary>
/// <typeparam name="TView">The view corresponding to the presenter</typeparam>
/// <typeparam name="TModelType">The type of the model</typeparam>
public class PresenterBase<TView, TModelType>
where TView:IViewBase
where TModelType:BaseModel<TModelType>
{
  /// <summary>
  /// The view corresponding to the presenter
  /// </summary>
  protected TView View
  {
    get;
    private set;
  }
  /// <summary>
  /// The model for the presenter
  /// </summary>
  protected TModelType Model
  {
    get;
    private set;
  }
  /// <summary>
  /// The session ID
  /// </summary>
  protected string SessionId
  {
     get;
     set;
  }
  /// <summary>
  /// Constructor
  /// </summary>
  /// <param name="view">The view corresponding to the presenter</param>
  public PresenterBase(TView view)
  {
    View = view;
  }
  /// <summary>
  /// Initializes the presenter and gets the Data class instance for the session
  /// </summary>
  /// <param name="sessionId">The session ID to get the Data class instance for</param>
  /// <param name="baseClass">A baseclass to work with (optional, not used at the framework level)</param>
  public virtual void Init(string sessionId, IBaseClass baseClass = null)
  {
    SessionId = sessionId;
    Model = BaseModel<TModelType>.GetInstance(sessionId);
  }

 

De combinatie van deze drie vormt een krachtig middel om ècht platform onafhankelijk het MVP concept te gebruiken.

Een veel gehoorde vraag is: Waarom helemaal daarheen? Waarom gaan jullie niet gewoon naar de DevDays?
De reden om sowieso jaarlijks naar de DevDays te gaan en in bijzondere gevallen ook naar een major event in het buitenland is tamelijk eenvoudig:

De DevDays is in mijn ogen met name erop gericht om mensen te laten weten wat er is, wat eraan komt en om ze aan de hand van pakkende voorbeelden te triggeren om eens wat dieper in de techniek te duiken. Dat is voor ons de reden om daar ook echt jaarlijks heen te willen. Je wil geen bruikbare technieken over het hoofd zien, of achter de feiten aanlopen.Major events zoals de VSLive! en de DevConnections hebben voor een deel dezelfde strekking, maar voor het overgrote deel gaan ze nèt dat stapje verder. Een stukje ‘outside the comfort zone’ van wat een technologie out-of-the-box kan. Als die geweldige nieuwe techniek (waarvan ons op de DevDays is verteld dat hij out-of-de-box de hele applicatie ongeveer voor je schrijft) in bepaalde gevallen onbruikbaar blijkt voor de wat grotere business processing applicaties, dan hoor je dat op deze events. En dat niet alleen: Er wordt ook uit de doeken gedaan hoe het dan wèl zou moeten of kunnen werken.

Mensen als Scott Guthrie, Brian Harry, Billy Hollis, developers uit het Visual Studio team, de team lead van het C# compiler team, UI guru Mark Miller (DevExpress) en nog veel meer vak idioten waarvoor dit dagelijkse kost is, staan voor je klaar. Niet alleen tijdens de sessies, maar ook daar buiten zijn ze te porren voor een bakkie of een lunch.

In oktober 2007 waren we ook al in Las Vegas te vinden op de VSLive! waar we ons hebben vastgebeten in UI design, quality assurance en application lifecycle management met Team Foundation Server. De resultaten hiervan maken nu deel uit van onze dagelijkse werkzaamheden. De manier van samenwerken, de hoge kwaliteit en de manier waarop we Team Foundation Server ‘uitnutten’ komt voor een groot gedeelte vanuit de VSLive!.

Waar we ons op de DevConnections 2010 mee hebben laten doorweken zijn in grote lijnen de do’s and dont’s van Silverlight, Windows Phone 7 development, MVC 3.0 en het Entity Framework.
Eerste resultaat: De nieuwe versie van onze RAP applicatie zal gebaseerd zijn op MVC 3.0 in combinatie met het Entity Framework.

Patrick heeft nog een aantal Microsoft Lync sessies bijgewoond, met als resultaat dat er nu op onze bureaus telefoons staan met een USB kabel in plaats van een telefoonstekker. Onze uitdaging is natuurlijk om hier uiteindelijk een koppeling op te maken vanuit onze software…

Gekkenhuis dus; Wanneer gaan we weer?!?

Op persoonlijke titel zou ik nog nog wel eens naar de Microsoft PDC willen. Daar doet Steve Ballmer himself de keynote .
Dat staat bij mij op hoog mijn persoonlijke ‘things to definitely do’ lijstje. Wie weet…

De gelukkige die hier mag komen werken valt daarbij meteen met zijn neus in de boter. Naast natuurlijk zulke fijne collega’s (kuch), mag hij/zij ook direct mee naar de DevConnections 2010 in Las Vegas. Lijkt me een prima reden om direct te solliciteren.

De advertentie kun je hier vinden.

In het voorbeeld dat ik hieronder aanhaal gebruik ik het ‘OnClientClick’ event van een Button. Daar komt ter bevestiging een “Weet u het zeker” melding in te staan, alvorens de server-side event afgaat. Het OnClientClick event is eigenlijk een string property die gevuld mag worden met java-script. Voor een “Weet u het zeker” melding zou daar het volgende in kunnen komen te staan:

return confirm('Weet u het zeker.');

Als in de confirmatietekst een new-line (“\r\n”) staat, dan gaat het niet zomaar lukken. De new-line moet ge-escaped worden naar:

return confirm('Weet u het zeker.\\r\\nAlle data gaat verloren');

De eerste oplossing
In eerste instantie zegt mijn intuïtie dat ASP.NET vast ergens wel een method heeft die dit voor me doet. Zo is er de HttpServerUtility.HtmlEncode, en de HttpServerUtility.UrlEncode. Deze zijn hier echter niet voor geschikt.

In een vorig project werd het opgelost door middel van enkele string-replace aanroepen. Zie onderstaand voorbeeld:

/// <summary>
/// Build a javascript string, to be used in a javascript.|
/// </summary>
/// <param>The raw value to create a javascript string for.</param>
/// <returns>The javascript string.</returns>
private static string BuildJavascriptString(string rawValue)
{
    string escapedValue =
        rawValue
        .Replace("\\", "\\\\")
        .Replace("\'", "\\\'")
        .Replace("\"", "\\\"")
        .Replace("\r", "\\r")
        .Replace("\n", "\\n");
    return string.Format("'{0}'", escapedValue);
}

Het gebruik van deze method ziet er als volgt uit:

MyButton.OnClientClick = string.Format("return confirm({0});",
    BuildJavascriptString(confirmMessage));

De echte oplossing
Het is en blijft echter vreemd dat zoveel string-replace aanroepen nodig zijn. Het zou wellicht op te lossen zijn met een regular expression, maar zelfs dan zit ik nog op het verkeerde spoor. En zijn nu alle varianten afgedekt? Blijft dit werken in de toekomst? Dit moet toch beter kunnen!

Ergens in een donkele hoek van alle Microsoft assemblies in de GAC, staat de Microsoft.JScript assembly. Laat deze nou toevallig een method hebben die lijkt op de java-script escape method. Door de method BuildJavascriptString te vervangen door onderstaande, weet ik zeker dat ik er nooit meer naar om hoef te kijken.

/// <summary>
/// Build a javascript string, to be used in a javascript.
/// </summary>
/// <param>The raw value to create a javascript string for.</param>
/// <returns>The javascript string.</returns>
private static string BuildJavascriptString(string rawValue)
{
    return string.Format("unescape('{0}')",
        Microsoft.JScript.GlobalObject.escape(rawValue));
}

Bovenstaande method is overigens in ons framework geadopteerd, met een uitbreiding voor booleans, integers, doubles en nullables:

/// <summary>
/// Convert a value, regardless of it's type, to be used in a javascript.
/// </summary>
/// <typeparam>The type of the parameter.</typeparam>
/// <param>The value to convert.</param>
/// <returns>A javascript string which represents the specified value.</returns>
public static string ConvertValueToJavaScript<T>(T value)
{
    string valueAsJavaScriptString = string.Empty;

    if (value == null)
        valueAsJavaScriptString = "null";
    else if (typeof(T) == typeof(bool))
        valueAsJavaScriptString =
            value.ToString().ToLowerInvariant();
    else if (typeof(T) == typeof(string))
        valueAsJavaScriptString =
            "unescape('{0}')".FormatInvariant(
            Microsoft.JScript.GlobalObject
                .escape(value as string));
    else
        valueAsJavaScriptString = Convert.ToString(value,
            CultureInfo.InvariantCulture);

    return valueAsJavaScriptString;
}

Java-script syntax verifiëren met C#
In diezelfde donkere uithoek zit ook een java-script compiler, die run-time gebruikt kan worden om java-script te complileren en verifiëren. Hiermee is het mogelijk om een unit-test te schrijven, die alle java-script bestanden opzoekt in het project, en verifieërd. Maar voor deze vonst gaan de credits naar Mads Kristensen, zie zijn blog-post: Verify JavaScript syntax using C#

Visual Studio

Ik moet zeggen dat het er allemaal erg goed uit ziet. Ik had wel liever gezien dat ze tijd hadden gestoken in bijvoorbeeld een multithreaded compiler dan om de hele UI in WPF te gieten maar ach, het gaat vlot genoeg.

Buiten natuurlijk de language support voor C# 4.0 zijn er toch 3 nieuwe zaken die er voor mij echt uitspringen in deze versie van Visual Studio.

Run Impacted Tests
Een hele welkome toevoeging op Visual Studio Team System (ik gebruik op dit moment beta 2 van de Ultimate edition) is de ‘Run Impacted Tests’ feature. Ik heb er even mee geëxperimenteerd en het werkt fantastisch!
Na een build bekijkt visual studio welke unittests (direct of indirect) geraakt worden door de code die gewijzigd is.  Vervolgens kun je ervoor kiezen om alleen de ‘Impacted Unittests’ te draaien. Zo weet je zeker dat je geen gerelateerde unittests over het hoofd ziet, zonder alle unittests te hoeven draaien.

Intellisense
De intellisense is ook wat intelligenter geworden door een contains filter op het gedeelte van je invoer te zetten. Een member hoeft dus niet langer te beginnen met je invoer.

 �
Visual Studio 2008

Visual Studio 2010

Code Analysis
Er zijn bovendien een hoop nieuwe Code Analysis rules bijgekomen die voor ons een zeer welkome toevoeging zijn op de bestaande set rules en onze custom rules. Aan 90% van de nieuwe rules voldeden we al zonder het in de gaten te hebben. 5% van de nieuwe rules is bij ons eigenlijk niet van toepassing. De overige 5% van de nieuwe rules zijn wel in lijn met onze guidelines, dus die zouden feitelijk geen meldingen moeten geven. Maargoed, we zijn allemaal mensen dus er kan wel eens wat doorheen glipppen. Het aantal meldingen die hierdoor ontstaan is dusdanig beperkt dat we toch wel trots op onszelf kunnen zijn. Deze gaan we dus aanpakken en oplossen.

 Ook het nieuwe ‘Ruleset’ concept dat met Visual Studio 2010 geïntroduceerd wordt is zeer welkom. Dit helpt om zelf vaste sets te maken waar de code in projecten aan moet voldoen, zonder dit steeds op ieder nieuw project handmatig een voor een in te moeten stellen. Ook is een ‘minimium requirement’ ruleset op te geven bij de Check-In policy van Team Foundation server, wat ook enkele onhebbelijkheden uit het verleden opheft.

Team Foundation Server

Team Foundation server is eenvoudiger te beheren en biedt tools om aan Team Project inrichting te sleutelen zonder Visual Studio daarbij nodig te hebben.
TFS Web Access zit nu geintegreerd in de Team Foundation installatie, maar als ik zie wat er allemaal voor ‘neat features’ beschikbaar zijn gekomen direct op de Project Portal (zoals het beheren van de User Stories en Tasks) denk ik niet dat TFS Web Access nog nodig is. Team Foundation Server is nu toch wel volwassen te noemen.

Bij Driessen valt met de komst van Team Foundation Server 2010 het doek voor de Scrum project template van Conchango die we tot nu toe gebruikten voor project planning. De MSF for Agile project template dekt de lading om volgens het Scrum principe te werken ruimschoots.
Ik verwacht dat ook onze product owners hier op korte termijn goed mee uit de voeten kunnen.

Sprint Planning met Excel in Team Foundation Server 2010. Even wennen maar het werkt toch wel erg lekker!
Een goed overzicht met de workload op iedere developer. Marco blijkt wat teveel hooi op zijn vork te hebben genomen, dus moet er  wat werk van Marco naar de andere developers gezet worden.

 Al met al dus genoeg om naar uit te kijken. Ook de proefconversies van onze projecten die ik tot nu toe heb gedaan zien er goed uit. We wachten in spanning af tot Q1 2010.