Blogs @ IRM

SlowCheetah XML Transforms as part of a TFS Build

ericqu — Tue, 15 May 2012 12:46:00 GMT

A half year ago I blogged about “Deploying ClickOnce to Multiple Environments”, but now I want to take this a couple of steps further and use a build server to automate the deploys. The first thing that I looked into was how to get SlowCheetah XML Transformations to work on our build server and this is the steps I took:

First of all I added the files the SlowCheetah installed to a place relative to my project files. You can find the files in you profile folder under “AppData\Local\Microsoft\MSBuild\SlowCheetah\v1”, so I copied them to our packages folder and checked them in to TFS Source Control.
After this I right-clicked on my project in Solution Explorer and choose “Edit Project File”. Search for SlowCheetahTargets and replace “$(LOCALAPPDATA)\Microsoft\MSBuild\SlowCheetah\v1\SlowCheetah.Transforms.targets” with the relative path to the targets file. In my case I replaced it with “..\packages\SlowCheetah.Transforms.targets”.
Now when you create a new Build definition in TFS you can set “Configurations to Build” (under “Build process parameters” and “Items to Build”) to the configuration that you want to build and the transformations will be applied on the build server too.

EA Principles–a way to overcome complexity and create simplicity

eskil — Thu, 10 May 2012 10:01:47 GMT

Eskil Swende starts a discussion on EA Principles. He will discuss a number of hypotheses how to overcome complexity and create simplicity.

Our enterprises evolve continuously. As a result, their architectural structures are transformed and extended continuously. Without control such changes are bound to lead to an overly complex and uncoordinated environment. Such a structure is hard to manage and may resist future changes in the desired direction.

Enterprise Architecture (EA) aims to proactively manage and share this structure. One main purpose of EA is to simplify the structure to make the enterprise agile and prepared for change and transformation. The other main purpose of EA is to simplify IT solutions and the system architecture.

A number of Architecture Principles form the cornerstone of EA. These principles provide a means to direct a successful transformation of the enterprise and achieve simplicity beyond the complexity.

Introduction

Background

EA has been around since Zachman introduced his Framework in the 1980s. EA was introduced to management by “Enterprise Architecture as Strategy” written by Ross, Weill and Robertson, published in 2006. Today the Open Group is introducing EA globally with their TOGAF Framework.

In Scandinavia more than 150 Architecture Plans have been developed since 1982, starting at SAS and SKF and recently at Scania, Statoil and IKEA to mention a few important examples. More than 800 Enterprise Architects have been certified at an academic level since 1994.

Contribution

A large number of global experts have been visiting us in Sweden and generously shared their knowledge and experience contributing to these EA Principles. Among them are Michael Brackett, Chris Bradley, Malcolm Chisholm, Steve Conway, Larry English, Thomas Erl, Danny Greefhorst, Steve Hoberman, Dirk Krafzig, Rick van der Lans, Stuart MacGregor, Jan Henderyckx, Dave McComb, Daniel Moody, Alexander Osterwalder, David Robertson, Jaap Schekkerman, Bob Seiner, Len Silverstone, Graeme Simsion and John Zachman.

A number of very professional certified enterprise architects in the DAMA Scandinavia network have been very supportive with helpful proposals and criticism.

A special thanks to Len Fehskens and his very inspiring thoughts in “Re-thinking Architecture”.

What is a principle?

“A principle is a law or rule that has to be, or usually is to be followed, or can be desirably followed, or is an inevitable consequence of something, such as the laws observed in nature or the way that a system is constructed.” (Wikipedia).

Why EA Principles?

Now when EA is globally accepted we may continue our effort to reach maturity. We all know that adding complexity is a short term solution to many problems. On the other hand creating simplicity is a long term solution, which requires a lot of knowledge, experience and resources.

Is there any way where we can work proactively towards long term solutions when we solve our short term problems? Yes, we think so. Reusing or creating simple solutions is often easier than adding complexity.

The EA Principles I want to discuss in this column aim at finding more long term simplicity when finding solutions to our problems.

“EA must include everything you need and nothing you don´t need” is one of the most important thoughts from Len Fehskens. “Simplicity is a virtue” is stated by Ingvar Kamprad, the founder of IKEA.

List of EA Principles

The overall EA Principles

Manage Information as a Resource and capture data once only
Create simplicity to overcome the complexity

EA Principles

Create a Business Driven Architecture
Develop and manage an Overall Business Information Model
Develop and manage an Overall Business Process Architecture
Achieve traceability from the overall architecture to the solution details and vice versa
Start at the top and keep the overview
Support transformation, give assistance and share the EA knowledge
Relate EA to the Business Innovation Models
Invest in reusable Components
Develop and manage an EA – Project agreement for new IT Solutions
Establish EA Governance supporting the desired transformations

Overall EA Principle 1 – Managing Information as a Resource and capture data once only

Information is a unique resource because you don’t consume it when using it. But it is also a very difficult resource to manage. Ted Codd, an English mathematician, made 1970 a ground-breaking development with his “Normalization theory” published and spread around the world by Chris Date.

In Scandinavia Bo Sundgren, a Swedish IM-professor, has made it operational and created a workshop approach. A number of business experts together with a professional facilitator can achieve a high quality Information Model; often named Data Model by IT professionals.

At architecture level we want to find a number of overall Information Groups, where an entity is only allowed in one single information group. Normally we find 25 – 40 Information Groups. These groups are gradually detailed when developing new IT solutions. This is a way to create reusable components in the business creating simplicity and reducing complexity. Read more at http://www.tdan.com/view-articles/12655

Still this requires knowledge and experience and many enterprises have not yet made this investment. Let us compare with the car and truck industry. Today this industry has invested heavily in modularity, but it has taken them more than 50 years to reach this maturity stage. Volkswagen calculate savings around 5 billion Euros yearly, since many car models use the same components or platform. When Scania or Volvo deliver a truck it is often unique, but it is built only using standard modules. In EA we have only just started such a journey.

Overall EA Principle 2 – Create simplicity to overcome the complexity

Our world is growing more and more complex. We have many driving forces adding to this complexity and very few creating simplicity. Companies like IKEA, where “simplicity is a virtue”, are very rare.

In a new book “Managing Complexity in our Organizations” Ulrich Steger at IMD in Lausanne tells us a lot about how complexity is still driving us away from a useful simplicity. Standardization of core processes is important when reducing complexity. There is a diversity of systems within a company that are often incompatible and resemble a patchwork of undisciplined IT-enabled business processes and redundant databases. The information itself is often quite diverse and is an important complexity driver. The complexity drivers in the innovation process are described in detail and are shown in a case study from LEGO, by Robert Davidson.

Our experience is that creating simplicity may start with the overall information modeling and the development of common definitions of important entities. The information structure and the common definitions are very useful when developing the overall business process architecture. It is a good way to reduce complexity in the enterprise structure. To start with the processes avoiding the information itself is attractive, but a short cut is often the longest way around!

”It seems that perfection is reached,
not when there is nothing left to add,
but when there is nothing left to take away”

by Antoine de Saint Exupéry, French author and pilot, 1900 – 1944.

Introducing the EA Principle approach

Fig 1. In the center we have the City Plan (EA) describing the structure of the enterprise, mainly the business processes and the information resource. To the left we may have a number of Business Model Canvases, where we have a binary alignment to the City Plan. Like a sun up to the right we have the reusable components (modules) also binary aligned with the information resource in the City Plan. To the right we may have a number of development projects based on the structure in the City Plan and giving feedback to the architectural structure.

Overview of the EA Principles

Fig 2. The EA Principles No 1-6 are guiding the development of the Enterprise Architecture to make it fulfil the EA purpose. No 7 is the binary alignment to the Business Innovation Model. No 8 is about how to develop reusable components. No 9 is the agreement between EA and Projects guiding the implementation of the Architecture. No 10 is the EA Governance needed to manage the transformation to the desired structure.

Please give your feedback!

Please give your feedback about these hypotheses. Have we included everything you need and nothing more? Read more about it in the book “Architecture Principles - the cornerstones of EA”, by Danny Greefhorst.

