Er is inmiddels een vrijwel onuitputtelijke lijst met programmeermodellen: MVP, MVC, MVVM, MVPP enzovoorts. Allemaal met hun eigen voors- en tegens.
RAP wordt op dit moment gebouwd op basis van MVC (Model View Controller), de overige (wat meer data-entry) applicaties worden gebouwd op MVP (Model View Presenter). Maar dan ECHT multi UI platform, met behulp van ons Driessen framework. (meer…)

Om ons eens flink onder te dompelen in Visual Studio 2010 en .NET 4.0 hebben we in november 2010 de DevConnections in Las Vegas bezocht..

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. (meer…)

Er staat een advertentie in de .NET Magazine waarin we nieuwe collega’s zoeken. We zijn op zoek naar nieuwe C# .NET developers.

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.

De uitdaging
Voor het bouwen van een maatwerk web-portal voor een van onze klanten, kwam ik tot de ogenschijnlijke kleine uitdaging om een stuk java-script aan te maken in C# code. Piece of cake… Totdat er een new-line in de java-script kwam te staan, die de browser niet (zomaar) slikte.

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#

Om straks vlekkeloos over te kunnen stappen van Visual Studio 2008 en Team Foundation Server 2008 naar de 2010 versies van deze producten ben ik de afgelopen 2 weken bezig geweest met het inventariseren en testen met de Beta 2 release van beide producten.

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.