Peter's Gekko

A simple WCF service with username password authentication: the things they don’t tell you

pvanooijen — Mon, 22 Mar 2010 11:35:00 GMT

The WCF framework is gigantic. It has such an enormous amount of possibilities that it’s pretty easy to get completely lost. For our scenario we needed just a small basic subset. Our application provides a set of services which are consumed by a diversity of clients which have to tell who they are by providing a custom username and password. There are loads and loads of documents and manuals to be found on the web but I didn’t find anything which gave me the complete story. Most of them follow all kinds of sidesteps in other parts of the rich WCF framework. Things we didn’t need at all, the things we needed to get our stuff to work were either omitted or only mentioned briefly in a comment.

This post tries to describe the full story. It will try to keep quiet on all noise on other cool, but unneeded, features. This information is assembled from a rich variety of stuff on the web and error messages provided by the WCF framework itself. The latter are often quite to the point and provide a lot of essential information. This post is just a kind of cookbook recipe, I don’t claim to understand every detail and would appreciate any comment to further clarify the details.

The service

The service is an ASP.NET service, hosted by IIS and configured in the system.ServiceModel part of the web.config.

  <system.serviceModel>
    <services>
      <service behaviorConfiguration="FarmService.CustomerDeskOperationsBehavior" name="FarmService.CustomerDeskOperations">
        <endpoint address="" binding="wsHttpBinding" bindingConfiguration="RequestUserName" contract="FarmService.ICustomerDeskOperations">
        </endpoint>
        <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange"/>
      </service>
    </services>

The endpoint address is the root of the IIS site in which it his hosted. To use username authentication you need to use wsHttpBinding. The services functionality is described in the ICustomerDeskOperations contract.

In the binding you specify the credential type as username.

<bindings>
  <wsHttpBinding>
    <binding name="RequestUserName" >
      <security mode="Message">
        <message clientCredentialType="UserName"/>
      </security>
    </binding>

In the servicebehaviour you set up how the username is going to be validated

<behaviors>
  <serviceBehaviors>
    <behavior name="FarmService.CustomerDeskOperationsBehavior">
      <serviceMetadata httpGetEnabled="true"/>
      <serviceCredentials>
        <userNameAuthentication userNamePasswordValidationMode="Custom" customUserNamePasswordValidatorType="FarmService.Authentication.DistributorValidator, FarmService"/>
        <serviceCertificate findValue="Farm" storeLocation="LocalMachine" storeName="TrustedPeople" x509FindType="FindBySubjectName"/>
      </serviceCredentials>
    </behavior>

The username is custom validated. This is done by the FarmService.Authentication.DistributorValidator class in the FarmService assembly. This class inherits from WCF class UserNamePasswordValidator and overrides the Validate method.

public class DistributorValidator : UserNamePasswordValidator
{ 
    public override void Validate(string userName, string password)
    {
        if (string.IsNullOrEmpty(userName) || string.IsNullOrEmpty(password))
            throw new SecurityTokenException("Username and password required");
        var repository = new DistributorRepository();
        if (! repository.IsKnownDistributor(userName, password))
            throw new FaultException(string.Format("Wrong username ({0}) or password ", userName));
    }
}

The method validates the incoming username and password in a repository and throws appropriate exceptions when needed. This is really custom code. As long as you don’t throw an exception the service invocation will be accepted.

So far this could have been a copy of many a story on the web. Except for one detail which is absolutely essential. For username password authentication to work your server hosting the service needs an X509 certificate. Else all service invocations will fail. This certificate is specified in the service behavior.

First you need a certificate. Instead of buying one (which is bound to a specific server address and thereby as good as useless for testing purposes) you can create your own. The .net framework comes with tools to generate these and there are several tutorials how to use these tools. Far more easier is selfcert a pluralsight tool which takes care of the whole process in a couple of clicks.

What they don’t tell you here is that you have to run the tool as administrator, else it will crash most ungracefully. What the tool is also unclear about is where to store the generated certificate. By default it is stored in MyStore. When validating the certificate it’s trustworthiness depends on the location it is stored. When the store is not trusted a chain of validation is started. Instead of setting up a chain of certificates you can also directly store your certificate in a trusted store.

With these settings the certificate is stored in a trusted location. The name and location match the settings in the service behavior

Troubles don’t end here. After a while, like logging in the next time, the service host will start complaining it cannot find the private key of the certificate with a “Keyset does not exist” error message. What happens it that the service no longer has the access right to read the certificate. What helped me was explicitly setting rights on the certificate’s private key file.

Here I am using a blunt axe by just allowing everybody read rights on the certificate’s private key file. I’m no security expert but I am aware this is absolutely not the way to do things. But hey, I only want to build a service, never asked for this certificate stuff and the only thing I want to do here is get that out of the way in the development process.

Now the service is ready to be consumed by a client

The client

To consume this service add a service reference in the client. The mexHttpBinding in the service configuration enables to read all metadata form the service without any credentials.

Setting up a connection to the client requires some fiddling. Again not all of these settings are clear by default.

var endPoint = new EndpointAddress(new Uri(Farm.FarmUrl), EndpointIdentity.CreateDnsIdentity("Farm"));
var binding = new WSHttpBinding();
binding.Security.Mode = SecurityMode.Message;
binding.Security.Message.ClientCredentialType = MessageCredentialType.UserName;
 
var result = new CustomerDeskOperationsClient(binding, endPoint);
result.ClientCredentials.UserName.UserName = Farm.FarmUserName;
result.ClientCredentials.UserName.Password = Farm.FarmPassword;

First we need an endpoint. This is assembled from the url in the client’s configuration, here a constant Farm.FarmUrl. For the custom username authentication to work the endpoint also needs an EndpointIndentity. According to the sparse msdn documentation this is to prevent phishing. The fact that the identity was needed and the parameter had to be the certificate’s name was suggested by the WCF error messages.

The security is set according to the security settings we have seen in the service. Both the username and password are set in UserName property of the ClientCredentails.

Wrapping up

This is it. Now our service and clients are talking. But it took far to much effort to find the right settings. The number is not great, but they all were found to be essential. Finding the right was a process of endlessly weeding out all sidesteps. I hope this well help you to get it done a little faster.

Ubiquitous and unambiguous ?

pvanooijen — Sun, 07 Mar 2010 16:45:00 GMT

My last musings on a observed misuse of ubiquitous language (UL) led to deeper comments than I had ever realized when writing the story down.

To many a non native speaker ubiquitous is at first hearing a strange word, as far as I know it is not widely used outside the world of IT. The sounding reminds of (un-)ambiguous, a term often found in the same context. There is a relation between these two words and IMHO that was the heart of the comments and led me to take another dive into the idea of UL.

