Peter's Gekko

Reporting against a domain model

2009-07-01T08:44:00Z

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.

A small web design rant: beware of the RADical designer

2009-06-22T10:09:39Z

A web designer is responsible for the look of a web site. She designs how the information is displayed on the pages, what illustrations are used and how the parts look together. Working with Visual Studio the collaboration between developer and designer can be streamlined. What usually works quite well is the designer creating an html page and style sheet with the look of the site. The places with dynamic content are marked as plain div’s, in the first draft usually filled with some dummy content to get a first impression. As a developer I turn this page into the master page substituting the content div’s with content placeholders. The classes in the style sheet are used in all the views and pages and I am freed from worries about the look. A clear separation of concerns.

Over time some adaptations might be necessary, due to content not fitting or specifications changing. This is usually no problem, I get a new css or updated html. Many a good designer does understand asp.net markup, making round tripping even easier. In the process both visual designers are used (by the designer) and mark up is edited (by me). This is no problem as good tools used are two way designers: when you change the look visually the markup changes and when you change the markup the visual appearance changes.

All of this is of course pretty obvious. But recently I had an experience where it did not work. Describing the scenario our designer assured us it was no problem. She (actually he) would make a good design and his tool would provide us with plain html and a decent css stylesheet. The visual appearance, in the browser, was nice and the design was approved. But alas the markup behind was not that nice. The html was over complicated with things like div’s whose only purpose was to wrap up yet another div. The css did contain a lot of classes. Most of them were quite verbose and defined many many style attributes. A later analysis of their usage showed they were not cascading style sheets, many an attribute was repeated, usually with exactly the same value. Trying to change the appearance of the site was hard. We had to wrestle our way through the trees of markup. And trying to change the font of a particular part was a quest through styles. Changing which one(s) would do the trick ?

Going back to the designer did not solve that much, his knowledge of the mark up side of web design was not sufficient for an effective communication. The lessons learned were several. First of all make sure that your designer does not only have good esthetical judgment but can communicate his ideas in a shared language, that of html and css. And when she has a tool which generates that make sure it is a two way tool, so proposals for change can be dealt with.

All reminded me very much of the RAD discussions. With again the same conclusion. RAD on itself smells but a good 2-way visual designer can still be nice. Coming from Delphi I used to believe that kind of tool existed. Having seen the haystacks of code Visual Studio produces led to serious doubt. And having seen what a visual design tool can do has shattered my last hope.

A first glimpse of virtualization in Windows 7

2009-05-20T14:29:00Z

For some time now I’m using a laptop running 64 bits Server 2008 for mobile software development. The main reason for picking that particular OS were the great virtualization possibilities. In a more detailed post I described setting up the machine and working with the diverse network configurations I met on the road. The machine still works great, the only disadvantage is the relatively long time it takes to boot or shutdown.

This time my desktop needed a repave. As everybody seems to be wild about Windows 7 I decided to give that a spin. I can be short on Windows 7 itself. It is really great ! The usual bundle, VS 2008 with MVC and SL, Resharper 4.5, Visual SVN, runs without a glitch. Very smooth, very fast. Just like my server 2008 experiences. Both OS’s share the same kernel and this shows.

