.Met de punt naar voren

Create EML file from System.Net.Mail.MailMessage

Sat, 23 Nov 2013 15:03:00 GMT

For a project I was working on, I needed to create an EML file from the standard MailMessage class which exists in the System.Net.Mail namespace. I came across an article which describes how to extend the save functionality on the MailMessage class. Using the same technique I created an extension method which is able to save the MailMessage class as EML.

With this extension method in your solution you can create an EML file like this:

var mailMessage = new MailMessage();
string eml = mailMessage.ToEml();

The extension method is implemented like this:

using System.IO;
using System.Net.Mail;
using System.Reflection;
using System.Text;

namespace Infrastructure.MailMessageExtensions
{
    public static class MailMessageExtensions
    {
        public static string ToEml(this MailMessage message)
        {
            var assembly = typeof(SmtpClient).Assembly;
            var mailWriterType = assembly.GetType("System.Net.Mail.MailWriter");

            using (var memoryStream = new MemoryStream())
            {
                // Get reflection info for MailWriter contructor
                var mailWriterContructor = mailWriterType.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, new[] { typeof(Stream) }, null);

                // Construct MailWriter object with our FileStream
                var mailWriter = mailWriterContructor.Invoke(new object[] { memoryStream });

                // Get reflection info for Send() method on MailMessage
                var sendMethod = typeof(MailMessage).GetMethod("Send", BindingFlags.Instance | BindingFlags.NonPublic);

                // Call method passing in MailWriter
                sendMethod.Invoke(message, BindingFlags.Instance | BindingFlags.NonPublic, null, new[] { mailWriter, true, true }, null);

                // Finally get reflection info for Close() method on our MailWriter
                var closeMethod = mailWriter.GetType().GetMethod("Close", BindingFlags.Instance | BindingFlags.NonPublic);

                // Call close method
                closeMethod.Invoke(mailWriter, BindingFlags.Instance | BindingFlags.NonPublic, null, new object[] { }, null);

                return Encoding.ASCII.GetString(memoryStream.ToArray());
            }
        }
    }
}

Conclusion

EML files are perfect for storing the email message on your file system or in the database. The EML file contains all the data from the email, including attachments. You can open the EML in most mail clients and view the email.

Bookreview Instant jqGrid by Gabriel Manricks

Sun, 29 Sep 2013 19:40:00 GMT

JqGrid is an ajax enabled jQuery plugin for showing and editing data in a grid. I've been using jqGrid extensively throughout my projects, and created an Html Helper to ease the implementation in ASP.NET MVC. Because of my experience with jqGrid, Packt publishing asked me to review one of their latest books, Instant jqGrid by Gabriel Manricks.

The book is mainly focused on people starting with jqGrid, experienced users will probably know most of the stuff that is written in the book and is of no added value to them.

The book can be divided in two parts. The first part teaches the jqGrid basic concepts, installation and walks you through the steps of creating your first grid. The second and biggest part is called 'Top 7 features you need to know about' and takes a deep dive in the most important features of jqGrid.

Covered in the second part are formatters, adding controls, editing data, connecting to a backend server and a description of some common methods and events of the jqGrid API. I especially liked the the example of connecting jqGrid to the backend. The backend code is written in PHP, but should easily be understood by developers of other platforms. The example shows how to retrieve data from the server, and page, search and edit data on the server, which are the core features of jqGrid. The author describes every step thoroughly and in a clear and simple form.

What I missed in the book is how to deal with custom styling. It is mentioned you can use jQuery UI themeroler, but doesn't give any information or example how to further customize the styling of the grid. Also I thought it was too bad the author did not mention the option of virtual scrolling when describing the pager, which I like very much and is easy to implement.

The book is very easy to read and to follow. After going through the book, and the examples, a developer should have a sound knowledge of jqGrid, and be able to customize the grid to their needs. I remember the pain going through the online documentation and examples when I first started with jqGrid, this book is a real time-saver for people who want to start working with jqGrid. Not every feature or option is covered in the book, it only counts 58 pages, but I think gives you enough baggage to get started and explore more features, like subgrids, treegrids and data grouping, on your own using the online documentation and examples.

Presenting iDeal.NET

Wed, 24 Oct 2012 18:06:00 GMT

iDeal is the leading online payment platform in the Netherlands. Last year when working on bidfortickets.nl I had to create an API to interact with our iDeal provider (Rabobank) to handle all online payments. I noticed that a lot of examples existed out there especially for PHP, but nothing really usable for the .NET ecosystem. So I decided to open source the API on GitHub and call it iDeal.NET. The API takes care of all communications with the iDeal provider and is easily integrated into a .NET (web)application.

Supported iDeal versions

iDeal.NET is aimed at iDeal Professional (Rabobank), iDeal Zelfbouw (ABN Amro), iDeal Integrated and iDeal Advanced (ING Bank). These versions allow for real-time feedback on transactions.

iDeal.NET does not yet support iDeal Basic (ING Bank), iDeal Hosted , iDeal Lite (Rabobank) and iDeal Zakelijk which are easily implemented in applications but do not allow for real-time feedback on transactions.

Source, samples and documentation

The source code is hosted on GitHub, this is where you also find the documentation. The solution includes a sample ASP.NET MVC application which shows the basis usage of iDeal.NET. The sample application uses www.ideal-simulator.nl to simulate the entire process of paying and retrieving status of payments. A live version of the example can be found here.

Usage

Implementation of iDeal is basically about three types of requests: directory requests, transaction requests and status requests. iDeal.NET provides an easy to use API to send the requests and handle the responses.

A directory request for example, which retrieves a list of bank (issuers), is as easy as:

var iDealService = new iDealService();
var directoryResponse = iDealService.SendDirectoryRequest();
var issuers = directoryResponse.Issuers;

You can find detailed information about the usage of the API on GitHub

Enjoy!

Using P4Merge with TortoiseGit