The term Ubiquitous Language was brought to the world of software by Eric Evans in his classic book Domain Driven Design (DDD). Where it is defined as a language based on a model and spoken by both domain experts and developers. It should be “more robust than the lowest common denominator” (p.25). Domain experts “should object to terms or structures that are .. inadequate to domain understanding” and developers “should watch for ambiguity ..” (p.27) So a good UL is a powerful common unambiguous language spoken by all experts, whatever their background, to communicate on a software system.

Note the stress on the word expert. Now some people involved are not an expert. Take the old lady in my previous story, the recipient of UL. She might be very good in choosing what to buy and finding her way to the counter but when it comes to the technical rules of dealing with her payment she has all the right in the world to be a nitwit. As a domain expert you can consider her as something outside of the domain. To communicate in a safe way you can use an anti corruption layer (ACL). For the outgoing messages it will translate a lot of the domain specific facts and rules into a subset of commands like “Don’t do this” and “Please do that”. Which is perhaps not too friendly but at least it is unambiguous. But when it comes to incoming messages things get bad. These messages will be quite ambiguous. Like “I don’t understand”, without the sender even being able to make clear what she does not understand. Here we have a many to one mapping for outgoing messages and a one to many mapping for incoming messages. Where the latter can be quite ambiguous. “Would you please be so kind to explain what it is you don’t understand ?”.

The core of this problem is IMHO not an IT issue, it is just that the modern technological world is becoming too complex for more and more people. Be prepared for that yourself to. Just wait for the moment when you are going to give up on the new toolkit or methodology. That moment will come. According to the Peter principle I am almost there myself :)

Ubiquitous language leaking in the wrong direction

pvanooijen — Fri, 19 Feb 2010 15:34:07 GMT

This is a little musing on something I observed in a supermarket the other day. Over here (in the Netherlands) more and more shop payments are handled online. The employee scans the shopping, the counter sums up the amount due and the customer sweeps a card to authorize a payment from her account to the shop’s account. Behind the scenes there is a quite interesting domain with loads and loads of fodder for stories on software design. For the public quite handy and also the older generations, having used cash their entire life, are using it en masse.

The other day there was an old lady next in my counter line. Proudly she was waving her card, feeling all part of modernity. Until the employee told her “The transaction cannot be started until the first article is scanned”. To me this was a very informative piece of domain specific ubiquitous language. But the old lady felt like an alien living in a world she no longer understood and started looking for her purse.

At first it only made me realize that an ubiquitous language may be quite informative and precise for people working inside the domain but that that same jargon and strictness scares a lot of (potential) users of the domain being discussed.

Later on I realized that the employee had made an even bigger mistake. The customer herself is not a part of the domain at all. The shopping’s are a part and her card is a part. But by addressing the customer herself the assumption is made that the shopping’s and the payment are associated with one and the same person. The shop doesn’t care as long as somebody pays. The shopping’s don’t care as long they leave the shop. Who needs a customer ?

The domain does need a customer to use it. But don’t hassle her with language never intended to leak out of the domain.

My 2 e-Cents

The comments on this make it clear there are two ways you can view the situation. Each with different implications. What the real problem was depends on the position of the lady in the story.

1. She is not a part of the domain, only an actor providing some input. Like passing in some shopping and passing in a payment. This actor (or these actors, in case somebody else is going to pay) needs some instructions. In a language which she understands. But even when the terms in the language, like transaction, article and scan are replaced with words of her choice it would be only confusing to her to expose the rules of the domain to her. It would be far better to just tell her “Please wait swiping your card until I tell you to do so”. But that doesn’t really map on the UL spoken inside the domain.

In this scenario there is just no UL which is understood by everybody. It’s just the shop employee uttering impropriate language.

2. The lady is part of the domain. In this case the interface between shopper and counter is not that good. As it exposes behavior which cannot be granted to be understood. Or at least should be expressed in a better language.

In both views the language is the problem. Speak in a language clearly understood by the receiver. Or just keep quiet.

</Post scriptum>

From Hyper-V back (?) to Virtual PC

pvanooijen — Sun, 31 Jan 2010 13:56:00 GMT

For over a year I have been using Server 2008, 64 bits, as OS for my laptop. The main reason for this platform was Hyper-V. Almost every other project I’ve been working on needs another virtual server. And each location I am working has a different network. With Hyper-V both switching servers and switching networks works fast and good. The downside of using Hyper –V is that it knocks out all possibilities of hibernating or putting my laptop to sleep. Server 2008 R2 boots a lot faster, but still. Another downside is that to use Hyper-V you have to run the 64 bit versions, R2 only comes 64 bits. Visual studio is a 32 bit app, runs OK on 64 bits but it is still not the most stable piece of software I know.

Due to circumstances I had to use my laptop more and more in typical mobile situations. Also the way my colleague presses the power button, is back where he was, does his thing, closes the lid and just walks away made me a little jealous. Perhaps I should move on to Windows 7 and try Virtual PC 2009. I had played with that combination and it looked promising.

To see if this was a good idea I set up some some tests

Is it possible to migrate the hyper-V virtual machines to Windows 7 virtual PC ?
Can you switch networks in a virtual machine without the need of a reboot ?
How does a running virtual machine survive a sleeping machine ?
How does a running virtual machine survive hibernation ?

All version of hyper-V and virtual PC share the same virtual hard disk (vhd) format. They differ on the integration features, some piece of host specific software installed on the virtual machine to facilitate all communication with virtual machine. Both Hyper-V and Virtual PC have “Install integration features” as menu option.

As a test candidate I took a virtual machine with quite a history. It started its life in Virtual PC 200x as a Windows server 2003 machine with several monsters of sql 8 databases, sql reporting services and some COM custom app. Over the years it had been upgraded tot server 2008 and been living under several versions of Virtual server and Hyper –V. Not something to rebuild from scratch, just getting that version of reporting service to work is a piece of science on itself. In short: a typical real world machine. Under the several host OS-es it had seen several completely different versions of integration services. These were pretty screwed up. Every attempt to install the newest integration services resulted in messages complaining about previous versions. But the machine still worked.

Migrating

The official recipe to migrate a virtual machine is to uninstall integration services, move the machine and reinstall the integration services of the new host. But you will not find integration services under the installed programs. All attempts to uninstall form the command prompt (/Uninstall) only resulted in the same messages about previous versions.

What worked is changing the HAL (Hardware Abstraction Layer) of the virtual machine:

Start MSconfig
Boot Tab
Advanced Options
Check the “detect HAL” box

After that I just shut down the machine, copied the hard disk and created a new virtual machine in W7 Virtual PC using the copied vhd file as hard disk.

The machine booted and complained about requiring new drivers. It also required renewed activation. I installed the W7 Virtual PC integration services and allowed the renewed activation (which is never a problem with MSDN OS licenses). And after that the machine just worked fine. All integration was smooth, all software had perfectly survived the migration.