EA Forum in Venice on the 21st – 22nd of August 2012

Learn more and discuss with experts and architects at the EA Forum in Venice on the 21st – 22nd of August 2012.

In upcoming articles I will present and discuss each EA Principle in detail.

Next article will discuss the pros and cons of creating an agile Business Driven Enterprise Architecture, where the architects facilitate a group of business experts covering the overall enterprise structure.

How to do Custom Event Logging and Trace Writing in Azure

johan — Fri, 24 Feb 2012 14:56:00 GMT

We’re about to begin our first “real” Azure project and I needed to wrap my head around event logging and trace writing in the cloud. Any proper application running in any cloud needs this sooner or later.

I quickly noticed that the information around Azure diagnostics was all over the place, and some things seems to have been changed in newer versions of the Azure SDK. So, something I thought was going to take me just a few minutes to figure out took about a day, but I think I got it sorted in the end and here’s what I did to get simple event logging and trace writing to work for our web role.

First thing I had to understand was how data for all kinds of diagnostics is handled and stored in Azure. You need to define which kinds of diagnostics data you want to capture, and you need to define where Azure should transfer the data captured so that you can download them or look at then with various tools. You also need to define how often these values should be transferred. I’ll get back to that a bit later.

Create a Custom Event Source

First thing I wanted to have was a custom event source to write to for warnings and errors. To do this I created a simple cmd-file which I placed inside the web role project and uploaded with the packed deployment. Now when the web role is deployed, you define startup task which runs in elevated mode (to be able to create the event source) and points to this cmd-file. So, create a file inside your project’s root called CreateEventSource.cmd and put this inside it:

EventCreate /L Application /T Information /ID 900 /SO "MySource" /D "my custom source"

NOTE! Make sure the cmd-file property for “copy to output directory” is set to “copy always” or “copy if newer”.

Then open up your service definition file, ServiceDefinition.csdef, and add a startup task to it:

<?xml version="1.0" encoding="utf-8"?>
<ServiceDefinition name="MyWeb" xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition">
  <WebRole name="MyWebRole" vmsize="ExtraSmall">
    <Startup>
      <Task commandLine="CreateEventSource.cmd" executionContext="elevated" taskType="simple" />
    </Startup>
    <Sites>
… and so on…
</ServiceDefinition>

So now when your application is deployed the cmd-file should be executed with elevated permission and create the event log source you specified. EventCreate is a tool which is available on the Azure server so it’s nothing you need to worry about. Same thing should work well on your local dev machine too.

Storage Location for Diagnostics Data

You need a place for the diagnostics data to be transferred to. This is number of Azure Storage tables so you need to create an Azure Storage Account where Azure can create these specific tables and transfer the captured data. So you basically go to the Azure Management Portal and create a new Storage Account and copy the access key. Then paste the storage account name and key into the Service Configuration:

Now when Azure starts to transfer data from event log and trace writes, they will be written to these two tables; WADLogsTable and WADWindowsEventLogsTable:

If you capture performance counters and such, these will be written to other tables.

Diagnostics Configuration

Next thing to do is to configure which diagnostics to capture for your application. This is done in the OnStart() method of your WebRole.cs file. What I wanted to test initially was event logging to my custom source and also some trace writings for information, warning and errors. I also specified how frequently I wanted these diagnostics to be written to the storage tables:

public override bool OnStart()
{
    var diag = DiagnosticMonitor.GetDefaultInitialConfiguration();
            
    diag.Logs.ScheduledTransferLogLevelFilter = LogLevel.Information;
    diag.Logs.ScheduledTransferPeriod = TimeSpan.FromSeconds(30);

    diag.WindowsEventLog.DataSources.Add("Application!*[System[Provider[@Name='MySource']]]"); 
    diag.WindowsEventLog.ScheduledTransferPeriod = TimeSpan.FromSeconds(30);

    DiagnosticMonitor.Start("Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString", diag); 

    return base.OnStart();
}

Note a few things about this code – The transfer schedule is set to 30 seconds and you may want to set this one a bit higher and also look at the buffer quotas. The sample code is also only capturing and transferring event logs from the “Application” logs, and I’ve added an xpath expression to only transfer logs from the “MySource” event source we specified in the cmd-file earlier. You may want to grab all application events as well as all system logs too, in that case:

diag.WindowsEventLog.DataSources.Add("System!*");
diag.WindowsEventLog.DataSources.Add("Application!*");

Writing to Event and Trace Logs

The simplest thing is then to add some code to write to the event log and trace logs in your code, for example:

Trace.TraceError("Invalid login");
EventLog.WriteEntry("MySource","Invalid login",EventLogEntryType.Error);

Looking at the Data

To actually see what’s been written to these tables, you need to either download the data from the storage tables via APIs, use the server explorer or some tool, like the one from Cerebrata – “Azure Diagnostics Manager” – which seems to do the job pretty well. As far as I know, there is no proper tool available from Microsoft. Be that as it may.

Please, feel free to write comments below and add tips and tricks about handling diagnostics in your Azure application. I’d like to know more about the Transfer Period and Buffer Quotas and how they may affect the application and maybe also the billing… I’m sure there are loads to learn about this .

Cross-posted from my blog at http://weblogs.asp.net/jdanforth

When the Test Agent Fails on the Build Server

ericqu — Thu, 16 Feb 2012 20:23:46 GMT

When I set up a continues integration build on our new build-server, I got “The agent process was stopped while the test was running.” when the test ran. This is not a very helpful error message and the troubleshooting is hard when all test succeeds locally. Fortunately I have the possibility to read the event log on the build server and there were more details. In my case the problem was that the code contracts wasn’t installed on the server.

Once again the lesson is to read the event log. Am I the only one that often forgets to do that initially?

How to Force Comments When Doing Check-In in TFS

johan — Wed, 08 Feb 2012 09:35:52 GMT

I was looking for a policy like this, and found this blog article by Claus Konrad:

http://blog.clauskonrad.net/2010/08/tfs-2010-how-to-force-comments-when.html

Now, unfortunately everyone in the project has to have the TFS Power Tools installed to make this work.

The power tools can be downloaded from the Visual Studio Gallery, this is a direct link to it:

http://visualstudiogallery.msdn.microsoft.com/c255a1e4-04ba-4f68-8f4e-cd473d6b971f?SRC=VSIDE

Whish this was in the box from start.

Cross-posted from my blog at http://weblogs.asp.net/jdanforth

MSTest and Calling Exe with Sample Data Files

johan — Tue, 07 Feb 2012 08:52:59 GMT

For various reasons I’m using MSTest for my unit tests and I have this console app which generates a PDF file from an XML file that needed some tests.

So, when moving the unit tests over to a TFS build server, having hard coded paths to test data files is not a good idea. The recommended way of doing it is to use the DeploymentItem attribute.

Also, when calling an exe-file which does Environment.Exit() and catching the exit code from the unit test is pretty straight forward by using Process.Start() and checking the ExitCode property.

A small sample:

[TestMethod]
[DeploymentItem(@"TestData\arbetsorder.xml", "TestData")]
[DeploymentItem(@"TestData\arbetsorderReport.rdlc", "TestData")]
public void GeneratorShouldReturnWithExitCode0()
{
    Process proc;
    try
    {
        proc = Process.Start("PdfGenerator.exe", "\"" + Directory.GetCurrentDirectory() + "/TestData/arbetsorderReport.rdlc\" \"" +
            Directory.GetCurrentDirectory() + "/arbetsorder.pdf\" \"" + Directory.GetCurrentDirectory() + "/TestData/arbetsorder.xml\"");
    }
    catch (System.ComponentModel.Win32Exception ex)
    {
        proc = null;
        Assert.Fail(ex.Message);
    }

    Assert.IsNotNull(proc);
    proc.WaitForExit(10000);
    Assert.IsTrue(proc.HasExited);
    Assert.AreEqual(0, proc.ExitCode, "Expected 0, got " + proc.ExitCode);
}