Wed, 24 Oct 2012 18:04:00 GMT

The team I’m currently working with uses Perforce as their versioning system. Personally I prefer Git over Perforce, but Perforce has a great merging/diff tool called P4Merge. Fortunately you can install P4Merge separately without the rest of the system. I mainly use the Bash and TortoiseGit when working with GIT , this article demonstrates how to integrate P4Merge with TortoiseGit.

Install P4Merge

P4Merge is included in the P4 Installer, when executing the installer you’re are able to install P4Merge only, you have to download the entire installer however. Follow these steps to install P4Merge:

Go to http://www.perforce.com/downloads/complete_list
Click ‘Browse by Platform’ tab
Chose a platform
Chose a operating system
Download P4Merge
Run the installer and only select P4Merge to install

Setup Diff Viewer with TortoiseGit

Follow these steps to setup P4Merge as the default diff viewer for TortoiseGit:

Open TortoiseGit->Settings from the Windows start menu
Choose ‘Diff Viewer’ from the settings tree
Choose to use an external tool instead of TortoiseMerge
Specify the following path and parameters: C:\Program Files\Perforce\P4Merge.exe %base %mine

Setup Merge Tool with TortoiseGit

Follow these steps to set P4Merge as the default merge tool for TortoiseGit:

Open TortoiseGit->Settings from the Windows start menu
Choose ‘Merge Tool’ under ‘Diff Viewer’ from the settings tree
Choose to use an external tool instead of TortoiseMerge
Specify the following path and parameters: C:\Program Files\Perforce\P4Merge.exe %base %theirs %mine %merged

Setup Bash

Integrating P4Merge with GIT from the Bash is explained in this answer on StackOverflow.

Starting IIS Express from the command line

Wed, 24 Oct 2012 18:02:02 GMT

I've been working with IIS express for some time now, but only as an integrated webserver in Visual Studio. Today I stumbled upon a feature of IIS Express I didn't know existed. You can start IIS express from the commandline and host a webapplication on the fly. No Visual Studio needed.

To start IIS Express from the command line, first navigate to the IIS Express installation folder:

c:\Program Files\IIS Express

or for 64-bit:

c:\Program Files (x86)\IIS Express

With the following command you can host an application in the specified path on port 9090:

iisexpress /path:c:\myapp\ /port:9090

Very handy when you quickly want to test an application downloaded from the internet. In my case a beta of Umbraco CMS 5.0, I got it up and running in seconds.

For a more complete overview of all command line options of IIS Express read this article.

When you don't want to fire up the command prompt each time you want to launch IIS Express, Chris McLeod created a shell extension using some registry edits to add "IIS Express Website Here" to your context menu. It starts IIS Express in the selected directory, making things even more easy.

Update jqGrid Html helper for ASP.NET MVC

Wed, 24 Oct 2012 18:00:00 GMT

We released a new version of MvcJqGrid, a fluent html helper which eases the the implementation of jqGrid in ASP.NET MVC applications. I'll give a short description of the most notable changes in this article. Source code and documentation are hosted on github. We included a sample application in the source code, a live example can be found here.

Razor engine support

Although it was possible to use the previous version with the razor engine, it wasn't quite obvious how. The following gives you a basic example how to use the new version of MvcJqGrid with the razor view engine:

@(Html.Grid("basic")
    .SetCaption("Basic Grid")
    .AddColumn(new Column("CustomerId")
        .SetLabel("Id"))
    .AddColumn(new Column("Name"))
    .AddColumn(new Column("Company"))
    .AddColumn(new Column("EmailAddress"))
    .AddColumn(new Column("Last Modified"))
    .AddColumn(new Column("Telephone"))
    .SetUrl("/Home/GridData/")
    .SetAutoWidth(true)
    .SetRowNum(10)
    .SetRowList(new int[]{10,15,20,50})
    .SetViewRecords(true)
    .SetPager("pager"))

NuGet

MvcJqGrid is now available as a NuGet package which makes installing the helper a trivial task:

install-package MvcJqGrid

You have to install jqGrid and jQuery yourself, we decided not to include these as dependencies.

Modelbinder

We included the jqGrid modelbinder created by Ilya Builuk. The modelbinder makes it easy to handle data requests from the grid in your controllers:

public JsonResult GridData(GridSettings gridSettings)
{
    ...
}

Sample Application

The sample application was also updated. The sample is included in the source code, you can find a live example here. The sample application is a nice way to get started with the helper, because for every sample grid the source code is displayed below the grid.

One word about the sample data being used. The sample data is contained in a Sql Express Database in the App_Data folder. Make sure you have installed Sql Server Express 2008 R2. The Web Platform Installer sometimes indicates you have installed R2 when actually you only have SP2 installed. More info on StackOverflow.

Unit tests

Daan le Duc went out of his way and added 129 unit tests to the project, which improved the overall quality of the Html Helper.

Hopefully, you'll like this new release. Suggestions, questions and comments are always welcome.

Setting up FluentValidation for ASP.NET MVC using Ninject

Wed, 24 Oct 2012 17:59:00 GMT

FluentValidation is a powerful library to validate your model objects fluently. Setting up FluentValidation is easy, import the NugGet package to your project and you're ready to go. It's possible to setup FluentValidation using an IoC container, which is very useful when your validators contain some dependencies which you would like to remove using dependency injection. In this article I'll show you how to use Ninject to setup FluentValidation.

There's a NuGet package for that!

I'm assuming you already have FluentValidation and Ninject set up for your project. There's just one little package you need, ninject.web.mvc.fluentvalidation, which you also can grab from NuGet. This package contains a custom validatorfactory which puts Ninject in charge of creating instances of your validators.

First you have to create the ninject factory and configure FluentValidation to use this factory instead of the default one. Add the following lines of code to the Application_Start method in Global.asax or if you're using webactivator in the start method of the fluentvalidation startup class in App_Start:

NinjectValidatorFactory ninjectValidatorFactory = new NinjectValidatorFactory(Kernel); 
FluentValidationModelValidatorProvider
  .Configure(x => x.ValidatorFactory = ninjectValidatorFactory);
DataAnnotationsModelValidatorProvider
  .AddImplicitRequiredAttributeForValueTypes = false;

FluentValidation is now using the ninject factory for creating instances of validators. The last step is to bind all validators to their implementation. You can do this with one line of code:

AssemblyScanner.FindValidatorsInAssembly( Assembly.GetExecutingAssembly())
    .ForEach(match => kernel.Bind(match.InterfaceType).To(match.ValidatorType));

This method scans the specified assembly (in this case the current assembly) for validators and binds their interfaces to their implementations. You have to add this method to your Ninject startup script.

By now, all validators can take dependencies which are resolved by Ninject.

Happy programming!

AutoPoco, create meaningful test data based on your domain objects. (.NET)

Tue, 23 Oct 2012 22:45:00 GMT

Creating test data for your applications is usually a cumbersome and not too inspiring exercise, to say the least. Lately I discovered a nice tool called AutoPoco which is created by Rob Ashton. AutoPoco enables you to generate meaningful test data based on your domain objects (poco's). AutoPoco is able to generate data for individual unit tests, or you can use AutoPoco to generate large amounts of test data to populate your database.

In this article I'll give a short introduction to AutoPoco and explain how to customize AutoPoco to enable the generation of test data which is meaningful to your project and not just some randomly generated values.

I also created a sample app hosted on github, which contains some basic usage stuff and some custom datasources I wrote. A live version of the sample app is located here

Notice:Source code in this article is based on the latest version of AutoPoco residing in the trunk. The trunk contains some breaking changes with the official v1.0 release and because of that the source code used in this article will not work with the v1 release. The trunk is located here. You can also use the autopoco.dll which is included in the sample app, if you don't feel like compiling the dll yourself. I will update this article and the sample app when Rob decides to release the next version of AutoPoco.

How does it work?

Basically AutoPoco examines your domain objects using reflection and assigns datasources to each property/field of your domain object. The assignment can be done automagically (convention over configuration), or you can assign datasources yourself. When generating test data each datasource creates meaningful test data to populate the assigned property. Here's a quick example:

First, create a domain object for which test data will be generated:

public class User
{
    public int Id { get; set; }
    public string Firstname { get; set; }
    public string Lastname { get; set; }
    public string Email { get; set; }
    public DateTime DateOfBirth { get; set; }
}

Setup an AutoPoco factory and assign datasources to the properties of the domain object:

// Create factory for poco's and setup datasources
var pocoFactory = AutoPocoContainer.Configure(x =>
{
    x.Conventions(c => c.UseDefaultConventions());
    x.AddFromAssemblyContainingType<User>();
    x.Include<User>()
    .Setup(u => u.Email).Use<EmailAddressSource>()
    .Setup(u => u.Firstname).Use<FirstNameSource>()
    .Setup(u => u.Lastname).Use<LastNameSource>()
    .Setup(u => u.DateOfBirth).Use<DateOfBirthSource>();
});

Create an AutoPoco session:

var pocoSession = pocoFactory.CreateSession();

Tell AutoPoco to generate 10 users:

var users = pocoSession.List<User>(10).Get();

And here's the result:

AutoPoco is also able to set fixed values for certain properties and allows for invocation of methods on the domain objects. More information on installing and configuring AutoPoco can be found at http://autopoco.codeplex.com/documentation

Roll your own datasources

AutoPoco has some built-in datasources, like Email, Firstname, Lastname etc. In a real world scenario the built-in datasources won't get you far. Luckily it's easy to create your own datasources for AutoPoco.
The easiest way to create a custom datasource is to create a class that inherits from the DatasourceBase class:

public class ExampleSource : DatasourceBase<string>
{
    public override string Next(IGenerationContext context)
    {
        throw new NotImplementedException();
    }
}

As you can see, there's only one method you have to implement, the Next method. The DatasourceBase class uses generics to determine the returntype, in this case a string, but this can just as easy be any other object. As an example I will create a datasource which provides company names:

public class CompanySource : DatasourceBase<String>
{
    private readonly Random _random = new Random(1337);
 
    public override string Next(IGenerationContext context)
    {
        return Companies[_random.Next(0, Companies.Length)];
    }
 
    private static readonly string[] Companies = new[]{
        "Acme, inc.",
        "Widget Corp",
        "123 Warehousing",
        "Demo Company",
        "Smith and Co.",
        "Foo Bars",
        "ABC Telecom",
        "Fake Brothers",
        "QWERTY Logistics",
        "Demo, inc.",
        "Sample Company",
        "Sample, inc",
        "Acme Corp",
        "Allied Biscuit",
        "Ankh-Sto Associates",
        "Extensive Enterprise",
        "Galaxy Corp",
        "Globo-Chem",
        "Mr. Sparkle",
        "Moes Tavern",
        "Central Perk",
        "Chasers"
    };
}

Once created this datasource can be used in the same way as the built-in datasources. Extending our previous example, the configuration of AutoPoco would look like this using the company datasource:

var pocoFactory = AutoPocoContainer.Configure(x =>
{
    x.Conventions(c => c.UseDefaultConventions());
    x.AddFromAssemblyContainingType&ltUser>();
    x.Include<User>()
    .Setup(u => u.Email).Use<EmailAddressSource>()
    .Setup(u => u.Firstname).Use<FirstNameSource>()
    .Setup(u => u.Lastname).Use<LastNameSource>()
    .Setup(u => u.DateOfBirth).Use<DateOfBirthSource>()
    .Setup(u => u.Company).Use<CompanySource>();
});

Which results in:

Concluding

It's very easy to generate test data with AutoPoco, and what I like most, you can give meaning to your test data by creating your own datasources.

I created a little project on github to host some of the custom datasources I wrote. The project includes an asp.net mvc example using some of the built-in and all of the custom datasources I use to generate data. The output of the example project can be found here. Feel free to use the datasources anyway you like. Included datasources are:

EnumSource
BooleanSource
CitySource
CompanySource
DateTimeSource
DecimalSource
DoubleSource
DutchCitySource
DutchMiddlenameSource
DutchMobileSource
DutchPostalSource
DutchTelephoneSource
ExtendedEmailAddressSource
FloatSource
IntegerSource
PostalSource
StreetSource
TimeSpanSource
UrlSource

Fluent jqGrid Html Helper for ASP.NET MVC

Tue, 23 Oct 2012 22:40:00 GMT

Update: A newer version of the jqGrid helper was released, read more about it here

JqGrid is a widely adopted grid plugin for jQuery, notorious for its flexibility and tons of available features, and last but not least it's free! Creating the appropriate JavaScript to create a jqGrid and effectively use the available options can be a little verbose, and usually requires a lot of visits to the documentation wiki. I decided to create a html helper for ASP.NET MVC, which eases the implementation of jqGrid inside the view.

The helper contains a fluent interface providing for a clean and readable view. Most of the properties, events and methods from the base classes of jqGrid are implemented in the helper, including paging, sorting and toolbar searching. At this point, editing, treegrids and subgrids are not yet supported.

Sample Application

To showcase the helper I created a sample application which demonstrates various grids with different configurations. The source code from the view is displayed below every grid, which should make it easy for you to get started. You can find the sample application here.

The source code of the entire sample application including the helper is available at github. For non-git users, locate the 'Download Source' button on the github page to grab the code.

Requirements

jQuery 1.3 or later, included by default when you create a MVC project in Visual Studio or you can grab the latest release at http://jquery.com
jqGrid 3.6.5 or later, you can create your own custom jqGrid package using the Download Builder. Make sure you select all three base modules (Grid base, Formatter and Custom), these are used by the helper, other modules are not supported by the helper.
jQuery theme, create your own or pick one from the gallery at http://jqueryui.com/themeroller
The helper, available at github (You only need the file Grid.cs, located in the HtmlHelpers folder.)

Getting Started

After installing jqGrid and adding the helper to your application, you can start using the helper in your views. Make sure to include an import statement to the top of the viewpage that will use the helper:

<%@ Import Namespace=" MvcJqGrid.HtmlHelpers" %>

or if you're planning on using the grid on multiple pages in your project, it's possible to add the reference to your web.config in the system.web/pages/namespaces node, which enables the helper in all your views:

<add namespace="MvcJqGrid.HtmlHelpers"/%>

Creating a basic grid could look something like this:

<%= Html.Grid("basic")
    .setCaption("Basic Grid")
    .addColumn(new Column("CustomerId")
        .setLabel("Id"))
    .addColumn(new Column("Name"))
    .addColumn(new Column("Company"))
    .addColumn(new Column("EmailAddress"))
    .addColumn(new Column("Last Modified"))
    .addColumn(new Column("Telephone"))
    .setUrl("/Home/GridDataBasic/")
    .setAutoWidth(true)
    .setRowNum(10)
    .setRowList(new int[]{10,15,20,50})
    .setViewRecords(true)
    .setPager("pager")
    %>

Which results in:

As you can see, the grid is available in the Html class as a regular Html helper. The grid's constructor takes one parameter, which is used to set the id of the grid. All additional properties, methods and events are available through method chaining. The order in which you call the methods doesn't influence the behavior of the grid.

After the grid is rendered in the client, the grid issues an AJAX callback to request the data. The setUrl method points to an action on your controller, which should either return a json or an xml response containing the requested data (responsetype is set using the setDataType property, default is json). The exact format of the response can be found here.

The helper's only responsibility is to create the appropriate clientside Html and JavaScript to generate the grid. It's the responsibility of the controller to generate the correct response to the request for data send by the grid.

The sample application uses a custom modelbinder (created by Ilya Builuk) to catch all the request parameters jqGrid sends to the controller. This modelbinder parses all arguments send by jqGrid into a strongly typed object called GridSettings. The definition of the action inside your controller when using this modelbinder would look something like this.

public JsonResult GetData(GridSettings gridSettings)

I won't go into the details of setting up the controller and the model to create the correct response. Lots of information about that subject can be found on the internet. Also, you can examine the sample application. The sample uses a basic model, including sorting, filtering and paging, and shows how to format the data from the model to a json response. It's easy, I promise.

Hope you like it!

Noted: Daan le Duc created a php version of the jqGrid viewhelper, which inspired me to write this ASP.NET MVC variant. Thanx Daan for all the input and hard work!

Fluent Interfaces in Views en Templates

Tue, 23 Oct 2012 22:36:00 GMT

De afgelopen tijd zijn wij binnen Webpirates fan geworden van het gebruik van fluent interfaces om onze code beter leesbaar te maken. In dit artikel wil ik laten zien hoe wij fluent interfaces inzetten om views en templates een stuk leesbaarder, schoner en eenvoudiger in gebruik te maken.

Wat is een fluent interface?

Kort gezegd maakt een fluent interface het mogelijk om de publieke API van een object op een efficiente en heldere wijze aan te spreken. De aanroepende code wordt hierdoor doorgaans sterk verkort, beter leesbaar en eenvoudiger in gebruik.

Het volgende voorbeeld laat zien hoe een class met een fluent interface in C# aangeroepen wordt:

var customer = new Customer()
    .setFirstname("Ad")
    .setLastname("van de Kaart")
    .addOrder(new Order()
        .setProductId(3)
        .setQuantity(10))
    .addOrder(new Order()
        .setProductId(7)
        .setQuantity(5))
    .save();

De customer class bevat naast een aantal properties ook een functie om orders toe te voegen. De order class heeft ook een fluent interface geïmplementeerd waardoor het order object ook eenvoudig te configureren is.

Dezelfde aanroep, maar dan zonder fluent interface zou er als volgt uit zien:

var customer = new Customer();
customer.Firstname = "Ad";
customer.Lastname = "van der Kaart";
var order1 = new Order();
order1.ProductId = 3;
order1.Quantity = 10;
customer.Orders.Add(order1);
var order2 = new Order();
order2.ProductId = 7;
order2.Quantity = 5;
customer.Orders.Add(order2);
customer.save();

Hoewel een fluent interface qua functionaliteit niets toevoegt ziet de code er een stuk overzichtelijker uit. Op <a target="_blank" href="http://en.wikipedia.org/wiki/Fluent_interface">wikipediavind je heldere voorbeelden hoe je in verschillende talen een fluent interface kan maken. Ik zal hier dan ook niet verder op ingaan.

Fluent interfaces in views

Binnen Webpirates gebruiken we fluent interfaces met name in views en templates. Views bevatten voornamelijk html en verschillende helperobjecten om eenvoudig html te genereren op basis van data die aan de view toegewezen is. De helpers lenen zich dan ook uitstekend voor fluent interfaces. In php templates gebruiken wij bijvoorbeeld een helper voor het opbouwen van een dropdown list:

echo SysViewHelperDropdown::create('balls')
  ->setDropdownItems( 
    array(    
      '1' => 'Voetbal', 
      '2' => 'Basketbal', 
      '3' => 'Tennisbal'))
  ->setSelected(2)
  ->setClass('timebox');

Voor ASP.NET MVC hebben we een HtmlHelper ontwikkeld waarmee eenvoudig en snel een grid (jqGrid) gegenereerd kan worden. De interface ziet er dan bijvoorbeeld zo uit:

<%= Html.Grid("basic")
            .addColumn(new Column("CustomerId")
              .setLabel("Customer ID"))
            .addColumn(new Column("FirstName")
              .setWidth(500))
            .setUrl("/Home/GridData/")
            .setPager("pager")
            .setAutoWidth(true)
            .setViewRecords(true)
            %>

Fluent interfaces maken object interfaces beter leesbaar en makkelijk hanteerbaar. De meerwaarde van fluent interfaces komt vooral tot z'n recht als binnen het object nieuwe objecten aangemaakt kunnen worden, zoals nieuwe kolommen in het grid voorbeeld. De code wordt dan aanzienlijker korter en overzichtelijker.

Sitefinity CMS

Tue, 23 Oct 2012 22:31:00 GMT

Om opdrachtgevers in staat te stellen hun eigen website te beheren, zet Webpirates op dit moment Joomla of intern ontwikkelde content management systemen in. Deze systemen zijn momenteel allemaal ontwikkeld in PHP. Om onze dienstverlening uit te breiden ben ik de afgelopen periode op zoek gegaan naar een CMS dat gebaseerd is op ASP.NET.

Het CMS moet aan een aantal vereisten voldoen. In de eerste plaats moet het CMS gebruiksvriendelijk zijn en een breed scala aan functionaliteiten bevatten. Tevens moet het CMS makkelijk uit te breiden en aan te passen zijn door een ontwikkelaar, zodat we dienstverlening op maat kunnen bieden en toch kostenefficiënt blijven.

Na een aantal systemen uitgeprobeerd te hebben, ben ik uitgekomen op Sitefinity van Telerik. Dit CMS is voor gebruikers uitermate gemakkelijk te bedienen, de standaard installatie bevat legio functionaliteiten en is voor ontwikkelaars makkelijk uit te breiden zonder hiervoor nieuwe technieken te leren.

Het CMS bevat alle gebruikelijke CMS onderdelen, zoals blogs, news, artikelen, polls en forums maar ook de mogelijkheid om wiki pagina's aan te maken, nieuwsbrieven te versturen en gebruikersgroepen te beheren. De meeste functionaliteiten zijn eenvoudig te gebruiken en in te stellen door de gebruiker. Een korte training of uitleg is voldoende om snel aan de slag te kunnen met Sitefinity. Op de website van Sitefinity is een uitgebreid overzicht van alle features van het systeem te vinden.

Een aantal punten waarmee Sitefinity zich onderscheid van andere content management systemen wil ik in dit artikel uitlichten. Ten eerste bevat Sitefinity ondersteuning voor meerdere talen. Gebruikers kunnen zelf teksten in verschillende talen opslaan, zonder dat voor elke taal een nieuwe pagina aangemaakt hoeft te worden.

Sitefinity heeft een uitgebreid versiebeheersysteem ingebouwd. Hiermee kunnen meerdere versies van content opgeslagen en bekeken worden. Grootste voordeel hiervan is dat gemaakte aanpassingen met één klik weer teruggedraaid kunnen worden en inzichtelijk is wie welke aanpassingen heeft doorgevoerd.

Naast versiebeheer bevat Sitefinity een systeem waarmee alle nieuwe en aangepaste content eerst goedgekeurd moet worden door de daartoe bevoegde personen om gepubliceerd te worden. Vooral in ondernemingen waar meerdere mensen bijdragen leveren aan de inhoud van de website is dit een veel gevraagde optie.

Telerik stelt dat Sitefinity eenvoudig uit te breiden is door ontwikkelaars. Om dit te testen heb ik een kleine Twitter module geschreven waarmee de laatste tweets van een in te stellen gebruiker op de site worden weergegeven. En inderdaad, binnen enkele minuten had ik al een eerste werkende versie. Sitefinity gebruikt technieken die voor elke ASP.NET ontwikkelaar bekend zijn zoals masterpages en user controls. Nieuwe technieken hoeven dus niet te worden aangeleerd om nieuwe functionaliteiten toe te voegen aan Sitefinity.

Sitefinity was tot voor kort beschikbaar als community edition die gratis te downloaden was. Helaas is dit project stop gezet en is alleen de professionele editie nog beschikbaar. De kosten van het CMS bedragen $900,- per domein, dit is relatief goedkoop in vergelijking tot andere commerciële pakketten.

Grootste minpunt tot nu toe is de installatieprocedure. Het heeft mij zeker een halve dag gekost om Sitefinity aan de praat te krijgen. Belangrijkste les was om vooral niet de meegeleverde installer te gebruiken, maar de installatie handmatig uit te voeren.

Al met al ben ik erg enthousiast over de mogelijheden die Sitefinity biedt, het gebruiksgemak en de eenvoudige wijze waarop ontwikkelaars functionaliteit toe kunnen voegen. Wilt u meer weten over Sitefinity of de diensten die wij op dit product bieden? Of wilt u een demonstratie van de mogelijkheden? Neem dan gerust contact met ons op, wij helpen u graag verder!

Software design principles

Tue, 23 Oct 2012 22:22:00 GMT

“It is one thing to write code that works. It is quite another to write good code that works” Dino Esposito (2009)

Eén van mijn persoonlijke doelen met betrekking tot Webpirates is om de bestaande technische kennis en vaardigheden binnen Webpirates vast te leggen, te delen en te vergroten. In dit kader zal ik regelmatig een artikel schrijven die één of meerdere aspecten belicht van het software-ontwikkelproces. Dit artikel geeft een overzicht van software design principes die in de loop der jaren industriestandaarden zijn geworden en door elke programmeur gekend en toegepast zouden moeten worden.

Het draait allemaal om aanpasbaarheid

Goed geschreven software voldoet niet alleen aan de eisen die vandaag gesteld zijn, maar houdt ook rekening met de gevraagde aanpassingen en toevoegingen van morgen. Het is dus van belang dat de ontwikkelaar zijn of haar code zo ontwerpt dat deze in een later stadium relatief eenvoudig aan te passen is.
Tijdens het ontwerp van de applicatie zijn de aanpasbaarheid en onderhoudbaarheid van de applicatie dan ook de belangrijkste kwaliteitskenmerken voor een ontwikkelaar. Al het andere kan later ingepast worden, als de applicatie maar eenvoudig aan te passen is. Vaak wordt gesteld dat wisselende requirements de oorzaak zijn van slecht geschreven software, dat door alle veranderingen de code onbeheersbaar wordt. Dit is pertinent onjuist. Het is aan de ontwikkelaar om ervoor te zorgen dat zijn software bestand is tegen aanpassingen en uitbreidingen. Wisselende requirements ontmaskeren dus eigenlijk alleen slecht geschreven software en hun auteur.

Symptomen van slecht design

Slecht geschreven software is slecht bestand tegen veranderingen. Robert C. Martin (2000) formuleert slecht design als volgt: Software die voldoet aan de opgegeven requirements maar aan één of meer van de volgende symptomen lijdt is slecht ontworpen:

Rigiditeit: Elke verandering zorgt voor teveel aanpassingen in andere delen van het systeem.
Fragiliteit: Wanneer een aanpassing doorgevoerd wordt, gaan andere delen van het systeem onverwacht kapot.
Immobiliteit: Lastig om code te hergebruiken in een andere applicatie omdat teveel afhankelijkheden met de huidige applicatie bestaan.
Viscositeit: Makkelijker om omwegen in de software te bouwen dan daadwerkelijk problemen in de software op te lossen.

High Cohesion, Low Coupling

De beste strategie om software makkelijk aanpasbaar te maken is door het systeem op te delen in losse componenten, high cohesion en loose coupling zijn hierbij de uitgangspunten.
Cohesion geeft de mate aan waarin de verschillende functionaliteiten van een component met elkaar gerelateerd zijn. Hoe meer cohesie hoe beter. In de praktijk betekent dit het gebruik van sterk gespecialiseerde classes met meestal weinig methodes. Met de groei van het aantal functionaliteiten van een class groeit ook het aantal afhankelijkheden van andere classes, dit staat aanpassingen in de software in de weg. Coupling geeft de mate van afhankelijkheid tussen de verschillende componenten aan. Hoe minder afhankelijkheden hoe beter. Dit maakt de code makkelijker te onderhouden, leesbaarder, eenvoudiger om te testen en verkleint tevens de mate van fragiliteit en rigiditeit van het systeem.

Separation of Concerns

Separation of Concerns (SoC) ( geïntroduceerd door Edsger W. Dijkstra, 1974) is een principe dat helpt loose coupling en high cohesion te bereiken. Het toepassen van SoC betekent het opdelen van een systeem in delen die elkaar zo min mogelijk overlappen, elk deel heeft zijn eigen verantwoordelijkheid.
SoC wordt concreet bereikt door code modulair op te stellen, de interne werking van de modules af te schermen (encapsulation), en alleen te communiceren via publieke interfaces. Op deze manier kunnen veranderingen in de interne werking van modules plaats vinden, zonder dat andere modules hiervoor aangepast dienen te worden aangezien de interface gelijk blijft.
In de praktijk zie je toepassingen van SoC overal, in procedurele talen worden procedures en functies gebruikt voor het scheiden van de verschillende aspecten van een systeem, in object georiënteerde talen worden classes gebruikt. Architecturen zoals MVC bereiken SoC door het opdelen van systemen in meerdere logische lagen elk met hun eigen vooraf gedefinieerde verantwoordelijkheden.

Object Oriented Programming (OOP)

Object georiënteerde programmeertalen voorzien de ontwikkelaar van de benodigde gereedschappen en technieken om een systeem op te delen in een groot aantal losse onderdelen (objecten). Door de jaren heen zijn een aantal industrie standaarden ontstaan op het gebied van OOP die algemeen toepasbaar zijn op elke object georiënteerde programmeertaal.
Ik bespreek eerst de basis principes van OOP en vervolgens een aantal meer geavanceerde principes die vallen onder de noemer S.O.L.I.D. principles gebundeld door Robert C. Martin.

Basis OOP principes

Hét standaardwerk op het gebied van OOP is het boek van the Gang of Four (GoF) ‘Design Patterns: Elements of Reusable Object-Oriented Software’. GoF vat object georiënteerd design als volgt samen:

'You must find pertinent objects, factor them into classes at the right granularity, define class interfaces and inheritance hierarchies, and establish key relationships among them. Your design should be specific to the problem at hand, but also general enough to address future problems and requirements.'

Het identificeren van pertinente objecten gebeurt meestal door de requirements en/of use-cases af te speuren naar zelfstandige naamwoorden en werkwoorden. Zelfstandige naamwoorden representeren vaak objecten of eigenschappen van objecten, werkwoorden zijn vaak methoden van objecten. Voorbeeld:

“De gebruiker moet een nieuwe recipient toe kunnen voegen aan de mailinglist.”

Objecten: Gebruiker, Recipient, Mailinglist
Methode: AddRecipient

Belangrijk om te realiseren bij het identificeren van objecten is het feit dat objecten ‘dingen’ representeren géén processen. Processen zijn de interacties tussen de verschillende objecten. Hierin verschilt OOP dus fundamenteel met procedurele programmeertalen.

Twee basisprincipes worden door GoF naar voren gebracht:

Program to an interface, not an implementation
Favor object composition over class inheritance

Het eerste principe wijst op het gebruik van interfaces om de verschillende objecten met elkaar te laten communiceren. Zoals eerder uitgelegd zorgt het gebruik van interfaces voor een minder sterke koppeling tussen de verschillenden objecten en biedt hierdoor een verhoogde weerbaarheid tegen toekomstige aanpassingen.

De volgende code laat een class zien die sterk gekoppeld is met de class Logger:

class CoupledObject
{
  public void DoSomething()
  {
    Logger logger = new Logger();
   
    // Do something...
    logger.log("Log this!");
  }
}

De volgende code laat zien dat het gebruik van een interface zorgt voor loose coupling:

class DeCoupledObject
{
  public void DoSomething()
  {
    ILogger logger = LogHelper.getLogger();
    
    // Do something...
     
    logger.log("Log this!");
  }
}

De LogHelper class stelt een class beschikbaar die de interface ILogger implementeert. De helper class kan nu dus elke class ter beschikking stellen zolang deze class maar de ILogger interface implementeert. Welke class wordt aangeboden kan bijvoorbeeld worden bepaald door een configuratiebestand uit te lezen. De helper class wordt in dit geval ook wel een factory object genoemd, een producent van classes.

Het tweede principe, 'favor object composition over class inheritance', geeft aan dat overerving van classes niet altijd de beste methode is om code te hergebruiken. Dit wordt echter wel vaak aangedragen als een voordeel van object georiënteerd programmeren. Afgeleide classes kunnen kapot gaan door toekomstige veranderingen in het basis type dat overerft wordt. Tevens dienen afgeleide classes zo gebouwd te worden dat elke plaats waar het basis type ingezet kan worden, ook het afgeleide type kan worden gebruikt. Dit is in de praktijk lang niet altijd het geval, omdat bestaande functionaliteiten van het basis type overschreven of aangepast worden, en niet meer bruikbaar zijn in de context van het basis type. (zie ook Liskov’s Substitution Principle)
Overerving dient eigenlijk alleen gebruikt te worden als er alleen nieuwe methoden aan een class worden toegevoegd. Compositie is meestal een veiligere oplossing voor het hergebruiken van code. Met behulp van compositie creëer je een nieuw type (class) die een instantie van het basis type bevat. Het basis type wordt nooit rechtstreeks aangesproken, maar is een private member. Het compositie object heeft nooit toegang tot de interne delen van de basis class en kan het gedrag dus niet veranderen. Het compositie object is in feite een wrapper en delegeert waar nodig alle aanroepen naar het basis type en voegt zelf functionaliteiten toe. Voorbeeld:

class CompositeClass
{
  private BaseClass baseClass;
  public CompositeClass()
  {
    baseClass = new BaseClass();
  }
   
  public void DoSomeWork()
  {
    baseClass.DoSomeWork();
   
    // Add extra code here..
  }
}

Als we nu beide principes zouden willen combineren moeten we eigenlijk het interne basis object niet rechtstreeks aanspreken, maar vervangen door een interface.

SOLID OOP principes

Naast de basisprincipes beschreven door de Gang of Four bestaan er nog een aantal geavanceerde principes, de belangrijkste zijn gebundeld door Robert C. Martin, genaamd de SOLID principles:

Single Responsibility Principle: There should never be more than one reason for a class to change. (Robert C. Martin, 1996) Wanneer een class meerdere verantwoordelijkheden heeft, bestaan er meerdere redenen om een class aan te passen (lage cohesie). Dit geeft een koppeling tussen de verschillende verantwoordelijkheden, wat leidt tot rigiditeit en fragiliteit van een applicatie.
Open Closed Principle: A module should be open for extension but closed for modification (Bertrand Meyer, 1988). Dit betekent dat de source code van een module nooit aangepast wordt, maar altijd d.m.v. overerving of compositie wordt aangepast. In de praktijk is het meestal de interface die niet aangepast wordt.
Liskov’s Subtitution Principle: Subclasses should be substitutable for their base classes. (Barbara Liskov, 1994). Een afgeleide class zou altijd ingezet moet kunnen worden waar hun basis class ook kan worden ingezet. Eerder is al gezegd dat dit niet altijd het geval is, compositie is dan op zijn plaats.
Interface Segregation Principle: Clients should not be forced to depend on methods that they do not use. (Robert C. Martin, 1996). Interfaces van een class zouden cohesive moeten zijn, gegroepeerd naar functionaliteiten. Wanneer dit niet het geval is, deel dan de interfaces op in verschillende delen. In het geval van een ‘fat interface’ zou elke class die deze interface implementeert alle methoden moeten implementeren, inclusief de methoden die hij niet gebruikt.
Dependency Inversion Principle: High-level modules should not depend upon low-level modules. Both should depend on abstractions. Abstractions should not depend upon details. Details should depend upon abstractions. (Robert C. Martin, 1996). Kort gezegd zouden high-level modules niet afhankelijk mogelijk zijn van één of meerdere low-level modules. Het volgende voorbeeld geeft een nieuwsbrief module aan die afhankelijk is van een low-level module om de nieuwsbrief te versturen:

class NewsLetter
{
  public void SendNewsLetter(string Email)
  {
    IMailer mailer = Helper.getMailer();
    mailer.send(this, Email);
  }
}

Om de afhankelijkheid op te heffen, kunnen de low-level modules worden geïnjecteerd in de constructor van de high-level module:

class NewsLetter
{
  private IMailer mailer = null;
   
  public NewsLetter(IMailer mailer)
  {
    this.mailer = mailer;
  }
   
  public void SendNewsLetter(string Email)
  {
    this.mailer.send(this, Email);
  }
}

Conclusie

De belangrijkste les die getrokken moet worden is het feit dat software ontworpen moet worden met het oog op toekomstige aanpassingen en toevoegingen. Alle principes beschreven in dit artikel bevorderen de flexibiliteit van een applicatie en verhogen hiermee de weerbaarheid tegen veranderingen.
Naast design principles bestaan er ook talloze design patterns die helpen bij het oplossen van bekende design problemen en zorg dragen voor een minimaal aantal afhankelijkheden in de code. Patterns zijn bewust niet genoemd in dit artikel aangezien patterns meestal toegepast worden op specifieke probleemgebieden, terwijl de design principes genoemd in dit artikel algemeen toepasbaar zijn.

Gebruikte literatuur:

Microsoft .NET: Architecting Applications for the Enterprise, Dino Esposito et al, 2009.
Design Principles and Design Patterns, Robert C. Martin, www.objectmentor.com, 2000.
The Single Responsibility Principle, Robert C. Martin, www.objectmentor.com, 1996.
The Open-Closed Principle, Robert C. Martin, www.objectmentor.com, 1996.
The Liskov Substitution Principle, Robert C. Martin, www.objectmentor.com, 1996.
The Interface Segregation Principle Principle, Robert C. Martin, www.objectmentor.com, 1996.
The Dependency Inversion Principle, Robert C. Martin, www.objectmentor.com, 1996.
Patterns of Enterprise Application Architecture, Martin Fowler, 2003.
ASP.NET MVC Framework Unleashed, Stephen Walter, 2009.

Mindmapping met Bubbl.us

Sun, 21 Oct 2012 15:03:00 GMT

Op lifehacking.nl kwam ik de term mindmapping een aantal weken geleden voor het eerst tegen. Mindmapping is een methode om je gedachten en/of ideeën over een bepaald onderwerp in kaart te brengen

A mind map is a diagram used to represent words, ideas, tasks, or other items linked to and arranged around a central key word or idea. Mind maps are used to generate, visualize, structure, and classify ideas, and as an aid in study, organization, problem solving, decision making, and writing.
Wikipedia Mindmapping

De methode intrigeerde mij direct aangezien ik al langere tijd op zoek ben naar een manier om gedachten over bepaalde onderwerpen snel vast te kunnen leggen, te kunnen ordenen en makkelijk terug te kunnen vinden. De onderwerpen waar je een mindmap van kan maken zijn zeer uiteenlopend: Het ontwerp van een nieuw software product, het opstellen van een offerte, de inrichting van een huis of gedachten over een blog artikel zoals deze. Kortom alles wat je maar kan bedenken.

Na wat zoeken vond ik een aantal tools die je helpen om deze mindmaps te maken. Belangrijk criterium is dat de mindmaps snel en eenvoudig te creëren zijn, je bent aan het brainstormen en je wil niet dat je tijd en focus verspeelt aan een applicatie. Eén tool heeft mijn hart gestolen:Bubbl.us

Bubbl.us is een webapplicatie die gebruik maakt van de mogelijkheden van Adobe Flash en is kinderlijk eenvoudig in gebruik, je kan direct beginnen met het maken van een mindmap. Je begint met één ballonnetje, en met behulp van de enter en tab toets maak je respectievelijk childs en siblings aan. Voor het opslaan van je hersenspinsels dien je een account aan te maken. Totale kosten: noppes.

Het feit dat Bubbl.us een webapplicatie is heeft als voordeel dat je de applicatie altijd en overal kan gebruiken, mits je een internetverbinding hebt natuurlijk. Ook staan al je eerdere zielenroerselen altijd ‘in the cloud’ op je te wachten. Tevens is het mogelijk bepaalde mindmaps te delen met anderen, dit maakt het mogelijk om online te brainstormen!

Ik heb Bubbl.us de afgelopen weken gebruikt voor een aantal projecten, puur om mijn gedachten op een rijtje te zetten. Tot nu toe is het voor mij een efficiënte manier om mijn gedachten snel vast te leggen en te ordenen. Het leuke is dat je snel al je gedachten neer kan plempen en in een later stadium orde in de chaos kan aanbrengen. Het geeft een goed houvast gedurende het project en nieuwe ideeën en inzichten zijn snel ingepast en vastgelegd.

Bubbl.us is geheel gratis, vergeet daarom niet een klein bedrag te doneren als teken van dankbaarheid als je de tool echt gaat gebruiken. Dit kan eenvoudig met behulp van Paypal.

Overigens: Pen en papier zijn ook geweldige gereedschappen voor een mindmap ;)