Switching networks

I can be short on this. This works just as smooth as in Hyper-V

Changing the adapter in the settings is instantaneously reflected in the status of the virtual machines adapter. The good thing is that everything works just as well with an adapter with a dynamic IP address as with one with a static address.

Sleep and Hibernate

The difference between sleep and hibernate is that in sleep mode the RAM of the PC is still powered, so actually the machine is still alive. In hibernate mode all RAM is saved to and restored from disk.

In Hyper-V the virtual machines are running on the machine level. In virtual PC you start a virtual machine as a logged in user. When logging off the virtual machines are shut down (or hibernated). Instead of logging of I tried both sleep and hibernate with the virtual machine still running. Again all news is good. All functionality completely survives both scenarios. Virtual PC is not ignorant of my actions. When hibernating it will (automatically) disable the integration services. When awakening it restores them.

To conclude

The only hurdle I had to take was the HAL setting when migrating the machine. All the rest just worked. So I repaved my laptop with Windows 7 and virtual PC 2009. (Just skip the virtual XP step unless you need a virtual XP machine). I was quite satisfied with Server 2008 (except the required full boot) but do like Windows 7 even better. VS worked well and now even works better. But that could be the result of a fresh install (there is no upgrade possible from 2008 to 7).

And now I can also close the lid of my laptop and leave the building.

Why choose between Ajax or MVC ? Together they KISS so sweet…

pvanooijen — Mon, 18 Jan 2010 10:38:00 GMT

Technology comes in waves. Over the years we have been drowned by several waves of web development technologies from MS. ASP, ASP.NET, ASP.NET Ajax and now there is ASP.MVC. A new wave does bring nice new things but also has the tendency to wash away the things brought by the one before. Also for the users of the software we create. Thanks to partial postbacks ASP.NET Ajax brought the user a far more pleasant view in the browser. Not every click resulted in a full screen refresh with its disturbing flickering. And the possibilities of javascript gave more room for screen candy. ASP.MVC, the next wave, still does care a lot about the possibilities of script but partial rendering has moved somewhat to the background of attention. Most MVC documentation and examples describe a full rebuild of the page. Bringing the user back to the well known restless browser screens.

But ASP.MVC is full of Ajax possibilities. It is even easier to build ajax style apps than in ASP.NET ajax. In this post I will first present the basics and give some hints to create a popup screen. Not one in a new window but one which can easily communicate with the document which created it.

Partial views

In MVC the basics for a partial screen update are present in the form of partial views. They are regular ascx usercontrols.

Inside straightforward MVC scaffolded markup, including the possibility to use a strong typed model

<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl<MyModel>" %>
<%@ Import Namespace="AjaxKissesMVC.Models"%>
<% =Model.MyProperty %>
<%
    foreach (var item in Model.MyList)
    { %>
        <% 
        =Ajax.ActionLink(item, "Partial", new {routeValue = item}, new AjaxOptions {}) %>
        &nbsp;
        <%
    } %>
 

More on the ActionLink later on. This is My Model

public class MyModel
{
    public MyModel()
    {
        MyProperty = "This is my model";
    }
 
    private readonly List<string> myList = new List<string>() {"One", "Two", "Three"};
    public string MyProperty { get; private set; }
    public IEnumerable<string> MyList
    {
        get
        {
            return myList;
        }
    }
}

You assemble a page from usercontrols using the renderpartial method of the html extension class

<asp:Content ID="indexContent" ContentPlaceHolderID="MainContent" runat="server">
    <h2><%= Html.Encode(ViewData["Message"]) %></h2>
    <p>
        <% Html.RenderPartial("MyPartialView", new MyModel()); %>        
    </p>
</asp:Content>

The ajax stuff needs extra script libraries. Include these in your masterfile

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title><asp:ContentPlaceHolder ID="TitleContent" runat="server" /></title>
    <link href="../../Content/Site.css" rel="stylesheet" type="text/css" />
    <script src="/Scripts/MicrosoftAjax.debug.js" type="text/javascript"></script>
    <script src="/Scripts/MicrosoftMvcAjax.debug.js" type="text/javascript"></script>
</head>

Async postbacks

The code so far produces this result.

Three hyperlinks, as dictated by my model. As they are created by the ajax-, and not the html-, extension class they will do an async partial postback.

These requests are also caught by the home controller.

public class HomeController : Controller
{
    public ActionResult Partial(string routeValue)
    {
        return null;
    }

What the action returns does not matter yet, for now I just return null. The reason it does not matter yet is because the actionlink has not defined a target to receive the result of the action.

An ajax actionlink has as obligatory parameter an AjaxOptions object. So far I had created an empty object. A list of the properties of the AjaxOptions class is shown by Intellisense

The updatetargetId is the id of any DOM element. Like an ordinary div. On the main page I will add an empty div as placeholder for the result of the async postback

<asp:Content ID="indexContent" ContentPlaceHolderID="MainContent" runat="server">
    <h2><%= Html.Encode(ViewData["Message"]) %></h2>
    <p>
        <% Html.RenderPartial("MyPartialView", new MyModel()); %>        
    </p>
    <div id="yourselection"></div>
</asp:Content>

(It would be tempting to code the div as <div id="yourselection"/>, but that will spoil the trick.)

This div is going to be the updatetarget for the ajax action link

        <% 
=Ajax.ActionLink(item, "Partial", new {routeValue = item}, new AjaxOptions {UpdateTargetId = "yourselection"}) %>

Now the controller has a target for its result. I create another simple partial view to return

<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl<MySelection>" %>
<%@ Import Namespace="AjaxKissesMVC.Models"%>
On <%=Model.SelectedTime %> you selected <%=Model.SelectedValue %>

This view uses another simple model

public class MySelection
{
    public MySelection(string selectedValue)
    {
        SelectedValue = selectedValue;
        SelectedTime = DateTime.Now.ToLongTimeString();
    }
 
    public string SelectedValue { get; set; }
    public string SelectedTime { get; private set;}
 
}

The model is passed to this partial view and this partial view will be the result of the action

public class HomeController : Controller
{
    public ActionResult Partial(string routeValue)
    {
        return View("Selected",new MySelection(routeValue));
    }

The result of the partial postback is now that the div will be filled by the contents of the usercontrol.

That is all there is to the basics to create aync postbacks and do partial rendering. All pretty straightforward. And with loads of possibilities to enrichen behavior.

Creating a pop up

As a small example I will now present the basics of a (not the) way to do a popup screen. Creating a popup in a new browser window has quite a few drawbacks. Your application loses control of the window and communicating between the two DOM’s in the separate windows is no fun either. It is so much easier to have your popup and its contents in the same document.

Plain old HTML (POH ?) has the possibility to render itself in layers. Each layer has it’s own z-index. I will now add the target of the async postback as a new layer to the master page

<body>