But, there’s a small caveat to get the DeploymentItem argument working properly! First you have to open up the test settings of your .testsettings file, select the Deployment settings and make sure the “Enable deployment” checkbox is checked:

That’s all you need to do. And note that you may actually have to exit and restart Visual Studio to make it work. I never got the files deployed until I did that restart.

Cross-posted from my blog at http://weblogs.asp.net/jdanforth

Information and Events are Stable Parts of Business

ericqu — Fri, 13 Jan 2012 09:32:51 GMT

At IRM we often use this picture to talk about the stable parts of the business. Actually we have used it at least during the eight years I‘ve been working here.

The least stable part is the organisation itself. Many of us have been affected by organisational changes during the last year and just as many of us will be affected by a change this year. Since it changes all the time it would be unwise to base any software architecture on the current organisation.
As a side note: This is one reason to why I often talk about (user) roles as a bad thing to base the security checks on for a system, even though it is often well supported by the platform.

The most stable part of the business is the structure of the information we need. As long as IRM have been a consultancy firm we have provided services to our customers in projects for which we have always tracked the hours (time) each employee have worked. Surely the information changes too, for example we have for many years educated other in both internal and open courses, but this was not part of the business when IRM started back in 1982. The content changes (hopefully) rapidly with new customers and projects all the time, but not what information we need to track.

How we have performed our services and the internal work have changed over time. It is the process we try to improve all the time. Since the process itself is something that we want to change this is also unwise to base the software architecture on. Still this was a very common advise when SOA was hitting the hype curve, but I believe that is a mistake that happened because we so eagerly wanted to align our solutions better to the business process (of course the system need to support the processes very well, but it shouldn’t be the part that we base our architecture on).
If we dig a little bit deeper into processes they are a series of activities, triggered by an event, that are performed to deliver a value for a customer. The activities are more stable than the process itself, but even more stable are the events. Actually there is an event after each activity that triggers the next activity. An event can also be found when studying the state transitions of the information, for example visualized in an UML State Diagram. This have lead me to talk about the events as the line between Process and Information in the stability diagram above.

I would say that information and events are two important artifacts to pay special attention to when designing software. This spans from defining the correct aggregates (in DDD) to defining service boundary (in SOA) or Bounded Context (in DDD) to integration between systems. I haven’t written about business capabilities in this post, but also when using capabilities for example to define services, you need to make sure that information which must be consistent (not eventually consistent) belongs to the same capability and the most important way of communication between services are based on events.

Deploying ClickOnce to Multiple Environments

ericqu — Wed, 14 Sep 2011 13:05:20 GMT

So in my struggling to get a lean and effective way to roll out new versions of an application for two of my clients, I have some more to share with you. I want it to be extremely easy for me to create a new ClickOnce installer for my clients and I have identified three things that I need to solve:

The installations will be run from different installation URL:s.
Getting unique config-files packed with the ClickOnce publish. I have 2 clients, each with a test and a production environment, and I need to handle my own test environment too.
A client machine needs to be able to run installations for both test and production on a single machine. This means that ClickOnce must see my applications as different applications even though it is only one.

I have solved the last two, so lets start with the last one.

Running both test and production environments on the same client

There are more than one way to solve this, but for me the easiest solution was to create two Visual Studio projects. Originally I had a single Windows Forms exe project in Visual Studio, but I changed this to be just a DLL-project (Output type in Application settings). Then I created two new projects with the names Application and Application.Test and for both of them I configured ClickOnce as usual. There is only a single line of code in each of these projects and that’s to call the original entry point in my old exe-project:

Program.Main(args);

With this solved I still needed to handle the differences in configurations.

Different config for each environment

Visual Studio 2010 has support for transforming configuration files when deploying a web project, but only when deploying and that is only supported for web projects. Luckily Sayed Ibrahim Hashimi and Chuck England have created a small VSiX called SlowCheetah XML Transforms that do the same thing, but when you build your project. So naturally the first step is to install the add-in. Next up is to create new project configurations in configuration manager (I created CustomerATest, CustomerAProd, CustomerBTest and CustomerBTest). With this in place you can right-click on the config-file in you project and select Add Transform, which adds a sub-config file for each configuration. In these config files you then apply the transformations for the changes you want to do in the config file.

This is so useful in many more scenarios than just for deploying with ClickOnce.

Unfortunately I haven’t solved the problem of having different installation URL:s for each configuration, but maybe someone has a tip? I have tried to edit the project file and move the installation url element to respective configuration. This works if I remember to reload the project each time I select another configuration (which I of course don’t), but if I don’t reload the settings will be overwritten with the value from the configuration that was used when the project was loaded so that won’t work. The best thing would of course be if Visual Studio could start to support different installation URL for each configuration.

Command Handling the Nancy Way

johan — Thu, 08 Sep 2011 13:50:55 GMT

MiniBuss is a micro service bus framework over msmq which consists of less than 400 lines of code, sitting inside one single source file. The project is hosted over at http://minibuss.codeplex.com and the source code is maintained at https://github.com/johandanforth/MiniBuss

I’ve been a fan of the Sinatra inspired web framework called Nancy, especially the neat way of setting up handlers for routes. The simplest sample on their site is this:

public class Module : NancyModule
{
    public Module()
    {
        Get["/greet/{name}"] = x => {
            return string.Concat("Hello ", x.name);
        };
    }
}

So, I shamelessly dug into the Nancy code and borrowed some 20-30 lines of code and came up with something like this for registering handlers for certain incoming commands on the minibus, what do you think?

public class CommandHandler : MessageHandler
{
    public CommandHandler()
    {
        WhenReceiving[typeof(SampleMessage1)] = x =>
        {
            Console.WriteLine("sample 1 message: " + x.Text);
        };

        WhenReceiving[typeof(SampleMessage2)] = x =>
        {
            Console.WriteLine("sample 2 message: " + x.Text);
        };
    }
}

It’s a bit more code but it helps/enforces you to move the handlers off to a certain module. Thoughts?

Cross-posted from my blog at http://weblogs.asp.net/jdanforth

More MiniBuss Updates

johan — Fri, 02 Sep 2011 20:23:23 GMT

MiniBuss is a micro service bus framework over msmq which consists of less than 400 lines of code, sitting inside one single source file. The project is hosted over at http://minibuss.codeplex.com

Thanks to @CodingInsomnia for testing out the MiniBuss stuff a bit more than I did For the samples, and for my initial testing code, I used a shared assembly with messages (events and commands), which shouldn’t be necessary. So I made a few simple changes and now you can choose to either share messages in an assembly between your sender/receiver and publisher/subscribers OR you can declare local message classes as long as those classes use the same class name and properties it should work.

The NuGet package has been updated, and the new code is in package version 1.0.2.0.

Cross-posted from my blog at http://weblogs.asp.net/jdanforth

MiniBuss Updates

johan — Thu, 01 Sep 2011 09:35:31 GMT

I made a small update to MiniBuss, the micro service bus framework. The messages you send, Commands and Events, are no longer dependent on IMessage. The messages sent on the bus can now be any .NET class which can be safely serialized.

The MiniBuss package on NuGet has been updated (version 1.1.0.1).