Another great thing thing is the overall navigation in Windows 7. The way Windows dock is subtly different but does save a lot of mouse movements. Good in the battle against RSI. And the quality of zooming, most notably in IE8, is terrific. Very good against eye-strain. It will keep an older developer like me up and running. My favorite new feature is the “Close all but this” Aero Shake. Grab a window bar with the mouse and shake it. Hilarious ! Alas, VS doesn’t understand the gesture :(

As I work on a variety of projects I do need several virtual machines. At least one for every flavor of database server. This drove me to Server 2008 64 bits with Hyper V. Also in Windows 7 virtualization is important. It’s not as far as Server 2008 yet but on the longer run it is going to go much further. Virtual XP mode is a good demonstration of that. All is very very beta, not all online documentation is complete. An overview of my experiments:

Install Virtual PC beta
Reboot
Install Virtual XP. This installs a complete configured virtual XP sp3
Start Virtual XP, a complete XP desktop shows up. With shared USB drives and full network connectivity to the host, the LAN and the internet
Install RAIL in virtual XP
Reboot Virtual XP

The Virtual PC manager looks familiar

As an experiment I tried hosting an existing Hyper-V hosted virtual machine. The vhd is accepted the machine did boot but the screen and all connections remained blank. No wonder, Hyper-V is based on a hypervisor which lives between the hardware and the OS itself. The integration services of the virtual machine are based on this hypervisor. Windows 7 does not have a (compatible) hypervisor yet. But Virtual PC for W7 does require a processor with enabled hardware virtualization support. And the future will bring more with names like MED-V, read more here.

One of the things W7 already does bring in the beta are virtual applications. The application itself will actually run in a virtual environment but presents itself as an application on the host OS. W7 has virtual XP applications. With RAIL installed shortcuts in the all users folder of XP are published on the host OS. I tried this with the worst application I could find. It is my bookkeeping program, an old MS-DOS Clipper application. Clipper applications are horrible. They think they own the whole machine and they are throwing endless streams of BIOS based IO requests. As a result a lot of keystrokes are not recognized. As the application is polling just one executable can drive the CPU load of any processor to 100%. The only good about them is that they do are not multi threaded, you will lose only one core running them. These monsters do work under XP, they don’t under Vista.

I set up a shortcut to the XP command prompt and one to the Clipper app

Both appear on the W7 start menu

And now I do have an XP application which (visually) run as a W7 app.

The only thing I do not like in W7 (so far..) is the default desktop. As a biologist and aquarium keeper I recognize the fish as a male of Betta splendens, the Siamese fighting fish. They are very aggressive, males will fight each other until one of them dies. Even when the loser gets the opportunity to escape they usually will not survive. A common sight in aquarium shops are specimens who are pale, wrinkled and hardly moving. Not a very good metaphor for an OS.

Wikipedia has a nice quote why it could make sense: “The Siamese fighting fish has been used as the default background in the first official beta version of the Windows 7 operating system, in an apparent reference to the name "betta". This could also be in reference to the fish's ability to survive in smaller, less advanced aquariums, much like Windows 7 is supposedly designed to work better on lower end computers.”

Could be, but my favorite would be a kwikwi then. Which will survive anything, accepts everything as food, can walk over land in case the puddle falls dry, and is a very gentle and social creature. It is also considered a very tasty consumption fish in South America.

</Small slightly off-topic rant>

When starting the Clipper app it does work functionally, all keystrokes are recognized and the app does not crash. But it’s not usable, there are long lags between a key press and a program response. (It does work smooth inside virtual XP). But the technique itself seems stable.

The idea of virtual applications does work. Running normal XP apps, like IE 6 or MSWord 97 is smooth. But why is all of this important to us as software developers ?

Get rid of legacy apps and legacy parts/ features of the OS. In case you need them, run it in Virtual XP. Give us a clean and rich environment.
The end of the OS as we know it. A lot of old Windows apps talk to each other. Using OS based protocols like DDE and COM. Or one app which fires of another app. A virtual running app cannot rely on other apps or specific OS features being available. All communication has to be done using formalized channels like WCF or REST

Well, so far I have scratched the surface. I hope it is enough to get you interested in upcoming virtualization features.

Keeping a long running Silverlight application alive under forms authentication

2009-04-16T20:27:00Z

This is the scenario : we have a Silverlight application (SL app) which run is running unattended on a big screen in an office. It displays the actual positions of objects on a map. Once every 10 minutes the app queries the hosting web server for position information. The information is not public, it is using asp.net forms authentication to guard it against unauthorized eyes.

To get this to work as intended required some special attention. In this post I will give an overview. The site is using ajax. Also Silverlight is doing a lot of async communication. The combination of async (partial) postback and forms authentication has some quircks on itself, I wrote a little post on that short ago. But as said, there are more quircks.

The server

The user sessions are running a long long time. The risk is that within a session IIS will recycle the underlying web application. When that happens the session state will be lost because, by default, session state is stored inproc. The first step is to store the sesssion state in sql server. This will keep the session information alive when the application is recycled. Setting up sql server is no big deal, this is a good overview. The thing to watch is that now everything you store in the session has to be explicitly serializable. Which usually boils down to setting the serializable attribute and adding default constructors.

The service

A Silverlight application gets it’s data from a service. Our basic service queries a repository to get specific data.

public class KaartData
{
    public static List<Kaart> Kaarten(KaartSoort soort, KaartPositie topLeft, KaartPositie bottomRight)
    {
        KaartRepository repository = RepositoryFactory.KaartRepository();
        return repository.ListKaarten(soort, topLeft, bottomRight);
    }
}

This service is published in a WCF service. A SL app can easily communicate over WCF with a service which is hosted in the same web application as the SL-app itself is running in. It should be possible to host the service somewhere else but that will introduce a large amount of security settings you will have to solve.

In VS there is a template for such a service.

The result is pretty straightforward

[ServiceContract(Namespace = "Datema")]
[AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
public class KaartService
{
    [OperationContract]
    public List<Kaart> Kaarten(KaartSoort soort, KaartPositie topLeft, KaartPositie bottomRight)
    {
        return Datema.DatemaDirect.KaartServices.KaartData.Kaarten(soort, topLeft, bottomRight);
    }
}

As the service is embedded in the website it is guarded by forms authentication. That’s as intended, we don’t want unauthorized people or software to consume our service. But that will hit back, as we will see later.

The Silverlight Application

The application itself is built around Deep Earth. This is an open source project which combines the power of Silverlight with that of a geo image servers like virtual Earth, Yahoo maps, Open Street Maps and many others.

The xaml markup wraps up a deepearth map

<UserControl x:Class="ChartMap.Page"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:DeepEarth="clr-namespace:DeepEarth;assembly=DeepEarth" >
 
    <Grid x:Name="LayoutRoot">
        <DeepEarth:Map x:Name="Map">
        </DeepEarth:Map>
        <StackPanel HorizontalAlignment="Left" VerticalAlignment="Top"  Margin="10" >
            <Slider x:Name="SliderZoom" Orientation="Vertical" Value="1" Height="200" Minimum="1" Maximum="20"  ValueChanged="Slider_ValueChanged"></Slider>
        </StackPanel>
    </Grid>
</UserControl>

A SL-app is living in the browser. The code behind does the registration.

private readonly GeometryLayer mapLayer;
 
public Page()
{
    InitializeComponent();
    if (Map.BaseLayer == null)
    {
        Map.BaseLayer = new TileLayer(MapMode.Aerial);
    }
 
    Loaded += ((theMap, args) => HtmlPage.RegisterScriptableObject("ChartMap", this));
    mapLayer = new GeometryLayer(Map);
 
}

The constructor also initializes a basic geometrylayer. That’s an aerial view of the world, to our app it’s just a background. A background you can zoom into in great detail. Check the deepearth site for more on that.

The constructor registers the application (this) on the HtmlPage under the name ChartMap. We’ll meet that later on in the javascript.

The application exposes methods to JavaScript by setting the Scriptable attribute

[ScriptableMember]
public void ShowKaarten(KaartSoort vanSoort)
{
    var tl = new KaartPositie();
    tl.Hoogte = Map.GeoBounds.Bottom;
    tl.Lengte = Map.GeoBounds.Left;
    var br = new KaartPositie();
    br.Hoogte = Map.GeoBounds.Top;
    br.Lengte = Map.GeoBounds.Right;
    var svcProxy = new KaartServiceProvider();
    svcProxy.GetKaarten(vanSoort, tl, br, DrawKaarten);
}

This method needs the WCF service to get the data.

Consuming the WCF service in Silverlight

The first step is to add a service reference. For this to work you have to disable the forms authentication, else VS cannot get to the service to generate a proxy. The generated proxy, KaartServiceClient, can only be invoked asynchronous.

To encapsulate the specific initialization and async coding aspects of the the proxy I have created a helper class

internal class KaartServiceProvider
{
    private readonly KaartServiceClient svc;
 
    internal KaartServiceProvider()
    {
        var addres = new Uri(Application.Current.Host.Source, "/Services/KaartService.svc");
        svc = new KaartServiceClient("BasicHttpBinding_KaartService", new EndpointAddress(addres));
    }
 
    internal void GetKaarten(KaartSoort soort, KaartPositie tl, KaartPositie br,
                           Action<ObservableCollection<Kaart>> kaarten)
    {
        svc.OpenCompleted += ((sender, e) => svc.KaartenAsync(soort, tl, br));
        svc.KaartenCompleted += ((sender, e) => kaarten(e.Result));
        svc.OpenAsync();
    }
}

It wraps the proxy svc. In the constructor the proper address of the service is assembled. As the service is hosted by the same application as the Silverlight app I can use Application.Current.Host.Source to get the right uri.

The GetKaarten method is doing the work. It is passed the parameters to the service and also passes kaarten a callback method to catch the result of the service invocation. The service is explicitly opened, also this has to be done async. OpenCompleted will start the real work by firing KaarternAsync. When that completes the callback method will update the map with the fresh data.

[ScriptableMember]
public void ShowKaarten(KaartSoort vanSoort)
{
    ....
    var svcProxy = new KaartServiceProvider();
    svcProxy.GetKaarten(vanSoort, tl, br, DrawKaarten);
}
private void DrawKaarten(ObservableCollection<Kaart> kaarten)
{
    mapLayer.Clear();
    foreach (var kaart in kaarten)
        mapLayer.Add(new VisualKaart(kaart));
}
 

The Silverlight app on a web page

The Silverlight app is running in the browser. So the way to program it is through JavaScript. It takes a little puzzling to find the object to talk to. Remember the silverlight app registered itself as ChartMap. To fire the scriptable webmethod you need the Content.ChartMap property of the SL-object.

A silverlight application can be used in several styles of web apps. A classical asp.net works well, an MVC app works even better. The latter is easier because the views in MVC are really client side views, the same enviroment the SL-app is living in. Classical Asp.net is more focused on server side code.

It will look like this in an MVC view. The SL- app is between the <object> tags and has id Wereld. The button’s onclick event fires the SL method.

<select id="kaartSoort">
    <option value="0">ENC</option>
    <option value="1">ARCS</option>
</select>
<input type="button" value="Toon kaarten" onclick="Wereld.Content.ChartMap.ShowKaarten(kaartSoort.value)" />
<object data="data:application/x-silverlight-2," type="application/x-silverlight-2"
    width="100%" height="100%" id="Wereld">
    <param name="source" value="/ClientBin/ChartMap.xap" />
    <param name="onerror" value="onSilverlightError" />
    <param name="background" value="white" />
    <param name="minRuntimeVersion" value="2.0.31005.0" />
    <param name="autoUpgrade" value="true" />
    <a href="http://go.microsoft.com/fwlink/?LinkID=124807" style="text-decoration: none;">
        <img src="http://go.microsoft.com/fwlink/?LinkId=108181" alt="Get Microsoft Silverlight"
            style="border-style: none" />
    </a>
</object>

To keep the map up to date the method has to be fired over and over again, controlled by some kind of timer. Javascript has no real timers but using the setTimeOut method you can (recursively) call a method after an interval. In this example the function showMap updates the map and calls itself after 600 seconds.

var fleetId = 0;
var logoDisplayed = false;
var map;
 
function showMap() {
    map = document.getElementById('ctl00_ContentPlaceHolder1_TrackingMap').Content.TrackingMap;
    map.ShowFleetTrack(fleetId);
    // Refresh map every 10 minutes
    setTimeout("showMap()", 600000);
}

This script is living on a classical asp.net page. Notice the ugly long id you need to get to the SL-app. I have moved all var’s out of the method to the page. Over time this code will build quite a call stack, not need for “invocation specific instance data”.

What’s wrong with this code ?

At first sight this code looks alright. But nevertheless it will hit an exception after a certain amount of time. Usually a quite cryptic Silverlight error. It took some puzzling to find out what went wrong.

The application stays on one and the same page. The script on the page hits the embedded service once every 10 minutes. The service is protected by forms authentication. On every roundtrip the authentication cookie is checked. But what does not happen is updating the timeout of forms authentication. When the user hits code behind a web page the session timeout of forms-authentication is reset. When the user’s page hits the embedded service this time-out is not reset. I’m not sure whether this is a bug or a feature but it is by no means the behavior you would expect.

To prevent the service from timing out the script has to hit some server side code behind the page. As a target I add a dummy webmethod to the page

public partial class FleetMap : System.Web.UI.Page
{
    [WebMethod]
    public static void HartBeat()
    {
        // No need to do anything, this is just a hartbeat from JavaScript to tell the page is still alive
        // This hartbeat prevents a time out of the authentication cookie
    }

A webmethod, part of ASP.net ajax, can be called directly from script.

function showMap() {
 
    PageMethods.HartBeat();
    map = document.getElementById('ctl00_ContentPlaceHolder1_TrackingMap').Content.TrackingMap;
    map.ShowFleetTrack(fleetId);
    // Refresh map every 10 minutes
    setTimeout("showMap()", 600000);
}
 

In the loop the hartbeat tickles the server to notify the page is still alive. After which the SL-app can start firing its WCF requests.

I am not checking on exceptions here. In case the session has timed out issuing a HartBeat will redirect the user to the login page. As intended.

To conclude?

And now the app works as intended. Looking back it was a great experience combining all these new api’s. Communication between them works pretty good. Once you know how :) The bad guy was imho forms authentication. Which dates from a time when there was no such thing as partial or async postback. In a previous post I talked about the problems it has with ajax. Silverlight, another async poster, apparently has its own problems.

Every picture tells a story

2009-04-07T12:24:00Z

As you may have noticed we have some trouble with the images on the codebetter site. Despite all good care the majority got lost when upgrading to a new server. Too bad. Imho a picture tells more than a thousand words. At this moment my blog looks a little like a scrapbook where the pictures have been torn out. Right now I’m digging through all my private backups to dig up what I can find. And will restore whatever I can. But no more lamenting. This post is to celebrate the joy of pictures.

Many a post is an announcement of some speaking engagement. Complete with a description of the material covered. This post is looking back on just a presentation. I will not cover any depth of content, I’ll just try to show watching and participating in a presentation is fun.

Sander Hoogendoorn spoke for the Dutch user group SDN. He’s always pleasantly opinioned on matters. You don’t have to agree on everything but it does tickle your thought. The presentation was titled “Surviving the hypes”. Let’s get started

Ok, everybody is awake now. All the favorite hobby horses, including nHibernate and mvc, pass the revue. Like a DJ he’s navigating through the slides and talk

But it’s not just opinions on what’s wrong with frameworks, included is a lesson how to isolate your app from the framework using design patterns and techniques like the layer supertype, facade and DI.

And if everything else fails there’s the new magic of extension methods.

Great show. In case you got interested in the talk itself, here’s some more But better visit your user group and be part of a live show. I hope to have given you some inspiration.

DDD and repositories. Without nHibernate but with lazy loading

2009-03-17T12:00:13Z

Domain driven design has become a very prominent way to develop software. A central domain model is used by all participants. To the end user it is a representation of the real world. To the coder the model is a class model, working with the real domain world boils down to instantiating objects from these classes. In meetings we find ourselves often discussing a Visual Studio class diagram. Nothing fancy, but it works quite well. The domain user recognizes her entities, their data and behavior, the developer recognizes his classes, properties and methods.

In DDD these domain objects interact with the database through repositories. The methods of a repository return (sets of) domain objects as read from the database or accept domain objects which will be persisted to the database. nHibernate is a wonderful tool to build these repositories. All you have to do is define a mapping between domain classes and databases tables and nHibernate will take care of the tedious sql stuff. As a bonus you get a nice API for querying.

But there are reasons not to use nHibernate.

Learning curve. In some teams the jump from sql scattered between the tags of a web page, stored procedures and wherever else to an O/R mapper is to big. Getting all database access together in one assembly is a big step forward on itself.
Database server specific functionality. In a current project we are using SQL 2008 because we need the specific geographical functionality. At the time we started the project SQL 2008 was not feature stable yet, the nHibernate support was not quite there either and the specific geographical queries would require a lot of sql passthrough. Combined with point 1 it was obvious we were going to do the sql ourselves.
Restricted permissions on the application hoster. To do its magic nHibernate uses a lot of reflection. Reflection requires more priviliges than the partial trust many a shared hoster does offer. I tried to get nHibernate to work under partial trust but did not succeed. Perhaps it is possible with nHibernate 2.0

But not using nHibernate does not mean you cannot work in DDD style. Using the repository pattern is still the way to go. In the remainder of this post I will briefly demonstrate that and will focus on lazy loading. This is a programming aspect of domain objects which makes life for you as a coder so much easier and your code such a lot clearer and easier to maintain. Given the domain model of last figure, it is clear to code like this

foreach (var orderLine in myOrder.Lines)
{
    myTotal += orderLine.Article.Price;
}

When you need to think about the database stuff behind this things get complicated. The order has to be read from an orders table. The orderdetails are read from another table and for every orderline a row has to be read from the articles table. The only way to get this working is by implementing lazy loading. That is read the data from the database when it is requested, not any earlier than that. With nHibernate you get lazy loading for free. We had to do it ourselves. The solution presented here works well for us. But don’t take it for granted, we have to jump through some hoops. Feel free to comment. Anything to simplify the matter will improve our code.

The domain layer itself should suffer from persitance ignorance. That is it should be completely unknown to the domain object itself how and where it it persisted. The concession I have to make is that the domain object cannot ignore the fact that it is persited in some way and that it does have a certain price to retrieve data. To express this I define delegates with the domain classes , that is the signature of methods which will actually retrieve a domain object.

Take the article class

public class Article
{
    public int Id { get; private set; }
    public string Name { get; private set; }
    public decimal Price { get; private set; }
}
 
public delegate Article OnRequestArticle(int id);

This delegate is used by the order line class to lazyload an article

public class OrderLine
{
    public OrderLine(int articleId, int numberOrdered)
    {
        this.articleId = articleId;
        NumberOrdered = numberOrdered;
    }
 
    public int NumberOrdered { get; set; }
    public static OnRequestArticle RequestArticle { get; set; }
    private int articleId;
    private Article article;
    public Article Article
    {
        get
        {
            if (article == null)
                if (RequestArticle != null)
                    article = RequestArticle(articleId);
            return article;
        }
    }
}

The article of the orderline is instantiated as a null object. The first time the article is requested the static delegate property is fired to actually retrieve the article. To do that I need the article id. Which is passed in the constructor but not exposed by the domain object. In case you need it it is requested as orderLine.Article.ID

Likewise the orderlines define a delegate, this one expresses that orderlines come in a set, all belonging to the same order.

public delegate List<OrderLine> OnRequestOrderLines(Order forOrder);

This delegate is used in the Order domain class

public static OnRequestOrderLines RequestOrderLines { get; set; }
private List<OrderLine> lines;
public List<OrderLine> Lines
{
    get
    {
        if (lines == null)
            if (RequestOrderLines != null)
                lines = RequestOrderLines(this);
        return lines;
    }
}

Using these static delegates we can have lazy loading. For the delegates to work they have to be wired up. Before doing that we have to take a look at implementing the repositories.

This demo project has three repositories: Orders, Articles and Customers. I will not dive into the details of the implementation, you can find those in a previous post. What is important for now are the signatures of the repository methods. This is the OrderRepository.

public class OrderRepository
{
    public Order GetOrder(int orderId)
    {}
 
    public List<Order> ListOrders()
    {}
 
    public List<OrderLine> GetOrderLines(Order forOrder)
    {}
}

The last method is quite interesting as it’s signature matches the OnRequestOrderLines delegate. It is the one which has to be wired to the Order’s RequestOrderLines property.

The repository has a helper class Lazyloaders which exposes all lazy loading methods as static methods.

public class LazyLoaders
{
    public static List<OrderLine> RequestOderLines(Order order)
    {
        var orderRepository = new OrderRepository();
        return orderRepository.GetOrderLines(order);
    }
    public static Article RequestArticle(int articleId)
    {
        var articleRepository = new ArticleRepository();
        return articleRepository.GetArticle(articleId);
    }
}

A repository object has very real instance members such as the connection to the database. It is not desired to have such a connection as a static member of the repository class. So it’s not possible to declare these static lazyloader members as members of the repository. That’s the main reason for the helper class.

The lazyloaders have to be static as they are wired to a static property of the domain objects. This wiring up is done in the static constructor of the repository. A static constructor is fired only once, at the moment in your code the class is actually used the first time.

public class OrderRepository
{
    static OrderRepository()
    {
        Order.RequestOrderLines = LazyLoaders.RequestOrderLines;
        OrderLine.RequestArticle = LazyLoaders.RequestArticle;
    }
 
    public Order GetOrder(int orderId)
    {}
 
    public List<Order> ListOrders()
    {}
 
    public List<OrderLine> GetOrderLines(Order forOrder)
    {}
}

In the static constructor of the repository the domain class is given an implementation of the lazyloaders. And now I am there and do have lazy loading for my orders and orderlines.

It works. There are some things I don’t quite like

The domain objects have to expose public delegate properties. These are needed by the repositories but for anything else they can be confusing.
The orderrepository has to expose the GetOrderLines method. This method makes no sense to any code outside the repositories. There are no orderlines without an order. The only way to access orderlines should be through their order. The lazy loading will return the orderlines. Lazy loading does need this method. Nobody else does. Any suggestion to hide this method is appreciated.
I have to keep the article ID in the orderline. It is hidden and only required for the lazy loading. But I don’t like having an article Id and an Article in my orderline object.

But as a whole this solution is quite satisfying for us. You might wonder whether it performs well. When the simple loop we started with executes a lot is happening behind the scenes.

foreach (var orderLine in myOrder.Lines)
{
    myTotal += orderLine.Article.Price;
}

For every iteration in the loop an article repository is created and a database query is performed. When it comes to the actual performance the only thing which really counts is database access. Don’t worry about instantiating POCO’s, do worry about complex sql. That’ s where the real bottleneck is. In this case I’m firing a series of short and simple sql statements. The ado.net connection pooling will ensure the multiple subsequent connections to the DB will be fast. And in real life the code presented here works fast and smooth.

The real plus lies in the real part of the application, where the code does things all kind of things with the domain objects. And never, ever has to worry when or how the data is read into the domain object.

I still do miss nHibernate. Writing all the sql, and especially maintaining it, is tedious and can be pretty boring. Except for the geographical stuff. But to all other parts of the application it is transparent whether the repositories are hand work or implemented by an O-R mapper.

I do hope to have made clear that you main goal should be coding against a domain model, and not using an O-R mapper. And I do hope you have suggestions to make my life even easier.

The return of CopySourceAsHtml

2009-02-26T09:55:09Z

In a recent post I did a walk through of using the Google syntax highlighter. In the end I got it to work. As also the comments pointed out there are two major drawbacks.

The syntax highligher requires some scripts. These are installed on the codebetter site but a post read from an RSS feed will not be able to reach the scripts. The code will be an unreadable jumble.
To work with html, xml or anything else with angle brackets requires using textarea tags. Many a blog post editor (but not all) will encode the contents of the text enclosed. (> is translated into >). The result will be that the code is also jumbled, even when the scripts are reachable.

The comments also pointed to an old friend, CopySourceAsHtml. I had lost it when moving to VS 2008. The comments pointed to a recipe to get it working in VS 2008. But that’s no longer needed, a VS 2008 version is now available.

The good thing with CopySourceAsHtml is that it works with any code file in VS, the Copy As Html item is always in the main edit menu.

For plain code

namespace Datema.ENCtracking.Repositories.Helpers
{
    public class RepositoryBase
    {
        public RepositoryBase(string connectionString)
        {
            connection.ConnectionString = connectionString;
        }
 
 For Html

<asp:Content ID="Content2" ContentPlaceHolderID="ContentPlaceHolder1" runat="server">
    <style type="text/css">
        html,body, form
        {
            height: 100%;
        }
    </style>
 
    <script type="text/javascript">
        function pageLoad() {
            window.onerror = tellerror;
        }
 
        function tellerror(msg, url, linenumber) {
            if (msg.toString().indexOf("Image") >= 0 && msg.toString().indexOf("4001") >= 0) {
            return true;
            }
            else {
                alert('Error message= ' + msg + '\nURL= ' + url + '\nLineNumber= ' + linenumber)
                return true;
            }
        }

For Xaml

<Grid x:Name="LayoutRoot" Background="White">
    <DeepEarth:Map x:Name="map" Margin="0,0,0,0" BorderThickness="10">
        <DeepControls:CoordControl></DeepControls:CoordControl>
    </DeepEarth:Map>
    <StackPanel HorizontalAlignment="Left" VerticalAlignment="Top" Margin="10" >
        <Button x:Name="ButtonPortLabels" Content="Ports" Click="ButtonPortLabels_Click" FontSize="7" Opacity="0.5"/>
        <Slider x:Name="SliderZoom" Orientation="Vertical" Value="1" Height="200" Minimum="1" Maximum="20" ValueChanged="Slider_ValueChanged"></Slider>
    </StackPanel>

All of these snippets where a matter of select, copy, paste. A thing to watch is the font size. Bu default CSAH takes the size of your editor. In my case the result will look far to big. Selecting a different size is no problem:

CSAH will remember this setting.

No hassles and it looks good on the site and in a feedreader.

Welcome back !

Paging in a sql result set

2009-02-26T09:28:32Z

This post is based on a post by fellow CB blogger Dave Hayden. It deals with paging through a set of sql server data. Dave has a very clear and elegant solution but it did take some puzzling to find out why things have to be done that way. Dave’s solution steered towards a sproc. Trying to stay away from that I want to present a dynamic sql version of the same idea.

Since the 2005 version of MS SQL server has the ROW_NUMBER function. This function returns the sequence number of the result set rows. Like this select statement.

SELECT Id, Name, ROW_NUMBER() OVER (ORDER BY Name) AS Row FROM Fleet

The OVER part determines the sort order of the result set.

This row number is an ideal base for retrieving data in pages. With a page size of 20 the first page will contain row numbers 1 to 21, the second 21 to 40, etc. Alas you cannot use the function result directly in the where clause. To retrieve the first page this sql will not work.

SELECT Id, Name, ROW_NUMBER() OVER (ORDER BY Name) AS Row FROM Fleet WHERE ROW < 21 

To get around this you need an outer select to wrap up. Like this:

SELECT Id, Name FROM 
(SELECT Id, Name, ROW_NUMBER() OVER (ORDER BY Name) AS Row FROM Fleet) AS tmp 
WHERE ROW < 21 

There is a pattern in this

SELECT  MyCols FROM
(SELECT MyCols, ROW_NUMBER() OVER (ORDER BY MyOrder) AS Row FROM MyView) AS tmp
WHERE ROW < MaxRow

The values for the example query I started with

MyCols=”Id, Name”

MyView=”Fleet”

MyOrder=”Name”

In a more complex scenario the data will be a view on several tables resulting in one result set. Here the list of columns for the result set will not match the list of columns in the view.

Take this query.

SELECT  Name,Id, City FROM 
(SELECT Person.Name,Person.Id, City.City , ROW_NUMBER() OVER (ORDER BY Name) AS Row FROM Persons INNER JOIN City On Person.CityId=City.ID) AS tmp  
WHERE ROW < 21

The pattern now evolves to

SELECT  MyCols FROM 
(SELECT MyViewCols, ROW_NUMBER() OVER (ORDER BY MyOrder) AS Row FROM MyView) AS tmp  
WHERE ROW < MaxRow

The values for the last query

MyCols=”Name, Id, City”

MyViewCols=”Person.Name,Person.Id, City.City ”

MyView=”Persons INNER JOIN City On Person.CityId=City.ID”

MyOrder=”Name”

To complete the pattern I have to fully parameterize the row numbers. Here I also limit the inner query with a SELECT TOP, no need to retrieve more rows than maxrow.

SELECT MyCols FROM 
(SELECT TOP MaxRow ROW_NUMBER OVER (ORDER BY  MyOrder ) AS Row, MyViewCols FROM MyView)  AS Tmp 
WHERE Row > @MinRow AND Row <= @MaxRow

It is cumbersome to assemble this query over and over again. Having to do all sql myself (more on that in a later post) I have built a small C# function which will assemble the paging query from the fragments passed in. It uses the pattern described, builds a sqlCommand and is used like this.

const string columns = "Code, ExpireDate, Description";
const string view = "Permit INNER JOIN ProductCell ON Permit.Code = ProductCell.Code WHERE Permit.LicenceId=@LicenceId";
const string orderBy = "Permit.Code";
const string viewColumns = "Permit.Code, ExpireDate, Description";
var cmd = BuildPagedSelectCommand(pageNo, columns, view, orderBy, viewColumns, pageSize);
cmd.Parameters.AddWithValue("@LicenceId", licenceId);

The function itself is pretty straightforward

protected SqlCommand BuildPagedSelectCommand(int pageNumber, string columnList, string selectFrom, string orderBy, string columnsAs, int pageSize)
{
    var minRow = (pageNumber - 1) * pageSize;
    var maxRow = minRow + pageSize;
    var cmd = new SqlCommand(string.Format("SELECT {0} FROM (SELECT TOP {1} ROW_NUMBER() OVER (ORDER BY {2}) AS Row,{3} FROM {4}) AS tmp WHERE Row > @MinRow AND Row <= @MaxRow",
                                           columnList, maxRow, orderBy, columnsAs, selectFrom), connection);
    cmd.Parameters.AddWithValue("@MinRow", minRow);
    cmd.Parameters.AddWithValue("@MaxRow", maxRow);
    return cmd;
}

All it does is calculate the rownumbers, assemble the sql statement and create the sql command to return.

For the simpler cases where the result columns match the underlying view columns I have created an overload.

protected SqlCommand BuildPagedSelectCommand(int pageNumber, string columnList, string selectFrom, string orderBy, int pageSize)
{
    return BuildPagedSelectCommand(pageNumber, columnList, selectFrom, orderBy, columnList, pageSize);
}

It uses the original overload using the columnlist twice.

Paging data is not that complicated but the syntax of the query required is somewhat confusing. I hope this example helps in clarifying it.

Formatting source code in a blog post (revisited)

2009-02-24T08:16:00Z

There are a couple of posts I have to write. But before doing that I need to reinvestigate the way to format source code. The Codebetter site supports the Google syntax highlighter. Which works great for C# code but up till now I havn’t had any luck with XML of HTML. This post was started as a public experiment to get that working. In the process I have posted it again and again to see what it looks like. Now things are straightened out and the cheat-sheet remains.

To use Syntax highlighter you needs a blogging tool which supports direct editing of the underlying HTML. As a non native speaker I also need a good spelling checker. Both are combined in LiveWriter,

Formatting some C#

Select the source in Visual studio and copy it to the clipboard
Paste the code into notepad. This will paste the raw text only and remove any formatting
Copy the code from notepad to the clipboard
Go to HTML view
Paste the code
Enclose it in a pair of pre tags

<pre class="c-sharp" name="code">

public Term GetOrAddTerm(string word, Language language)
{
    Term result = GetTerm(word, language);
    if (result == null)
    {
        result = new Term();
        result.Word = word;
        result.Language = language;
        Save(result);
    }
    return result;
}

</pre>

And this will be the result.

public Term GetOrAddTerm(string word, Language language)
{
    Term result = GetTerm(word, language);
    if (result == null)
    {
        result = new Term();
        result.Word = word;
        result.Language = language;
        Save(result);
    }
    return result;
}

That’ no big deal. But for HTML or XML it is harder. When pasting the code in HTML view the code itself will turn into markup of the page. Not the intention. To solve this use the textarea tag instead of the pre tag.

The html markup of the post will look like this.

<textarea class=”html” name=”code”>

<table>
    <%
        foreach (var crumb in Model.BreadCrumbs)
        {%>
    <tr>
        <td>
            <%= Html.ActionLink(crumb.Naam, crumb.ID.ToString())%>
        </td>
    </tr>
    <%
        } %>
    <tr>
        <td>
            <%= Model.ArtikelGroep.Naam %>
        </td>
    </tr>
    <tr>
        <td>
        </td>
    </tr>
</table>
</textarea>

This is pretty weird. Looks like markup, but it is no markup as it is enclosed between the <textarea> tags. Some pieces of software will trip over this. Like the post editor, which might change the html into escaped html (&lt). But on the CB site the result looks just great.

In the end it’s quite simple. Having this settled I can start working on the real posts. Stay tuned.

Firefox and the 100% DIV revisited

2009-01-27T13:13:00Z

One of the best thing about blogging is that it is a two way thing. Responses help me to find directions to solve the post's problem. In my last post I discussed a workaround for a problem we had with Firefox. The many constructive comments gave me more insight, leading to a far better solution.

The problem was a page which is supposed to display a Silverlight control which fills a browser window

<ajaxToolkit:ToolkitScriptManager runat="Server" ID="ScriptManager1" EnablePageMethods="true" />

It looks great in IE but in Firefox the page is completely blank. This has to with the way IE and FIrefox calculate the available width. IE takes the browser windows' width. Which is, in this scenario, the intended value. Firefox considers the width not set so it is 0. As James says it "both implementations are idiotic"

There are several work around's. A post by Giorgetti Alessandro summarizes all of them. I did some further investigations and found limitations and gotcha's on all three of them.

Use an absolute size instead of a percentage. I discussed that in my previous post already.
Add a position:fixed attribute to the style of the containing div. This does have a lot of drawbacks. Googling around you will find a lot of them. Besides upsetting a couple of browsers it also has a very bad influence on the content of the div. Our Silverlight control has the BackColor and Windowless attributes set. With these values the control works well with ajax popups like the calendar Extender. Setting the position:fixed attribute hides all of the popups. So that option is a no go.
Set the height of all main containers on the page to 100%. This is a suggestion which does work; but only when applied thoroughly.

To display the page correctly requires the following addition to the markup.

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title></title>
    <style type="text/css">
    html,body, form
    {
        height: 100%;
    }
    </style>
</head>

<ajaxToolkit:ToolkitScriptManager runat="Server" ID="ScriptManager1" EnablePageMethods="true" />

Adding the style to the page does the trick. Now the page displays well in IE and in Firefox.

But when you are using a masterpage or have nested containers things get more elaborate. Googling on Firefox Masterpage 100% will results in loads and load of similar frustrations. For the trick to work it is not enough to just add the style to the masterpage. You have to set the width and height of all containers around the control. Forget one and the control will still not show.

Thanks everybody for helping.

Silverlight, FireFox and 100%

2008-12-18T14:07:59Z

In my last post I mentioned something nice about FireFox. In this post I'll talk something not that nice about FireFox and the way we, more or less, worked around it.

A lot of people complain about Silverlight not working in Firefox. Including myself. Our DeepEarth page looks great in IE or Safari but in Firefox there is nothing to be seen at all. Not even an error message. There is quite a discussion on Silverlight and Firefox over here which branches in many directions. Thanks to Willem who spotted the one comment by Makkros which was the key to the solution.

The problem with Silverlight in Firefox has all to do with sizing. Take this snippet of the webpage

<asp:Silverlight ID="TrackingMap" runat="server" Source="~/ClientBin/TrackingMap.xap" />

</div>

It's a silverlight control enclosed in a div. As the control displays a map the best thing would be to claim as much space as available

<asp:Silverlight ID="TrackingMap" runat="server" Width="100%" Height="90%" Source="~/ClientBin/TrackingMap.xap" />

</div>

This works in IE and Safari (and maybe more). When the browser window is resized the control takes up all space available with the div wrapping around.

Alas things work different in Firefox. Googling on Firefox DIV 100% results in many many hits. Firefox first sizes the DIV and then it's up to the content to use it. Resulting in content sized 0 by 0. Which comes pretty close to invisible.

So you have to set the size of the control in absolute measures to see it. And resize it later on from script.

<asp:Silverlight ID="TrackingMap" runat="server" Width="500px" Height="300px" Source="~/ClientBin/TrackingMap.xap" />

</div>

Alas this does not solve things at all. The initial size is OK, but resizing the control will not resize the wrapping DIV. Sizing the control over it's initial size will crop a part, sizing it under it's original size will result in an undesired border. It requires a full page refresh to get things into proportion again.

In the end I came up with this solution. Not that elegant, but it works. Any suggestions for something better are more than welcome.

In the page load of the code behind the control is given it's initial size. A number of pixels for FF, a percentage for the rest.

protected void Page_Load(object sender, EventArgs e)
{

    if (! IsPostBack)
    {      

        if (Request.Browser.Browser.ToLower() == "firefox")
        {
            TrackingMap.Width = new Unit(mapWidth, UnitType.Pixel);
            TrackingMap.Height = new Unit(mapHeight, UnitType.Pixel);
            FireFoxWidth.Text = mapWidth.ToString();
            FireFoxHeight.Text = mapHeight.ToString();
            FireFoxSupport.Visible = true;
        }
        else
        {
            TrackingMap.Width = new Unit(100, UnitType.Percentage);
            TrackingMap.Height = new Unit(88, UnitType.Percentage);
        }
        
    }

}

The number of pixels for the initial size is hard to guess. The browsercapabilties always suggest a 640*480 screen. Not that useful; I have to take arbitrary values. To house it I created two properties which store the values in the session

private const string ffMapWidth = "FFmapWidth";
private int mapWidth
{
    get
    {
        var o = Context.Session[ffMapWidth];
        if (o == null)
            return 1024;
        return int.Parse(o.ToString());
    }
    set
    {
        Context.Session[ffMapWidth] = value;
    }
}

private const string ffMapHeight = "FFmapHeight";
private int mapHeight
{
    get
    {
        var o = Context.Session[ffMapHeight];
        if (o == null)
            return 768;
        return int.Parse(o.ToString());
    }
    set
    {
        Context.Session[ffMapHeight] = value;
    }
}

It's up to the user to pick a new size for the control, that's what the FireFoxSupport control is for. That has two textboxes to enter the size and a button to perform the actual resize.

protected void resizeMap(object sender, EventArgs e)
{
    try
    {
        mapWidth = int.Parse(FireFoxWidth.Text);
        mapHeight = int.Parse(FireFoxHeight.Text);
        Response.Redirect(Request.Url.ToString(), true);
    }
    catch
    {
        FireFoxWidth.Text = mapWidth.ToString();
        FireFoxHeight.Text = mapHeight.ToString();
    }
}

The new desired size is read from the textboxes and stored in the session using the properties. A complete rebuild of the page is enforced, the page load will now set the map to the desired size. And the div will wrap right because it's a brand new page.

I don't like this very much, but at least it does work. The only other working scenario I could imagine to circumvent the user taking care of the size is forcing a page refresh after a browser resize. Which stinks even more and will still leave the problem of finding out the available room. Which is a matter of chicken and egg.

I don't want to get involved in any holy war on browsers or w3c but I really do believe Firefox does this completely wrong. Silverlight is not the only content suffering.

Ajax and forms authentication

2008-12-18T08:46:32Z

Forms authentication is nice way to protect your asp.net web pages from unauthorized views. The good thing is that it shields all request for pages in your site and will redirect the request to a login page. You can set the time out of a session, after a preset period of inactivity the user has to be re-authenticated.

Al done in the web.config

</forms>

</authentication>

</authorization>

The bad thing is that forms authentication does not work that well with an AJAX site. When a partial postback hits the server and the session has timed out the server will redirect the request to the login page. This is a response the AJAX request cannot handle well. The result will be an endless loop of requests and the page just hangs. Damit Dobric has a very informative post on this. The good thing about Firefox is that it does detect the redirect loop and will stop. IE just keeps on trying.

Damir presents a solution for the problem which does requires quite some fiddling. Here I would like to present a simpler solution.

The page load of the masterpage checks if the request is the first one in the current session by inspecting the Session.IsNewSession property. In a page shielded with forms authentication this will never be the case; posting back the login form was the first request. But when the request was issued by a partial postback in a timed out session the IsNewSession property will read true and the situation can be handled.

protected void Page_Load(object sender, EventArgs e)
{
    // Ajax postback, session timed out. Redirect 
    if (Session.IsNewSession)
    {
        FormsAuthentication.SignOut();
        Response.Redirect("~/Default.aspx", true);
    }
}

It explicitly signs out of FormAuthentication and redirects the user to the main page. No more loops, no more hangups.

WPF = Code + Markup (Custom pushpins for DeepEarth)

2008-12-11T12:21:22Z

Windows Presentation Foundation has been around for a relative short while. Silverlight brings WPF to the browser, with that the amount of writings on WPF is growing fast. At the moment I'm working on a project which uses Deep Earth, a very cool Silverlight based viewer on Virtual Earth (or any other map provider). Deep Earth is an open source project. Having seen the curly path of this project I want to take a closer look at separation of presentation and logic behind, being one of the fundamentals of WPF.

WPF presentation is written out in markup, which is just another XML document. Logic is written out in C# (or any other .net language). There are several kinds of logic like business logic and presentation logic. Business logic should be kept as far from WPF as possible but when it comes to presentation logic there are many, many ways to handle that. In markup but also In C#. And sometimes you have to cross the border, C# code manipulating markup or markup providing a hook for your C# code. I will discuss both here.

As a demo I have a simple Silverligth user control. The xaml editor in VS is in it's current state not that useful. My image is drawn with Expression Blend. After that I copied the markup into VS. (VS and Expression Blend can be integrated, that's another story). The result looks like this.

Just an ellipse with two lines (the path elements)

I want to be able to set a visual property like the line thickness from code. There are many many ways to do that. According to most sources the way to do it is using databinding in the markup. But that is quite a hassle; not only the markup required also the timing. What if I want to update the property over and over again ? The most informative story I have found was this post by Rick Strahl on his frustrations.

What made me see the light was laying the web aside and browsing Petzolds book Applications = code + markup (this post's title is a tribute). That book has been critiqued by some as being not the right approach to WPF. For me it works just fine as it perfectly describes the two aspects, code and markup, and how they can communicate. I'm a code guy, at first sight Blend frightens me as a the tool of graphical artist. Anyway, Petzold's treatment presented a simple solution.

All visual elements have an optional name attribute. By default Expression Blend omits it. Elements with a name do show up in the code behind; elements without one don't. So after updating the XAML to

<Path x:Name="Line1" HorizontalAlignment="Left" Margin="163.401

<Path x:Name="Line2" HorizontalAlignment="Left" Margin="158.222

I can access the lines from code behind.

public partial class MyFancySilverlightControl : UserControl
{
    public MyFancySilverlightControl()
    {
        InitializeComponent();
    }

    public void ChangeLine(Color color, double thickness)
    {
        Line1.Stroke = new SolidColorBrush(color);
        Line1.StrokeThickness = thickness;
    }
}

The next thing I want to do is use my usercontrols in DeepEarth. DeepEarth does have a nice collection of shape controls to place on a map. Things like polygons to outline a region and pushpins to mark a position. Here the vector graphics used by WPF really shine. For example you can zoom in on a map and outline a city boundary in every detail using a Polygon shape. Zoom out and the boundaries melt into a small dot. Zoom in again and every detail is still there. Imagine doing that with bitmaps..

In the newest version the content of the different shapes is defined in markup templates. The basic markup of a shape is straightforward

<Setter.Value>

</Canvas>

</ControlTemplate>

</Setter.Value>

</Setter>

</Style>

A shape basically contains a single path (line). The template for a pushpin also contains a lot of fancy markup building the image of the pin. The WPF method OnApplyTemplate instantiates the shape. In overrides of this method the DeepEarth classes take further care of the correct size and position of the control on the map.

On a map usercontrols are like pushpins, an image of some kind placed on a certain location. A first shot would be to subclass the DeepEarth Pushpin class and add the markup of my pushpins to the templates of DeepEarth. But that would not be very flexible; in such a scenario every new control requires fiddling with the DeepEarth core assemblies. Besides that it would be hard again to set control properties from code.

Again, working from code provides a solution. And here the markup in the template provides a base for the code. I have added one new class to the DeepEarth shapes, a UserControlHost. This is it's markup

<Setter.Value>

</Grid>

</ControlTemplate>

</Setter.Value>

</Setter>

</Style>

Instead of a path the template declares a named grid. The nice thing about a grid control is that other controls can be added to its Children. And that's just what I do when applying the template

namespace DeepEarth.Shapes
{
    public class UserControlHost : Pushpin
    {

        private readonly UserControl hostedControl;

        public UserControlHost(UserControl hostedControl)
        {
            DefaultStyleKey = typeof(UserControlHost);
            this.hostedControl = hostedControl;
        }


        public override void OnApplyTemplate()
        {
            ((Grid) GetTemplateChild("LayoutRoot")).Children.Add(hostedControl);
            base.OnApplyTemplate();
        }

    }
}

The usercontrol is passed in the constructor. In the overriden OnApplyTemplate the grid is grabbed using the GetTemplateChild method and the usercontrol is added to its Children. After that OnApplyTemplate of the PushPin base class is fired. It takes care of all the sizing and positioning work. To that method there is no difference between xaml from the original template or xaml from injected usercontrol.

The UserControlHost class is just another shape like a polyline, polygon or the default pushpin. And you can do all the same things with it, like adding it to layers. This way you can host any UserControl in DeepEarth. This snippet will look familiar to anybody working with DeepEarth

UserControl visual;
if (isCurrentPosition)
    visual = new ShipVisual(shipColor, (double) clusteredWp.Course);
else
    visual = new PushpinVisual();

var pin = new UserControlHost(visual);

pin.Point = new Point(clusteredWp.Longitude, clusteredWp.Latitude);
wayPointLayer.Shapes.Add(pin);

That's it. I hope to have demonstrated that in WPF the border between markup and code is somewhat flexible. Both aspects are very powerful and they can really help each other. Separate well and rule (the deep earth).

Ubiquitous language, not only in your customer's domains

2008-11-25T20:52:40Z

In the hart of domain driven design is ubiquitous language. Everyone involved, from developer to domain expert, speaks the same language. This should not be just a matter of using the same labels for "things". Many a discussion starts with the question how to name something and leads to a shared analysis of what that thing really is. In the end (of that discussion) the resulting name is well chosen and has a deeper meaning.

But when it comes to naming things in the domain of software development I often see a not so ubiquitous language. To name just two of today's hobby horses: both the IoC/DI label and the TDD/BDD label are used for a diversity of "things". IoC and DI are not quite the same thing. But when it comes to naming techniques, designs, architectures or frameworks all to often the full label IoC/DI is applied. This almost reads as IoC aka DI, suggesting two different names for one and the same "thing". Whatever that thing is. It could be a framework implementing an IoC container or a design decision to use the DI pattern. Good articles on the subject describe the similarities and the differences between DI and IoC. Only the best take it a step further and use one name for one thing and suggest clear names rich in meaning for all other things.

The same story more or less applies to TDD/BDD. On the bright side Matthew Podwysocki just published a very good post on defining BDD as compared to TDD. So next time you read the label TDD/BDD just read that post again. And don't get me started on naming products. Microsoft almost makes a habit of names like "WCF formerly known as Indigo". I've been ranting on that before.

The domain of building software is one of the most complex domains you can imagine. Imho it would be beneficial to everybody to be as clear as possible in naming things here. What works for our customers will work for ourselves as well.

Interoperability with a Java (Axis) web service

2008-11-13T07:53:09Z

In my current project we are communicating with an external web service which is implemented in Java using Axis. This service returns arrays containing "nillable" integers. When generating the proxies in WCF or asp.net webservices these translate to nullable ints. So far so good.

The problem was that every nullable int in an array always returned null. A nullable element in the root of a return message did contain a value. Things got more confusing when my collegue, who uses Borland C++ builder to consume the service, could read values. Even more so because C++ does not have any nullable types.

Googling around revealed that this is a problem more people have with web services implemented with Axis. Using all kinds of tools to consume such a service. What I want to share is this gem in the search results. In a small and very clear post Tomer Gabel explains what is going on and also presents a very simple solution. Read the article and be amazed. The solution is flipping one flag in the Axis server config. Our service provider did that and now everything is working fine. Though C++ still doesn't have any nullable types :)

I'm no Java expert at all but it works on our machine :)