    <div id="yourselection" style="z-index:2; position:absolute;"></div>
    <div class="page">
 
        <div id="header">
            <div id="title">
                <h1>My MVC Application</h1>
            </div>
 

The z-index attribute makes it a new layer. A new layer in the same document. The position:absolute attribute ensures independent positioning from the underlying layer. To see the effect the resulting partial view of the async postback is decorated with a style.

.popup
{
    background-color:Transparent;
    border-style: double;
    border-width: thick;
    border-color:Red;
} 

Also a button is added to the popup. Clicking the button fires a script statement to close the popup. It does that by clearing the innerHTML of the target div

<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl<MySelection>" %>
<%@ Import Namespace="AjaxKissesMVC.Models"%>
<div class="popup">
   On <%=Model.SelectedTime %> you selected <%=Model.SelectedValue %>
   <input type ="button" value="Close" onclick="$get('yourselection').innerHTML='';"/>
</div>

This results in a transparent popup which lies on top of the originating page and can be closed by clicking the button.

By far not complete but the basics are there. I will leave it up to you (or better your html artist, I’m not good at it either…) for the further visual candy.

What I hope to have demonstrated is how easy and straightforward it is to add ajax functionality to an mvc application. Do your end users a favor and use it.

New year, new address

pvanooijen — Tue, 29 Dec 2009 14:10:00 GMT

Warning: this post has no technical content. But is a little explanation why I have cranked out so little of that lately.

Due to not to happy circumstances I have moved. My new address is:

Gekko Software

Peter van Ooijen

Viermat 7

9753 KW Haren

Moving does provide lots and lots of fodder for rants. Some small ones

Trying to move an internet connection is sheer hell. I thought I had the best provider in the Netherlands, at least they say the public considers them such. The enormous hassle it took to move makes me wander how bad the others are. As a result my ex-wife had only one day without internet and I still have two wait two more weeks.
Mobile internet dongles are great. But don’t trust them to work always, especially not in an everyday scenario. So far I only got it to work on my Server 2008 R2 laptop. Not on my W7 desktop, neither on an XP laptop.
Watch out for W7N, the explorer-less W7 version created to please “that woman” Neelie Kroes. I overlooked the N installed the W7 ultimate N on our mediacenter and now my kids have tp watch a DVD on a laptop. W7N has nothing usefull for a family PC. No explorere and no Media player, you can play nothing on it.

So far the bad news. 2010 is going to be great and I’ll be back to normal posting.

Happy new year everybody

Switching virtual networks the easy way

pvanooijen — Thu, 12 Nov 2009 10:40:00 GMT

For my laptop I am using server 2008 as OS. The main reason is Hyper V, for every different project I can fire up one or more appropriate virtual servers. For the details on setting up such an environment see this post. On the advantages of using Server 2008 R2 see this post. Traveling around the laptop meets a lot of different networks, from the Office domain of which it is a member to some kind of wireless in the wild open. Sometimes I want my virtual servers to see and be seen by the outer world, sometimes I don’t.

You can do a lot of network configuration in Hyper-V, in this post I described a rather baroque configuration where all kinds of network connectivity can be switched on and off. Which worked well but is far more complicated than needed. By now I have found out that switching networks in Hyper –V can be as simple as this:

Create a virtual network for every adapter on the laptop.

My laptop has an internal (fixed IP address) adapter and an external USB adapter (depending on DHCP). The Hyper-V virtual network manager does not allow you (yet ?) to pick Wireless or dial-up adapters for a virtual network.

Assign each virtual machine just one network adapter.
Select the active adapter as needed.

The good thing is that this can be done while the virtual machine is running. Changing the network is instantaneous. Just like pulling the cable and inserting another one. So much simpler than all the previous multi network fiddling.

Something you can (not) do with your (old) MSDN disks

pvanooijen — Mon, 26 Oct 2009 12:52:00 GMT

Time to renew my MSDN subscription. I don’t know about you but I’m still very pleased with the MSDN program.

In the old pre DVD days it used to be quite a problem what to do with the enormous piles of disks you received over and over again. Especially those things you never use. Anyone interested in a Finish version of Exchange server ? A Greek version of Windows 98 ? Since DVD times the piles has gotten a little smaller, but still. Googling around what to do with all these disks pops up an old rant of mine on this.

Being a biologist with a huge interest in aquarium fish (see my W7 betta rant) and an “old goat-wool-socks” environmental concern I thought I had a good use. Digital disk are very reflective, using them as a reflector for the light in my aquarium would give the disks a new life and would increase the effectiveness of fish tank lighting. So I tried.

This is what the result looked like in less than a year.

Moist has crept between the reflective (aluminum) layer and the (polycarbonate) disk itself and completely oxidized the metal. Resulting in a surface which reflects far less than the ground surface itself. Lesson learned: this does not work.

What you can do today with your disks is what I already asked for in my original rant: don’t get them. MSDN subscriptions now offer a download only option. You are free to download what you need (and what’s in your license). For many a product this was what I did already, downloading got me the product long before the disk finally arrived by mail. So if you want to stop wasting resources too: do switch to this subscription type. The only wish I have left is to save a little on money. Not producing and distributing the disks saves MS in the costs. I would like a small share of that in the form of a reduction on my MSDN fee. Fair deal ?

Map control confusion

pvanooijen — Thu, 22 Oct 2009 15:30:00 GMT

When it comes to including geographical information in your web-application you have to make two main decisions. The first one is which API you are going to use, the second one is who is going to provide the geographical data. These two are not always completely independent.

A lot of websites use google maps. The geographical information is supplied by google and the only way to get to that information is by using the Google Javascript API. When it comes to performance Javascript is far from ideal, more sophisticated applications which try to add a lot of information to a map are quite likely to hit a script timeout. The other downside of this approach is the (lack of) smoothness of the display. Panning or zooming a map results in a lot of image blur.

Both downsides can be overcome by using Silverlight. The DeepEarth project was the first to use deepzoom which results in a smooth display when scanning or zooming. The strong typed compiled C# Silverlight code working with the map has not only a speed advantage over Javascript, it’s running async resulting in an app which not only has a smooth look but also a smooth feel.

You can build amazing apps with that. This is a part of the MVP map created by DeepEarth evangelist SoulSolutions

When it comes to where and how to get the geographical data, which can be satellite images, road maps or routing information, confusion starts. The DeepEarth project offered a choice of map providers. Ranging from OpenStreetmap to Yahoo maps and Microsoft Live Earth. Google maps were not included, the reason is the one I mentioned. Nobody so far has managed to create a hack to get Google Map data without leaving JS.

But the most confusing data-provider was and is Microsoft. The first versions of DeepEarth offered plain Live maps. In later versions you were supposed to use LiveMaps webservices. The usage of these services was by far free. There was a free developer test account available which resulted in map images all decorated with the word “staging”. For production you had to buy a license. To get a proper deal for that always got stuck somewhere in the pipeline. At the same time the old versions using plain Live maps kept working. At the moment I’m writing this seems to be history already.

LiveMaps have become Bing maps. At the same time Microsoft started developing their own Silverlight map control. The good thing is that it is a marvel to work with. The performance is even better than DeepEarth. The API just shines, a lot of functionality is present straight out of the box. All the extra work I had to do to get my app running in Deep Earth could be replaced by just hooking into some events. The architecture is great as well. It is by no means just limited to using Bing Maps data, you can even bypass that completely using the control as a blank working surface with a Latitude-Longitude coordinate system. A part of the architecture is a clear and easy way to use any map provider you can imagine, or build yourself. There are a lot of good stories on the web on working with the control.

But, as announced, there is still confusion. First there is the name. It is Microsoft Virtual Earth Silverlight Map Control. I have no problem with that, do you like Bing ? I can’t get used to that. More serious is the source of map data. The control, now in CTP, displays full MS map data without any need to apply for a (test-) license. No staging, no problem. The control itself has a Token property, according to the documentation:

Gets or sets the token to use for service requests.

It contains an empty string. How and when to use it is not clear at all. When it comes to production will it be needed to use the control? Or will it only be needed to get actual MS map data? Which data ? Just routing information ? Maps? Satellite images ? I just cannot find out. In case anybody can shed some light on this, I would appreciate that very much. Building software using the control is great, but what are price and conditions my customer will have to deal with?

ScottGu, DotNed, loads of new stuff and intellisense

pvanooijen — Mon, 28 Sep 2009 12:41:40 GMT

Last Friday Scott Guthrie started his promo tour for VS 2010 and .NET 4.00 in the Netherlands. Dutch user group DotNed had to honor to host his performance.

For us it was Friday late afternoon. For him it was somewhere early in the morning (watch the clock on his laptop). Nevertheless he did two really long talks, over two hours each. Such an energy. One on VS 2010 and one completely dedicated to MVC.

I’m not going into the content, it will all be on the ScottGu blog. Needless to say the talks were entertaining, good and promising. Nice to see R# (code navigation and refactoring) and the alt.net (EF) influence shining through.

There is one little snippet which was really amazing. It’s about Javascript Intelisense. We made it really hard on the fly

It requires some explanation. In the for loop five dynamic variables are introduced, MyVar0 tot MyVar4. In the same loop five message-boxes will pop in the users face and five exceptions are thrown. Nevertheless the intellisense sees all these five variables on the fly. Without any disturbance. Well, that is really amazing.

If you get the chance to go to his talk in the coming weeks or months: do go. I am updated and really enjoyed it.

Windows Workstation 2008 R2: An even better OS for a laptop

pvanooijen — Tue, 22 Sep 2009 11:52:52 GMT

Some time ago I repaved my laptop with Windows 2008, 64 bit. The main reason was Hyper V providing such a good support for virtual machines. I dedicated quite a post on all the details of setting up that system. The machine has served it’s purpose quite well being a very powerful mobile workstation with a crisp response including any virtual server I need for the particular project. The only downsides were it’s relatively long booting time and the lack of power management options like hibernating to compensate for that.

Having heard such good things about Server 2008 R2 (only available in 64 bits version) I decided to upgrade. The process itself is very simple

Shut down all virtual machines
Uninstall Hyper V
Run setup and upgrade
Switch on the Hyper V role
Recreate the virtual networks and machines, using the existing virtual hard disks. Those are (by default) found in the public documents folder.

The last step may seem like a lot of work but it’s just another no brainer.

The result is a machine

Which boots a lot faster
Operates even smoother. Graphics are really better, using the default Windows driver
Has the Windows 7 UI, with nice docking and the Aero shake

Makes me feel happy. In case you’re running Workstation 2008 as well I can only advice you to upgrade this very moment.

Giveaway: antique and nostalgic PC

pvanooijen — Fri, 28 Aug 2009 07:34:00 GMT

As said before, I am getting rid of my past.

For year and years I’ve kept my first PC, as a kind of monument. But now it’s time to say goodbye to that too. As the machine is quite a milestone in the history of computing I guess (hope) there is somebody out there who can give her a place. I’ve tried something likewise before. Perhaps I’m to sentimental about this, but at least it should make a good story.

The machine is an Olivetti M24 (known in the US as the AT&T 6300). Almost as old as the first IBM PC, but with some interesting differences.

The original IBM PC had a 8088 processor. Internal 16 bits but with an 8 bits bus. The main reason was the unavailability of 16 bits support chips. These were available on time for the Olivetti; it is powered by the full 16-bits 8086 processor. Running at a whopping 8 Mhz (instead of the 4.77 in the IBM) with a separate 8087 numerical co-processor.

The is motherboard is mainly covered with RAM chips. A whopping 640K

To mount expansion cards a so called “bus converter” board is fitted. Note the fat power cables. On this board an AST “six-shooter” is mounted which offers things like a second a second parallel and serial port. This machine has it’s own parallel serial and serial connectors. In those days this wasn’t always the case for a PC. Imagine to have to buy a complete expansion board just to attach a printer…

The original IBM PC required a separate Color Graphics Adapter which would give you a 320*200 image. The Olivetti has on board 640*400 proprietary graphics. The popularity of the machine resulted in many software packages like Lotus 123 and later the Borland Turbo Graphix Toolbox providing a driver.

In the early PC days a hard disk (Winchester Drive) was not a standard option. I added one later on, no less than 10 MB. Note the handwritten sector notes on the sticker. I’m not quite sure about this disk still functioning. In case you want to get it spinning smoothly I’d advise a bicycle mechanic to check the bearings. No kidding, it did the trick last time.

In case you are bored stiff with this story, sorry about that. Nostalgic mood. In case you are really interested: she’s all yours. Shipping is not included, and she is on a strict 220V diet.

<Update>She has found a new home</update>

Predicting the future and getting rid of the past

pvanooijen — Thu, 27 Aug 2009 08:27:00 GMT

I spent the end of the summer holiday to tidy up my office. The amount of stuff I had collected over the years was so overwhelming that some serious action had to be taken. Here I would like to share some of my musings on the ancient stuff I have excavated.

Predicting the future is hard but always a nice inspiration. In my youth we were all big fans of a the television series the Thunderbirds. An SF animation staged one century later, that would be around 2066. Which is still more than half a century from now, but 25 years ago it was already clear how wrong the view on future technology was. Energy was abundant and of unlimited power. Far different from the oil-crisis and down-sized cars of today. IT played almost no part at all. In one episode there was a thing named a “computer” which more or less resembled a brain damaged Aibo. And the capabilities of the main communication space station (Thunderbird 5) would be surpassed by today’s average cell-phone.

A more serious look into the future of IT were the pile of Byte magazines I dug up. I had kept them as historical material, a documentation of the emerging world of small sized IT. Running through some of the issues was startling. Byte always was a good source: well informed, well written, well documented. But reading through articles on future developments was quite disappointing. As an example I’ll briefly discuss an article on a typical Codebetter subject in the December 1995 issue.

When carefully reading through the article there are some interesting quotes by people in the field like “As you’re writing code, you should be creating tests”, “establish a testing strategy that builds the interpreter every night and runs it on several” and “uses a variant of the spiral-development life-cycle”. But these were just isolated quotes. The conclusions of the article are, seen through today’s eyes, somewhat toe-curling. The major recommendation is “Fight for a stable design” and a whole page is spent on ways to formalize the development process. Which states : “This means, among other things, that development and testing occur separately”.

Enough said. For me the morale of the story is not that Byte was a bad magazine. It just describes the impossibility to predict the future. In the story are some glimpses of what will happen in later years. Looking back some things, like the quotes I mentioned are now today’s insight. But a lot, if not most, of the other things were just wrong. IMHO this is just another example how change in technology very much resembles that of evolutionary changes of life. The major trend will become extinct and some of the details will become the major trend. But don’t ask which. I blogged on that before.

Having learned this all these Byte magazines have become a thing of the past. How to get rid of the past ? I’ve brought them away to recycle the paper. New ideas can be printed on that.

There is more past I want to get rid of. But I’ll spend a separate post on that.

Domain driven reports: adding custom code

pvanooijen — Wed, 08 Jul 2009 13:21:00 GMT

In my last post I described how to create reports based on a domain model. Which led to many an interesting reaction. In this post I will explore some of my further explorations based on those comments as well on my personal requirements. In this post I will sketch a way to give reports a distinct place in the overall architecture of an application, how to separate the report from its presentation on a winform or a webform and how to add custom, domain based, code to a report.

Reporting is a service

In an application reporting is one of the services. As an implementation I have added a reporting class library to the solution. This class library contains the embedded report, the code to use the report in a report viewer and the report’s custom code.

This project has a reference to the domain model and contains many of the pieces of my first reporting story:

The DataSources based on the domain entities Invoice and InvoiceLine.
An interface IReport describing how the report will be exposed to a report viewer
A base class ReportBase implementing shared code
The report definition Invoice.rdlc
A class Invoicing which implements IReport as well as some custom code.

The IReport interface describes what a report should expose

public interface IReport
{
    string ReportDataSourceName { get; }
    Stream ReportDefinition { get;  }
    List<string> ReportAssemblyNames { get; }
}

It contains

The name of the datasource we met in the previous post.
The report definition as a stream. In the previous post the report was embedded in the same assembly as the report viewer, in this scenario the report is embedded in another assembly and can be streamed from there
A list of assembly names. These are needed by the viewer when we are going to add custom code to the report

The ReportBase class provides a base implementation

public abstract class ReportBase : IReport
{
    protected List<string> _reportAssemblyNames
        = new List<string> {Assembly.GetExecutingAssembly().GetName().ToString() };
 