I’m looking for testers, reviewers and co-authors. Areas I want to look more at are multithreading/concurrency and the reply-feature (especially being able to reply to current message in multithreaded scenarios.

Cross-posted from my blog at http://weblogs.asp.net/jdanforth

MiniBuss on Codeplex

johan — Tue, 30 Aug 2011 11:48:17 GMT

The micro service bus framework for msmq called MiniBuss is now open source on Codeplex at http://minibuss.codeplex.com

There is also now a NuGet package available for easy install into projects:

If you’re interested in co-op on this project, please contact me via Codeplex! I’m looking for devs and tester who knows their c#, msmq and concurrency.

Cross-posted from my blog at http://weblogs.asp.net/jdanforth

ClickOnce to the Rescue

ericqu — Tue, 23 Aug 2011 13:58:25 GMT

I have two clients who are outsourcing their PCs and servers and one consequence of that is from now on it will take 3 weeks (plus additional costs) to get a MSI delivered to the clients. This way to far from our fast deliveries that we have today, so I recommended them that we should move on to ClickOnce for distributing the application. This will allow us to roll out new versions quickly and keep the cost down to a minimum.

There is a switchboard integrated though and I was a little bit uncertain if we could handle the requirements of the switchboard to start the client with arguments and always with a single instance of the application. It turned out to be really simple. First of all, we did not need to make any changes in our single instance code (which uses named pipes to communicate from second instance to first).

When someone calls to my client, the switchboard makes a lookup by calling a web service. In the answer it retrieves the path to the installed client, including the correct command line arguments that should be used to start the application. When switching to a ClickOnce distribution the service are not able to include a local path anymore, since the server has no idea where the application is installed. After a quick search I found that ClickOnce can also be called with parameters so that was the path I choose to go down and it worked really well. This is what I needed to do:

In the “Manifests” settings (found under “Publish Options”) it is required to check “Allow URL parameters to be passed to application”.
Next I changed the web service so it returned the URL to the ClickOnce installation (not the bootstrapper exe, but the .application file which also needs to be the installation source) followed by regular query string parameters.

In my code, I just added a small function that takes command line parameters (so I continue to support local installs) as in parameters and the returns them or the parameters send through the query string.

private static string[] GetCommandLineArguments(string[] args)
{
    if (ApplicationDeployment.IsNetworkDeployed && ApplicationDeployment.CurrentDeployment != null)
    {
        if (ApplicationDeployment.CurrentDeployment.ActivationUri != null)
        {
            string queryString = ApplicationDeployment.CurrentDeployment.ActivationUri.Query;
            if (!string.IsNullOrEmpty(queryString))
            {
                queryString = queryString.Replace('?', '/').Replace('=', ':');
                return queryString.Split('&');
            }
        }
    }

    return args;
}

The ActivationUri will always be null if the “Allow URL parameters to be passed to application” isn’t set.

A One File .NET Micro Service Bus for MSMQ?

johan — Fri, 19 Aug 2011 11:15:00 GMT

This last year our company has invested quite some time in looking at CQRS, which led to looking at great looking service-buses like nServiceBus, Rhino Service Bus and Mass Transit, which led me to do some bus-coding on my own, mostly for fun and for learning MSMQ.

Inspired by the service buses mentioned above, the result became a bare-bones-one-file “micro service bus” that I call MiniBuss which sits on top of MSMQ. The file itself is only some 400 lines of code and supports send, receive, reply, publish and subscribe/unsubscribe.

Setting up a sender may look something like this:

var bus = new MiniBuss.ServiceBus();
 
 bus.RegisterMessageEndpoint<HelloCommand>("minibuss_receiver1@johan-dell-ssd");
 
 bus.Start();
 
 bus.Send(new HelloCommand { Guid = Guid.NewGuid(), Message = "Hello" });

Create the bus, register a message and tell it where messages of this type should go, start the bus and send the message.

Setting up a receiver may look something like this:

var bus = new ServiceBus { LocalEndpoint = "minibuss_receiver1" };
 
 bus.RegisterMessageHandler<HelloCommand>(command => Console.WriteLine(command.Message + " Guid: " + command.Guid));
 
 bus.Start();

Create the bus and tell it which endpoint to listen to (which creates a local MSMQ queue if necessary) and tell it which message type to listen for and which delegate to kick off when such a message is received.

Similarly, when doing a receive/reply, you would have to create the bus on the sender side with a local endpoint and register a message-handler for replies, like this:

var bus = new MiniBuss.ServiceBus { LocalEndpoint = "minibuss_sender1" };
 
 bus.RegisterMessageEndpoint<HelloCommand>("minibuss_receiver1@johan-dell-ssd");
 
 bus.RegisterMessageHandler<HelloResponse>(reply => Console.WriteLine("Reply from receiver: " + reply.Message));
 
 bus.Start();
 
 Console.WriteLine("Sending command...");
 bus.Send(new HelloCommand { Guid = Guid.NewGuid(), Message = "Hello" });

The receiver would do a bus.reply() like this:

var bus = new ServiceBus { LocalEndpoint = "minibuss_receiver1" };
 
 bus.RegisterMessageHandler<HelloCommand>(command =>
 {
     Console.WriteLine(command.Message + " Guid: " + command.Guid);
 
     bus.Reply(new HelloResponse { Guid = Guid.NewGuid(), Message = "Hello back!" });
 });
 
 bus.Start();

The MiniBus also supports publish to multiple subscribers. A simple publisher would create a bus with a local endpoint (to receive subscribe/unsubscribe commands), tell it to handle subscriptions for a certain event, then start publishing something every 5 seconds (as an example):

var bus = new MiniBuss.ServiceBus { LocalEndpoint = "minibuss_publisher1" };
 
 bus.HandleSubscriptionsFor<SomethingHappenedEvent>();
 
 bus.Start();    
 
 Task.Factory.StartNew(() => PublishingThread(bus), TaskCreationOptions.LongRunning);
 
 Console.WriteLine("Done, press ENTER to exit");
 Console.ReadLine();

private static void PublishingThread(MiniBuss.ServiceBus bus)
 {
     while (true)
     {
         Thread.Sleep(5000);
         var guid = Guid.NewGuid();
         Console.WriteLine("Publishing event with guid " + guid);
         bus.Publish(new SomethingHappenedEvent() { Guid = guid, Sent = DateTime.Now });
     }
 }

Any clients interesting in subscribing to events from the publisher would create a bus with a local endpoint, start the bus and then send a subscribe command to the publisher, telling it you’re interested in subscribing to a certain type of event and which delegate to handle it:

var bus = new MiniBuss.ServiceBus {LocalEndpoint = "minibuss_subscriber1"};
 
 bus.Start();
 
 bus.Subscribe<SomethingHappenedEvent>("minibuss_publisher1@localhost", 
     @event => Console.WriteLine("something happened at {0}, event id {1}",
         @event.Sent, @event.Guid));
 
 Console.WriteLine("Waiting for events, press ENTER to exit");
 Console.ReadLine();
 
 bus.UnSubscribe<SomethingHappenedEvent>("minibuss_publisher1");

Now, the question is, what do you think? I know there are issues with the code, like how to make message-handlers multi-threaded/concurrent without messing things up (it’s single threaded right now), and how to best handle exceptions, rollbacks and re-tries . Right now handling exceptions in send and receive works pretty well within a TransactionScope() together with ADO.NET, and if there’s an exception, the message is moved the an error-queue. No re-try or anything, only rollback and move to xxx_error. Also, the publisher doesn’t persist subscriptions, so if it is restarted subscribers wouldn’t know. You know, things like that.

I’m a user of the micro-orm called Dapper and like it a lot, so I’m thinking that maybe I should release this micro-bus as open source and see where people may take it, if anywhere? Maybe just down the drain because they figure out this service bus is dangerous to use and risk loosing messages or something (which would be extremely good to know :)

Or maybe this code is useless because you already got nServiceBus and Rhino out there and coders don’t need another service bus?

What do you say?

Cross-posted from my blog at http://weblogs.asp.net/jdanforth

Pomodoro Timer for the Windows 7 TaskBar

johan — Tue, 16 Aug 2011 11:08:00 GMT

EDIT: The code is now open source on codeplex, on http://pomodorotaskbar.codeplex.com There's a new version available for download there too.

If you’re into the Pomodoro technique and looking for a pretty simple out-of-the-way timer which sits in the Windows 7 taskbar and is controlled from the Win7 JumpList, this one might be worth trying out.

NOTE: Icon overlays will NOT work if you're using small TaskBar icons!

That’s the timer looking like a tomato, with the remaining session minutes written out dynamically as icon overlay.

The timer has a couple of JumpList Tasks which you can use to control it. The program works well when “pinned” to the taskbar if you prefer it.

You can also control the timer from the main window with one large action-button (stop, start, stop ringing and restart session).

When the timer is stopped, you can just click on the remaining minutes-textbox and change the default session length to whatever you like. The value is stored.

When the session is ended, the window flashes, the tomato shakes and a ringing sound is played a few times to get your attention.

Note, this is a very simple program which I’m planning to release as open source when I’ve received some feedback. I prefer to keep it simple, but may add session logging. The name as well as the looks may change. .NET 4.0 is required.

Download the Pomodoro Timer: http://pomodorotaskbar.codeplex.com/releases/view/71998

Cross-posted from my blog at http://weblogs.asp.net/jdanforth

Create Tag-Cloud from RSS Feed in ASP.NET MVC

johan — Mon, 08 Aug 2011 11:40:12 GMT

Say you want to generate your own tag-cloud from a list of categories or tags you pull from an RSS-feed or similar. This is one way to do it. I’m using ASP.NET MVC for this sample which creates a simple tag-cloud in a Razor-view with HTML looking something like this:

The controller-code to start out with looks like this, where you read in the RSS-feed into a SyndicationFeed class, then pull out and flatten all the categories you have in that feed. Then group all those categories and count them to build up this simple view-model which is a Dictionary of category and percentage:

public class HomeController : Controller
 {
     public ActionResult Index()
     {
         //get feed
         var feed = SyndicationFeed.Load(XmlReader.Create("http://blog.irm.se/blogs/MainFeed.aspx"));
 
         //get flat list of all categories/tags in the feed
         var categoriesList = feed.Items.SelectMany(item => item.Categories).Select(category => category.Name);
 
         var categoryGroups = categoriesList.GroupBy(category => category);
 
         decimal maxNrOfACategory = categoryGroups.Max(w => w.Count());
 
         //build a dictionary with category/percentage of all categories
         var tagCloudDictionary = new Dictionary<string, int>();
         foreach (var tag in categoryGroups)
         {
             var percent = (tag.Count() / maxNrOfACategory) * 100;
             tagCloudDictionary.Add(tag.Key, (int)percent);
         }
 
         return View(tagCloudDictionary);
     }
 }

So now we got this view-model which is a Dictionary<string,int> and contains category/percentage data like this:

So all we need to do is create some kind of cloud in HTML or similar in the view. One way of doing it is this, which creates the output shown at the top:

@model Dictionary<string, int>
 
 @{
     ViewBag.Title = "Index";
 }
 
 <h2>Tag cloud</h2>
 <div style="width: 400px; font-size: 25px;">
     @foreach (var tag in Model)
     {
         <span style="font-size: @(tag.Value / 2 + 50)%; ">
         @if (tag.Value > 10)
         {
             <span style=" font-weight: bold;">@tag.Key </span>
         }
         else
         {
             <span>@tag.Key </span>
         }
         </span>
     }
 </div>

Obviously, to be able to click on a tag and so on you need to create a richer view-model, I just wanted to show how I grab and count the tags from the feed

Cross-posted from my blog at http://weblogs.asp.net/jdanforth

Hosting Rhino Service Bus in IIS

ericqu — Sun, 19 Jun 2011 20:08:00 GMT

This is my third post (part 1, part 2) with notes from my exploration of Rhino Service Bus and in this I will focus on how to set everything up for Pub/Sub when having IIS as a host. The first thing that must be done is to choose a strategy for where to do the initialization of the bus and other parts of the service/application. Here is a good blog post covering the choices and for this sample I choose the AppInitialized because it supports other protocols than http and I don’t need to support any other hosts than IIS so I don’t need to cover that.

public static void AppInitialize()
{
    var host = new DefaultHost();
    host.Start<Bootstrapper>();

    var consumerHost = new DefaultHost();
    consumerHost.UseStandaloneCastleConfigurationFileName("Consumer.config");
    consumerHost.Start<Bootstrapper>();
}

In this test I trigger the events from button clicks on a webpage, but except for that everything works as in the previous post.

When deploying it to a server with IIS installed on, I manually created the Rhino Queue folders (in my case Publisher.esent, Publisher_subscriptions.esent, Consumer.esent and Consumer_subscriptions.esent). For each folder I than gave modify permission to the account running the application pool (you will get a access denied exception if you don’t do this and giving Modify permission on the parent folder does not seem like a good idea).

I haven’t been able to get a sample with RemoteAppDomainHost to work. It complains about not being able to find Rhino.ServiceBus assembly and I’m pretty sure it has to do with ASP.NET shadow copying of files. Has anyone got this working? Please leave a comment or link in that case. Thanks, Eric.

Consuming Events in the Same Process as the Publisher with Rhino Service Bus

ericqu — Sun, 19 Jun 2011 13:25:42 GMT

I recently blogged about getting started with Rhino Service Bus for publishing and subscribing to events. If you did not read that post, I recommend you to do that before continuing since I will just outline my modifications in this post.

My scenario is that I want to decouple things that happens when my server is getting a command. I would like to just save the parts that is core to my domain as a direct effect of the command, but other things like calling other external systems and creating a change history I would like to do later on and in its own transactions. For this I wanted to publish events from my domain and then have subscribers handling each and every scenario separately. I thought it wouldn’t be necessary to have a second process though, so in this post I will show you how both the publisher and the subscriber can exist in the same process.

So based on the steps in my previous post, I copied the class that consumes my events (implementing the ConsumerOf<> interface) to the publisher project. Now I need to have a second service bus host in the Publisher project and that second host must have its own configuration file.

I created a new configuration file, but instead of classic app.config, I called it Consumer.config and I also set the “Copy to Output Directory” to “Copy if newer”. The configuration file is a little bit different than the previous, because the host don’t want the surrounding castle element.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <facilities>
    <facility id="rhino.esb">
      <bus threadCount="1" numberOfRetries="5" endpoint="rhino.queues://localhost:31317/RSB_Consumer_In_Publisher" name="Consumer"/>
      <messages>
        <add
          name="RSB.Events"
          endpoint="rhino.queues://localhost:31315/RSB_Publisher"
          />
      </messages>
    </facility>
  </facilities>
</configuration>

After starting the Publisher host, I also added code to start the in-process Consumer host. The big difference here, compared to the consumer described in my last post, is that I tell the host to use another config-file, by calling UseStandaloneCastleConfigurationFileName.

static void Main(string[] args)
{
    var host = new DefaultHost();
    host.Start<Bootstrapper>();
    Console.WriteLine("Started server publisher.");

    var consumerHost = new DefaultHost();
    consumerHost.UseStandaloneCastleConfigurationFileName("Consumer.config");
    consumerHost.Start<Bootstrapper>();
    Console.WriteLine("Started server consumer.");

    IServiceBus bus = host.Container.Resolve<IServiceBus>();
    bus.Notify(new Event1());
    Console.WriteLine("Published Event1.");

    Thread.Sleep(2000);

    bus.Notify(new Event2());
    Console.WriteLine("Published Event2.");

    Console.ReadLine();
}

Another option for hosting in process is to use the RemoteAppDomainHost, which I believe will run in the same process, but in another AppDomain. This would probably add some robustness to the solution. The difference when using that hosting option is that the Consumer.config file will need to be an ordinary config-file with configSection and the facilities element must be contained in a castle element. The code for bringing the host up is similar to the one above.

var consumerHost = new RemoteAppDomainHost(typeof(Bootstrapper));
consumerHost.Configuration("Consumer.config");
consumerHost.Start();
Console.WriteLine("Started server consumer.");

Getting Started with Pub/Sub using Rhino Service Bus

ericqu — Sat, 18 Jun 2011 12:09:01 GMT

I have a project where I want to start publishing events on the server and then have a consumer subscribing to these events and take action. First I took a quick look at nServiceBus, but I also thought that it would be interesting to see what else exists on the .NET platform. I found both Mass Transit and Rhino Service Bus (RSB). I decided that Rhino Service Bus might fit very well with this project since it has built-in support for Rhino Queues (of course) and it is still open source without restrictions. Rhino Queues is interesting because it is a xcopy deployment.

This post is mainly about giving RSB a first run, so it will be very basic and more like a dump of my own progress.

First I created a simple project for defining the events (messages) and it only contains two empty classes Event1 and Event2. It might be worth noting that there is no requirements on the classes, aka it is not necessary to implement any interfaces or mark them with any attributes.

After this I created a Publisher and a Consumer project and in both projects I added a reference to the Events project and I used NuGet to add a reference to Rhino Service Bus. I began with the publisher:

Added an empty classes called BootStrapper which inherit from AbstractBootStrapper.

Added an app.config

<configSections>
  <section name="castle" type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor"/>
</configSections>
<castle>
  <facilities>
    <facility id="rhino.esb">
      <bus threadCount="1" numberOfRetries="5" endpoint="rhino.queues://localhost:31315/RSB_Publisher" name="Publisher"/>
      <messages/>
    </facility>
  </facilities>
</castle>

The endpoint attribute of the bus element defines the queue this bus is listening to. The “rhino.queues” defines that Rhino Queues should be used, but RSB also supports MSMQ by using the “msmq” moniker instead.

All that is left now is to start the bus and publish the events. The code for this is straight forward and self explained.

static void Main(string[] args)
{
    var host = new DefaultHost();
    host.Start<Bootstrapper>();

    Console.WriteLine("Starting server publisher.");
    Thread.Sleep(1000);

    IServiceBus bus = host.Container.Resolve<IServiceBus>();
    bus.Notify(new Event1());
    Console.WriteLine("Published Event1.");


    Thread.Sleep(2000);

    bus.Notify(new Event2());
    Console.WriteLine("Published Event2.");

    Console.ReadLine();
}

The IServiceBus supports both Notify and Publish for publishing events. The difference is that the later requires at least one listener.

So with the Publisher wrapped up, lets do the same three steps, plus one additional for the Consumer.

Added an empty classes called BootStrapper which inherit from AbstractBootStrapper.
Added an app.config

<configSections>
  <section name="castle" type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor"/>
</configSections>
<castle>
  <facilities>
    <facility id="rhino.esb">
      <bus threadCount="1" numberOfRetries="5" endpoint="rhino.queues://localhost:31316/RSB_Consumer" name="Consumer"/>
      <messages>
        <add
          name="RSB.Events"
          endpoint="rhino.queues://localhost:31315/RSB_Publisher"
          />
      </messages>
    </facility>
  </facilities>
</castle>

Before starting the bus I also need to create a classes that can handle the events when they get published. This is done by implementing the ConsumerOf<> interface.

public class EventConsumer : ConsumerOf<Event1>, ConsumerOf<Event2>
{
    public void Consume(Event1 message)
    {
        Console.WriteLine("Received Event1");
    }

    public void Consume(Event2 message)
    {
        Console.WriteLine("Received Event2");
    }
}

As for the Publisher the last step is to start the bus and when this is done it will automatically tell the Publisher which events the Consumer want to receive.
```
static void Main(string[] args)
{
    var host = new DefaultHost();
    host.Start<Bootstrapper>();

    Console.ReadLine();
}
```

Never, never, never do Office interop on the server

johan — Sun, 15 May 2011 17:14:37 GMT

I’ve been telling people this for years and years, and still I stepped right into the mudhole a month ago. I blame stress, but still I shouldn’t have. It’s so easy to just add the interop assemblies and off you go… until you try running your stuff on the 2008 r2 server, hosted somewhere else, with just enough user rights. And even though I managed to get the !”#!¤¤”% working after a while, I got mem-leaks and follow-up probs due to the workarounds I had to do to get the interop working in the first place.

Then I sat down and relaxed for a minute and realized I need to do this the right way, which is the OpenXML way.

The thing is, OpenXML is – compared to Office-interop - not easy, and the Microsoft OpenXML SDK 2.0 is just lipstick on top of the XML and some things which were so easy to do with the interop assemblies gives you nightmares to do with OpenXML. Try fill in formsfields in a protected word document for example. I ditched the SDK and ended up doing it directly against the XML directly instead.

I also had to fill out a few Excel spreadsheets with data, which was somewhat easier to handle than the Word-story above. But I ran into problems here too, because I wanted to do such a simple thing as setting text wrap on a few cells! I don’t know, but I’m sure Microsoft could have done something better for us poor developers that need to create docs on the server! Are we supposed to spend 40% of the coding time to just create a few simple docs, just because we go the OpenXML way? There are a quite a few pages on MSDN with samples, as well as code snippets to download, but as soon as you need to do something outside the “demo-path” you’re banging your head. Maybe I’m just stupid and doesn’t get it, or maybe I’m getting grumpy, because OpenXML is not a developer-friendly framework! There, feels much better now…

Now, for Excel spreadsheets there’s good hope because you got more than a few decent packages out there to help you out, and the best one I’ve found so far is called ClosedXML on Codeplex. It’s free and it did everything I needed to do right out of the box! It took me 5 minutes to create the 2 different spreadsheets I needed for my project, including cell formatting, text wrapping and so on. Cheers to MDeLeon for doing this!

Cross-posted from my blog at http://weblogs.asp.net/jdanforth

Refactored Dapper Extensions

johan — Tue, 10 May 2011 22:48:29 GMT

Making extensions for Dapper-dot-net was so fun and I needed a few more simple ones so I refactored a bit and made a few Update() and Delete() extensions as well. I’m also looking for Id-properties with the [Key] attribute on them. The class grew a bit, but it now supports the functions below. Note that this will only work for very simple objects and tables, but it might be helpful for some of you

I’m trying to follow the overall Dapper syntax as much as I can. If you done specify the table name with the input parameter, I’m using the name of the class/entity as table name, except where anonymous types are used.

The object I’m using for testing

    public class Test
    {
        [Key]
        public int Id { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
    }

Insert typed object

                var entity = new Test() { Name = "Johan", Age = 44 };
                connection.Insert(entity);

Insert anonymous object

                connection.Insert("insert into test", new { Name = "Johan", Age = 20 });

Update typed object (where-clause built up from Id-properties)

                var entity = new Test() { Id = 16, Name = "Johan", Age = 50 };
                connection.Update(entity);

Delete typed object (where-clause built up from Id-properties)

                var entity = new Test() { Id = 4, Name = "Johan", Age = 44 };
                var deletedCount = connection.Delete(entity);

Delete anonymous object (where-clause built up from anonymous object)

                var deletedCount = connection.Delete("delete from test", new { Name = "Johan" });

The Code:

public static class DapperExtensions
{
    public static void Insert(this IDbConnection connection, object entityToInsert)
    {
        Insert(connection, null, entityToInsert);
    }

    public static void Insert(this IDbConnection connection, string sql, object entityToInsert)
    {
        var name = entityToInsert.GetType().Name;
        var sb = new StringBuilder(sql);
        if (sql == null)
            sb.AppendFormat("insert into {0}", name);
        sb.Append(" (");
        BuildInsertParameters(entityToInsert, sb);
        sb.Append(") values (");
        BuildInsertValues(entityToInsert, sb);
        sb.Append(")");
        connection.Execute(sb.ToString(), entityToInsert);
    }

    public static int Update(this IDbConnection connection, object entityToUpdate)
    {
        return Update(connection, null, entityToUpdate);
    }

    public static int Update(this IDbConnection connection, string sql, object entityToUpdate)
    {
        var idProps = GetIdProperties(entityToUpdate);
        if (idProps.Count() == 0)
            throw new ArgumentException("Entity must have at least one [Key] property");

        var name = entityToUpdate.GetType().Name;

        var sb = new StringBuilder(sql);
        if (sql == null)
            sb.AppendFormat("update {0}", name);

        sb.AppendFormat(" set ");
        BuildUpdateSet(entityToUpdate, sb);
        sb.Append(" where ");
        BuildWhere(sb, idProps.ToArray());

        return connection.Execute(sb.ToString(), entityToUpdate);
    }

    public static int Delete<T>(this IDbConnection connection, T entityToDelete)
    {
        return Delete(connection, null, entityToDelete);
    }

    public static int Delete<T>(this IDbConnection connection, string sql, T entityToDelete)
    {
        var idProps = typeof (T).IsAnonymousType() ? 
            GetAllProperties(entityToDelete) : 
            GetIdProperties(entityToDelete);

        if (idProps.Count() == 0)
            throw new ArgumentException("Entity must have at least one [Key] property");

        var name = entityToDelete.GetType().Name;

        var sb = new StringBuilder(sql);
        if (sql == null)
            sb.AppendFormat("delete from {0}", name);

        sb.Append(" where ");
        BuildWhere(sb, idProps);

        return connection.Execute(sb.ToString(), entityToDelete);
    }

    private static void BuildUpdateSet(object entityToUpdate, StringBuilder sb)
    {
        var nonIdProps = GetNonIdProperties(entityToUpdate).ToArray();

        for (var i = 0; i < nonIdProps.Length; i++)
        {
            var property = nonIdProps;

            sb.AppendFormat("{0} = @{1}", property.Name, property.Name);
            if (i < nonIdProps.Length - 1)
                sb.AppendFormat(", ");
        }
    }

    private static void BuildWhere(StringBuilder sb, IEnumerable<PropertyInfo> idProps)
    {
        for (var i = 0; i < idProps.Count(); i++)
        {
            sb.AppendFormat("{0} = @{1}", idProps.ElementAt(i).Name, idProps.ElementAt(i).Name);
            if (i < idProps.Count() - 1)
                sb.AppendFormat(" and ");
        }
    }

    private static void BuildInsertValues(object entityToInsert, StringBuilder sb)
    {
        var props = GetAllProperties(entityToInsert);

        for (var i = 0; i < props.Count(); i++)
        {
            var property = props.ElementAt(i);
            if (property.GetCustomAttributes(true).Where(a => a is KeyAttribute).Any()) continue;
            sb.AppendFormat("@{0}", property.Name);
            if (i < props.Count() - 1)
                sb.Append(", ");
        }
    }

    private static void BuildInsertParameters(object entityToInsert, StringBuilder sb)
    {
        var props = GetAllProperties(entityToInsert);

        for (var i = 0; i < props.Count(); i++)
        {
            var property = props.ElementAt(i);
            if (property.GetCustomAttributes(true).Where(a => a is KeyAttribute).Any()) continue;
            sb.Append(property.Name);
            if (i < props.Count() - 1)
                sb.Append(", ");
        }
    }

    private static IEnumerable<PropertyInfo> GetAllProperties(object entity)
    {
        return entity.GetType().GetProperties();
    }

    private static IEnumerable<PropertyInfo> GetNonIdProperties(object entity)
    {
        return GetAllProperties(entity).Where(p => p.GetCustomAttributes(true).Any(a => a is KeyAttribute) == false);
    }

    private static IEnumerable<PropertyInfo> GetIdProperties(object entity)
    {
        return GetAllProperties(entity).Where( p => p.GetCustomAttributes(true).Any(a => a is KeyAttribute));
    }
}

public static class TypeExtension
{
    public static Boolean IsAnonymousType(this Type type)
    {
        if (type == null) return false;

        var hasCompilerGeneratedAttribute = type.GetCustomAttributes(typeof(CompilerGeneratedAttribute), false).Count() > 0;
        var nameContainsAnonymousType = type.FullName.Contains("AnonymousType");
        var isAnonymousType = hasCompilerGeneratedAttribute && nameContainsAnonymousType;

        return isAnonymousType;
    }
}

Feel free to fork the code as much as you can, I’m too tired to stay up longer. Dapper is getting really useful

.csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; }
Cross-posted from my blog at http://weblogs.asp.net/jdanforth

Simple Insert Extension for Dapper

johan — Tue, 10 May 2011 17:20:20 GMT

Last week I started using Dapper (dapper-dot-net on Google Code) for a project I’m working on. Dapper is a micro ORM, which extends IDbConnection. It’s very fast and works very well for queries where you want to return both typed and dynamic lists of objects. Have a quick look at the webpage and you’ll see what I mean.

Today I needed to do some inserting, which you can do with the Execute() extension, but you’d have to type out all the “insert into xxx (col1,col2) values (@val1, @val2)” stuff. Some guys suggested to create a dapper.contrib and adding extensions of insert, update, delete and so on but it’s not there yet (at time of writing).

Anyway, the extensions in dapper are already so well written I thought it should be quite easy to just add a dead simple (or stupid if you prefer) Insert() extensions on top of the existing Execute(), and I ended up with this raw unrefactored code. All it does really is building up the SQL for the insert using some property reflection, dapper itself does the heavy lifting:

public static class DapperExtensions
{
    public static void Insert(this IDbConnection connection, 
                              object entityToInsert, string sql = "insert into " )
    {
        var name = entityToInsert.GetType().Name;

        if (sql == "insert into ")
        {
            sql = "insert into " + name + " ";
        }
        sql += " (";
        for (var i = 0; i < entityToInsert.GetType().GetProperties().Length; i++)
        {
            var propertyInfo = entityToInsert.GetType().GetProperties();
            sql += propertyInfo.Name;
            if (i < entityToInsert.GetType().GetProperties().Length - 1)
                sql += ",";
        }
        sql += ") values (";
        for (var i = 0; i < entityToInsert.GetType().GetProperties().Length; i++)
        {
            var propertyInfo = entityToInsert.GetType().GetProperties();
            sql += "@" + propertyInfo.Name;
            if (i < entityToInsert.GetType().GetProperties().Length - 1)
                sql += ",";
        }
        sql += ")";
        connection.Execute(sql, entityToInsert);
    }
}

I’m using it like this with a type:

using (var connection = new SqlConnection(connectionString))
{
    connection.Open();
    var entity = new Test() { Name = "Johan", Age = 43 };
    connection.Insert(entity);
}

public class Test
{
    public string Name { get; set; }
    public int Age { get; set; }
}

…or like this with an anonymous type:

using (var connection = new SqlConnection(connectionString))
{
    connection.Open();
    connection.Insert(new { Name = "Johan", Age = 43 }, "insert into test");
}

Works for me ™

Cross-posted from my blog at http://weblogs.asp.net/jdanforth

Detecting Idle Time with Global Mouse and Keyboard Hooks in WPF

johan — Sat, 19 Mar 2011 11:29:47 GMT

Years and years ago I wrote this blog post about detecting if the user was idle or active at the keyboard (and mouse) using a global hook. Well that code was for .NET 2.0 and Windows Forms and for some reason I wanted to try the same in WPF and noticed that a few things around the keyboard and mouse hooks didn’t work as expected in the WPF environment. So I had to change a few things and here’s the code for it, working in .NET 4.

I took the liberty and refactored a few things while at it and here’s the code now. I’m sure I will need it in the far future as well.

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;

namespace Irm.Tim.Snapper.Util
{
    public class ClientIdleHandler : IDisposable
    {
        public bool IsActive { get; set; }

        int _hHookKbd;
        int _hHookMouse;

        public delegate int HookProc(int nCode, IntPtr wParam, IntPtr lParam);
        public event HookProc MouseHookProcedure;
        public event HookProc KbdHookProcedure;

        //Use this function to install thread-specific hook.
        [DllImport("user32.dll", CharSet = CharSet.Auto,
             CallingConvention = CallingConvention.StdCall)]
        public static extern int SetWindowsHookEx(int idHook, HookProc lpfn,
            IntPtr hInstance, int threadId);

        //Call this function to uninstall the hook.
        [DllImport("user32.dll", CharSet = CharSet.Auto,
             CallingConvention = CallingConvention.StdCall)]
        public static extern bool UnhookWindowsHookEx(int idHook);

        //Use this function to pass the hook information to next hook procedure in chain.
        [DllImport("user32.dll", CharSet = CharSet.Auto,
             CallingConvention = CallingConvention.StdCall)]
        public static extern int CallNextHookEx(int idHook, int nCode,
            IntPtr wParam, IntPtr lParam);

        //Use this hook to get the module handle, needed for WPF environment
        [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr GetModuleHandle(string lpModuleName);

        public enum HookType : int
        {
            GlobalKeyboard = 13,
            GlobalMouse = 14
        }

        public int MouseHookProc(int nCode, IntPtr wParam, IntPtr lParam)
        {
            //user is active, at least with the mouse
            IsActive = true;
            Debug.Print("Mouse active");

            //just return the next hook
            return CallNextHookEx(_hHookMouse, nCode, wParam, lParam);
        }

        public int KbdHookProc(int nCode, IntPtr wParam, IntPtr lParam)
        {
            //user is active, at least with the keyboard
            IsActive = true;
            Debug.Print("Keyboard active");

            //just return the next hook
            return CallNextHookEx(_hHookKbd, nCode, wParam, lParam);
        }

        public void Start()
        {
            using (var currentProcess = Process.GetCurrentProcess())
            using (var mainModule = currentProcess.MainModule)
            {

                if (_hHookMouse == 0)
                {
                    // Create an instance of HookProc.
                    MouseHookProcedure = new HookProc(MouseHookProc);
                    // Create an instance of HookProc.
                    KbdHookProcedure = new HookProc(KbdHookProc);

                    //register a global hook
                    _hHookMouse = SetWindowsHookEx((int)HookType.GlobalMouse,
                                                  MouseHookProcedure,
                                                  GetModuleHandle(mainModule.ModuleName),
                                                  0);
                    if (_hHookMouse == 0)
                    {
                        Close();
                        throw new ApplicationException("SetWindowsHookEx() failed for the mouse");
                    }
                }

                if (_hHookKbd == 0)
                {
                    //register a global hook
                    _hHookKbd = SetWindowsHookEx((int)HookType.GlobalKeyboard,
                                                KbdHookProcedure,
                                                GetModuleHandle(mainModule.ModuleName),
                                                0);
                    if (_hHookKbd == 0)
                    {
                        Close();
                        throw new ApplicationException("SetWindowsHookEx() failed for the keyboard");
                    }
                }
            }
        }

        public void Close()
        {
            if (_hHookMouse != 0)
            {
                bool ret = UnhookWindowsHookEx(_hHookMouse);
                if (ret == false)
                {
                    throw new ApplicationException("UnhookWindowsHookEx() failed for the mouse");
                }
                _hHookMouse = 0;
            }

            if (_hHookKbd != 0)
            {
                bool ret = UnhookWindowsHookEx(_hHookKbd);
                if (ret == false)
                {
                    throw new ApplicationException("UnhookWindowsHookEx() failed for the keyboard");
                }
                _hHookKbd = 0;
            }
        }

        #region IDisposable Members

        public void Dispose()
        {
            if (_hHookMouse != 0 || _hHookKbd != 0)
                Close();
        }

        #endregion
    }
}

The way you use it is quite simple, for example in a WPF application with a simple Window and a TextBlock:

<Window x:Class="WpfApplication2.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    <Grid>
        <TextBlock Name="IdleTextBox"/>
    </Grid>
</Window>

And in the code behind we wire up the ClientIdleHandler and a DispatcherTimer that ticks every second:

public partial class MainWindow : Window
{
    private DispatcherTimer _dispatcherTimer;
    private ClientIdleHandler _clientIdleHandler;

    public MainWindow()
    {
        InitializeComponent();
    }

    private void Window_Loaded(object sender, RoutedEventArgs e)
    {
        //start client idle hook
        _clientIdleHandler = new ClientIdleHandler();
        _clientIdleHandler.Start();
        
        //start timer
        _dispatcherTimer = new DispatcherTimer();
        _dispatcherTimer.Tick += TimerTick;
        _dispatcherTimer.Interval = new TimeSpan(0, 0, 0, 1);
        _dispatcherTimer.Start();
    }

    private void TimerTick(object sender, EventArgs e)
    {
        if (_clientIdleHandler.IsActive)
        {
            IdleTextBox.Text = "Active";
            //reset IsActive flag
            _clientIdleHandler.IsActive = false;    
        }
        else IdleTextBox.Text = "Idle";
    }
}

Remember to reset the ClientIdleHandle IsActive flag after a check.

Cross-posted from my blog at http://weblogs.asp.net/jdanforth

Learning about CQRS and Event Sourcing

ericqu — Sun, 06 Mar 2011 21:27:00 GMT

In my struggle to use Domain-Driven Design (DDD) in better ways to get more value out of it and not ending up with anemic models, I began reading about Command Query Responsibility Segregation (CQRS) and Event Sourcing. These are two patterns that fit very well with DDD and two of the most influent thinkers in this area is Greg Young and Udi Dahan. In this post I will simply list a couple of resources that I have found to be very useful, but first let’s start with some of the reasons why I believe this is so interesting:

When combining CQRS and Event Sourcing you will have a built-in integration model. For me, this is huge, since when is the last time you build an application/system in isolation? The problem often is that the need for integration is not taken care of until late in the project and then we add something on top of what we created more common than not with an unsatisfied result.
CQRS offers great separation of concerns and removes the need for supporting reporting in the domain model.
The application/system is built with three relatively loose coupled parts (domain model, read model and user interface) that can be developed and evolved independently from each other.
We store all events generated by the system (Event Sourcing). I believe events will get more and more attention over the coming years (if not Event-Driven Architecture and BI has already put a lot of focus on it) and it opens for many interesting business scenarios.
It is bare bone. This can sound strange, but during the last years I have tried many new frameworks (for example different O/R mappers, WCF RIA Services and so on) without getting the “reward” I’ve been hoping for. In my lab project so far I have not used any frameworks, but I don’t believe that I ‘m writing more code. Rather I find my code becoming better in many ways (easier to read and maintain, better separation of concerns, faster and more).
It fits very well with both cloud and SOA.
Offers some really good way to do unit testing (or at least I have learned better ways to do it when learning about CQRS and Event Sourcing).

There are more reasons which is outlined in many of the following resources that I’ve found good to start with:

1 hour introductionary video by Greg Young covering both CQRS and Event Sourcing.
1 2/3 hours video by Udi Dahan focusing on CQRS.
6,5 hours video by Greg Young going into more depth. I recommend you to take the time to watch this even though it is long. It can also be downloaded.
http://cqrs.wordpress.com/
Greg Young’s blog
nCQRS - .NET Open Source framework for CQRS and Event Sourcing
The CQRS forum

Of course Domain-Driven Design by Eric Evans is pre-requisite and Jimmy Nilsson’s Applying Domain-Driven Design and Patterns book is also a good read.

The Small Things: Asynchronous WCF Calls Without Setting Up Service Reference

ericqu — Sat, 29 Jan 2011 12:49:01 GMT

When you are developing both the service and the client it can many times be good to not use the “Add Service Reference” in Visual Studio. Instead the service and data contracts can be defined in a shared class library. There can be many reasons for this, on popping up immediately is that such a solution removes the need to always update the service reference as the service contract evolves. A “showstopper” could be that when using the ChannelFactory to create the proxy there are no asynchronous methods there to call. Lets start with a small example.

[ServiceContract(Name = "ProjectService", Namespace = Constants.Namespace)]
public interface IProjectService
{
    [OperationContract]
    ProjectDetails GetProjectById(Guid id);
}

This simple service interface could be used on the client with the help of ChannelFactory:

factory = new ChannelFactory<IProjectService>(“*”); 
IProjectService proxy = factory.CreateChannel();

The problem now is that we most often should make the calls to services asynchronous so that the client is not blocked. What we need to do to solve this is the create a client interface that exposes the asynchronous methods. In this case it will look like this:

[ServiceContract(Name = "ProjectService", Namespace = Constants.Namespace)]
public interface IProjectServiceClient : IProjectService
{
    [System.ServiceModel.OperationContractAttribute(AsyncPattern = true, 
        Action = Constants.Namespace + "ProjectService/GetProjectById", 
        ReplyAction = Constants.Namespace + "ProjectService/GetProjectByIdResponse")]
    System.IAsyncResult BeginGetProjectById(System.Guid id, System.AsyncCallback callback, object asyncState);

    ProjectDetails EndGetProjectById(System.IAsyncResult result);
}

Now all we need to do is of course switch the IProjectService to IProjectServiceClient in the ChannelFactory code and the asynchronous methods will be available. Oh … and one last thing, don’t forget to also change IProjectService to IProjectServiceClient in you client config file.