    public List<string> ReportAssemblyNames
    {
        get { return _reportAssemblyNames; }
    }
 
    public Stream ReportDefinition
    {
        get { return Assembly.GetExecutingAssembly().GetManifestResourceStream(ReportName); }
    }
 
    protected abstract string ReportName {get;}
 
    public abstract string ReportDataSourceName { get;}
 
}

It provides

The base list of assemblynames, already containing the full name of the Reporting assembly
A stream providing the report definition
Stubs for the report and datasource name

Building the invoicing report

On the ReportBase class the Invoicing class is based.

using System.Collections.Generic;
using Gekko.Administratie.DomainModel;
using Gekko.Administratie.Services.Reporting.Base;
 
namespace Gekko.Administratie.Services.Reporting
{
    public class Invoicing : ReportBase
    {
        public Invoicing()
        {
            _reportAssemblyNames.Add("DomainModel, Version=1.0.0.0, Culture=neutral, PublicKeyToken=7610f12aa6ca9a54");
            _reportAssemblyNames.Add(
                "nHibernateHelpers, Version=1.0.0.0, Culture=neutral, PublicKeyToken=ac06ce2921f125f7");
        }
 
        protected override string ReportName
        {
            get { return "Gekko.Administratie.Services.Reporting.Invoice.rdlc"; }
        }
 
        public override string ReportDataSourceName
        {
            get { return "Gekko_Administratie_DomainModel_Invoice"; }
        }
 
        public static string SayBoe()
        {
            return "Just say boo...";
        }
 
        public decimal RunningTotal;
 
        public decimal MyLineTotal(object lines)
        {
            var theLines = lines as IList<InvoiceLine>;
            decimal result = 0;
            if (theLines != null)
                foreach (var line in theLines)
                {
                    result += line.LineTotal;
                }
            RunningTotal += result;
            return result;
        }
    }
}

Notice that the class is using the domain model. In the constructor is adds the names of assemblies used to the list and provides the name of the report and it’s datasource.

It has two kind of custom members. There is the static SayBoe method, which just return a string. The instance member MyLineTotal is far more interesting. As a parameter is expects an IList of InvoiceLines. In which the LineTotal property is calculated in the domainmodel. The running total of all lines is summed in RunningTotal, another exposed member. It would be really nice to use these custom members in our report.

To use the custom code in the report requires some fiddling. All assemblies used should be added to the reference list of the report. To be trusted the assemblies should be signed. Notice the PublicKeyToken.

By adding the Invoicing class to the classes list the report will create an instance of that class when rendering the report. The instance will be available as MyInvoices.

Now the members of the invoicing class are avaliable in the report. The static members are referenced through the class name, this is now a valid reporting expression:

=Gekko.Administratie.Services.Reporting.Invoicing.SayBoe()

The fully qualified class name with the static method.

The instance members are reached through the Code prefix

=Code.MyInvoices.MyLineTotal(Fields!Lines.Value)        

Note that the MyLineTotal method is passed the value of the Lines field. This is a list of InvoiceLines. In the report itself this property is not usable. In the method the parameter is typed as object, the report does not know how to handle an IList<InvoiceLine> and would throw an exception when meeting one. But in the method’s implementation the passed in Lines can be cast to a typed IList and be used as intended.

public decimal MyLineTotal(object lines)
{
    var theLines = (IList<InvoiceLine>)lines;
    decimal result = 0;
    foreach (var line in theLines)
        result += line.LineTotal;
    RunningTotal += result;
    return result;
}

Now that is really nice, I do have full domain specific functionality inside my report.

The runningtotal is accessible through a straightforward reporting expression

=Code.MyInvoices.RunningTotal

Just like any normal property.

Displaying the report

With the report designed it’s time to display it. The .NET framework has two report viewers, one for winforms and one for asp.net. These reportviewers can work with server-side (SQL Reporting Services) reports and with clientside reports. The programming models for the winform and the webform viewer look identical but share, as far as I have discovered, no usable root. I will repeat the code for both variations

On a windows form.

The project references the reporting project. The form contains a report viewer of which no properties are set.

private void Form1_Load(object sender, EventArgs e)
{
    var repo = new InvoiceRepository();
    var invoices = new Invoicing();
    MakeReport(reportViewer1.LocalReport, invoices, repo.ListPrintableInvoices());
    reportViewer1.RefreshReport();
}

The repoistory is opened, an invoicing object is created, the MakeReport helper method ties everything together after which the report can be displayed.

static void MakeReport(LocalReport report, IReport reportSettings, object data)
{
    report.ExecuteReportInCurrentAppDomain(Assembly.GetExecutingAssembly().Evidence);
    foreach (var assemblyName in reportSettings.ReportAssemblyNames)
        report.AddTrustedCodeModuleInCurrentAppDomain(assemblyName);
    report.LoadReportDefinition(reportSettings.ReportDefinition);
    report.DataSources.Add(new ReportDataSource(reportSettings.ReportDataSourceName, data));
}

A report is just some running .net code. The first line sets the context. In case you omit this the reportviewer will not load the expression evaluator and the report will be blank. The second line explicitly sets a list of assemblies which the report is allowed to load. Note again that these assemblies have to be signed, else they will not be trusted. The third line loads the report definition in the viewer. And the last one binds the data to the report.

On a web form

The asp.net reportviewer only works in a classical asp.net application as it requires the viewstate. In case you are working in an mvc application it is no real problem to add a webform to the (otherwise) mvc web-app.

The markup for the reportviewer is simple

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Faktuur.aspx.cs" Inherits="GekkoAdministratie.Faktuur" %>
 
<%@ Register Assembly="Microsoft.ReportViewer.WebForms, Version=9.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
    Namespace="Microsoft.Reporting.WebForms" TagPrefix="rsweb" %>
 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title></title>
</head>
<body>
    <form id="form1" runat="server">
        <rsweb:ReportViewer ID="ReportViewer1" runat="server" Width="100%" Height="600px">
        </rsweb:ReportViewer>
    </form>
</body>
</html>

(Yes drag and drop works fastest :)

The code to set up the report looks completely the same as for the windows form

protected void Page_Load(object sender, EventArgs e)
{
    var repo = new InvoiceRepository();
    var invoices = new Invoicing();
    MakeReport(ReportViewer1.LocalReport, invoices, repo.ListPrintableInvoices());
}
 
static void MakeReport(LocalReport report, IReport reportSettings, object data)
{
    report.ExecuteReportInCurrentAppDomain(Assembly.GetExecutingAssembly().Evidence);
    foreach (var assemblyName in reportSettings.ReportAssemblyNames)
        report.AddTrustedCodeModuleInCurrentAppDomain(assemblyName);
    report.LoadReportDefinition(reportSettings.ReportDefinition);
    report.DataSources.Add(new ReportDataSource(reportSettings.ReportDataSourceName, data));
}

The only difference is that this LocalReport type is from another namespace as the LocalReport type in winforms.

You don’t have to (and can not) issue a RefreshReport, having set up the report it will be rendered to the viewer just fine.

Wrapping up

This is more or less it. It’s still a sketch but it does display the idea. Some things to watch:

Loading an assembly in a report can give you a hard time in Visual Studio. When building the assembly all expressions in the report are compiled to. After adding custom members, you need a successful build before you can use those custom members in report expressions. And when things really stop working you need an occasional restart of Visual Studio. Quite essential were the tips I found in this great post by, all about nothing, Gerhard Stephan. Without the post-build event described there nothing will even build.

In my scenario I am doing something somewhat strange (and perhaps even silly). The assembly I am loading in the report is the same assembly in which the report is embedded. My main intent was to keep all parts of the report, from the content to the viewer related stuff, together. I’m open for any other view on this.

But for now I’m going to pack our tent and let everything sink deeper in on the camping site. France here we come.

Reporting against a domain model

pvanooijen — Wed, 01 Jul 2009 08:44:00 GMT

I have a love it /hate it relationship with reports. In many an application the reports are the main output. They are the prints which get filed or the invoices which have to ensure the ROI of the application. A good looking output rich with information does increase customer satisfaction. The downside is that fine tuning a report is tedious and requires quite different skills than coding. Building a system with a lot of reports can be pretty boring. So the tools better be good. Switching from Crystal Reports to sql server reporting services (RS) was quite a relief.

But RS still has two drawbacks. First is that it accesses data using plain sql. My application is built around a domain model using nHibernate to hide all db details. The domain model includes calculated properties which are to be included in the report. The calculations are done in the domain object. It would be repetitive and prone to error to repeat them in sql or reporting expressions. It would be quite a relief to report straight from the domain model itself.

The other drawback is that RS requires an ms sql server instance with installed reporting services. The actual data is just a sqlexpress instance and I don’t want to set up a full blown reporting services server.

New in Visual Studio 2005 were client side reports (rdlc’s). They are very much like RS reports (rdl’s) but can work with any data source and don’t require a sql reporting server instance. To include these reports in an app two client side report viewers are include in the .NET framework, one for WinForms and one for asp.net. This looked like the best of both worlds so I decided to give the winforms version a try.

For a good overview on the reports check the got reportviewer site. In name it supports VS 2008, but (some of ?) the samples are based on VS 2005. Moving to 2008 there has been a change in the namespace for the classes, after fixing the reference the samples run in VS 2008. How to work with a non sql datasource is covered but not that clear. Here I will describe my minimalistic approach to work with a domain model fed by nHibernate.

The domain model

The intent of the application is to print invoices. This class diagram describes the model

An invoice is for a contact, has a number of lines and an enumerated property. That is a number of values which contain a tax rate and have a clear name describing this value. Which gives the model additional value, something which would get lost when viewing the data as raw db data. An invoice has a reference to a contact and many Invoice lines. The (fluent) nHibernate mappings express this.

public class InvoiceMap : ClassMap<Invoice>
{
    public InvoiceMap()
    {
        WithTable("Factuur");
        Id(x => x.Id);
        Map(x => x.Number).ColumnName("Nummer");
        Map(x => x.OnDate).ColumnName("Dedato");
        Map(x => x.BtwPercentage).CustomTypeIs<BtwPercentage>();
        Map(x => x.Description).ColumnName("Inleiding");
        HasMany(x => x.Lines).KeyColumnNames.Add("idFactuur").Cascade.All();
        References(x => x.ForContact).ColumnName("idRelatie");
        Map(x => x.PrintIt).ColumnName("Printen");
    }
}

So we have a customtype, a hasmany and a references. Let’s see how these are used in the report.

The report

There are several ways to include a report in an application. The default when adding a new report (Add –> New Item –> Reporting –> report) is embedded. Which is clear and easy in deployment. When you need more flexibility you can switch to rdlc file or (back to) server side report.

The report needs a datasource. It will accept any datasource including an object datasource.

Add a new object datasource to the project and pick the Invoice domain object.

Just pick your POCO domain class. There is no need to set up any methods to get data, it is enough to have a model of the data.

This object data source is the datasource for your report. Having done so the domain invoice is available in the report designer. (To be precise the datasource has to be attached to a List, see the reportviewer docs for more information on that.)

A report is built from VB-like expressions. A simple one looks like this:

=Fields!Description.Value

Which displays the plain content of a property. But expressions can be more complicated. The report designer has a good expression builder which even includes intellisense. The next expression uses both the meaningful name and the value of my tax enumeration property in a string

="BTW " & Fields!BtwPercentage.Value.ToString & " "  & Fields!BtwPercentage.Value & "%"

The result is a string like “BTW Hoog 19%”.

Things get really interesting when displaying the contact information. In the domain model this expressed as

invoice.ForContact.AddressLine1

In the report the expression is quite similar

=Fields!ForContact.Value.AddressLine1

The subreport

The lines in the invoice are a one to many relation. The invoice datasource has a lines property but this property is not usable in the report. To display the lines I need a subreport. The subreport is based on invoice lines. After adding the InvoiceLine class as a datasource the subreport is drawn. It is a simple table displaying the lines.

A subreport is linked to its parent report using parameters. In my case an invoice and its lines are linked through a parameter named FactuurNummer.

All of this works just as in “traditional” reports. In the main invoice report this parameter is assigned the value of the invoice number

Check the gotreportviewer site for further information.

Binding the data to the report

Now the reports are ready. The next step is to get some real life data into them.

It takes code to bind real data to a report and display the result in the viewer. Also the subreport has to be fed with data. To wrap things up I have built a helper class which takes a reportviewer component and a list of invoices and wires them up.

internal class InvoiceReporter
{
    internal InvoiceReporter(ReportViewer viewer, IList<Invoice> reportData)
    {
        _reportData = reportData;
        _viewer = viewer;
    }
 
    private readonly IList<Invoice> _reportData;
    private readonly ReportViewer _viewer;
 
    internal void ShowReport()
    {
        _viewer.LocalReport.ReportEmbeddedResource = "Gekko.Administratie.FactuurPrinten.Invoice.rdlc";
        _viewer.LocalReport.DataSources.Add(new ReportDataSource("Gekko_Administratie_DomainModel_Invoice", _reportData));
        _viewer.LocalReport.SubreportProcessing += SubreportProcessing;
        _viewer.RefreshReport();
    }
 
    private void SubreportProcessing(object sender, SubreportProcessingEventArgs e)
    {
        var invoiceNumber = e.Parameters["FactuurNummer"].Values[0];
        var invoice = _reportData.First(fakt => fakt.Number == invoiceNumber);
        e.DataSources.Add(new ReportDataSource("Gekko_Administratie_DomainModel_InvoiceLine", invoice.Lines));
    }
}

The code requires some explanation. The constructor should be clear, it receives viewer and data.

The ShowReport method does the real work. The first line loads the report in the viewer. The second line loads the report data. This line is tricky. The name of the ReportDataSource has to match exactly the name of the datasource class used as model. The Invoice class name is Gekko.Administratie.DomainModel.Invoice which gets formatted as Gekko_Administratie_DomainModel_Invoice. This required magic string is not clear from any documentation, it took me quite some time to find out how essential it was.

All these datasource properties in the report definition are confusing. The model of the data is saved in the report definition. Changing the datasource to another “dataset” will also lead to errors at run time. The report will complain about the former datasources. To get rid of the error messages you have to check the report defintion by hand. The report definition file (.rdlc) is plain xml. The last part contains dataset definitions. What helps is just deleting the unused nodes by hand.

Upon rendering a subreport an event is fired. In the third line of ShowReport a handler is attached. This SubReportProcessing method feeds the subreport with data. From the parameters the number of the invoice is read. Which is used to find the corresponding invoice. The datasource for the subreport is set just like the datasource of the main report. Again spelling the name of the reportdatasource right is essential. The data is the Lines property. Which is an IList of InvoiceLines.

Putting it all together

With all pieces in place it’s time to get some results. I have a windows form with a reportviewer on it.

var repo = new InvoiceRepository();
var reporter = new InvoiceReporter(reportViewer1, repo.ListPrintableInvoices());
reporter.ShowReport();

This reads the invoices from the repository and sends them with the reportviewer to the helper class.

There is one more thing to watch. The repository is an nHibernate repository. By default nHibernate lazy loads related objects, like the Contact and the Lines of the Invoice. The contact and the invoicelines will not be read from the database until they are actually used. This default setting has some serious drawbacks.

In the first place the reportviewer‘s datareader does not operate very well (at all ?) with nHibernate’s proxies. In the report all the contact fields will contain error messages. The subreport on the lines will work. But still the lines are not read from the database until rendering the sub-report. So for this lazy loading to work the report has to be run against a dataset with an open dataconnection. That’s bad, I try do do as little as possible, and most likely not presenting a report, with an open connection. A far better scenario would be to fetch all data in one go, close the connection to the database and render the report after that. This can be done by eagerly loading the Contact and Lines properties and disposing of the session before returning the data.

In the nHibernate API the fetch mode can be set on a property level. The code in the repository takes care of fetching all data in one big snapshot.

public IList<Invoice> ListPrintableInvoices()
{
    using (var session = SessionFactory.GetFactory.OpenSession())
    {
        var query = session.CreateCriteria(typeof(Invoice));
        query.AddOrder(Order.Asc("Number"));
        query.Add(Restrictions.Eq("PrintIt", true));
        query.SetFetchMode("Lines", FetchMode.Eager);
        query.SetFetchMode("ForContact", FetchMode.Eager);
        return query.List<Invoice>();
    }
}
 

The repository reads all data from the database and closes the connection. After that the collected data are input to the reportviewer. Which now works completely as hoped for.

I have my report complete with printing and export functionality and am still working with my beloved domain objects.

This way reporting can almost be pure fun.