Nikos Baxevanis

The GitHub way of blog discussion and commenting

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 28 Apr 2013 00:00:00 GTB Daylight Time

Using the underlying power of GitHub, blog authors often take a step further and roll their own discussion and commeting systems.

The best examples are:

With the evolution of blog-aware static site generators, like Jekyll, GitHub is becoming a central part for hosting both blog content and comments.

Hackers, Developers, Programmers

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Thu, 18 Apr 2013 00:00:00 GTB Daylight Time

The definitions about Hackers, Developers, and Programmers, that I like best are:

“Hackers are generally loners who don’t care if others can figure out their code (at least while they are in the mode or role of hacking). Thus, they build their own little world in it that fits themselves nicely so that they can hack fast, but the rest of the world be damned.” — c2.com/wiki

“On the ‘programmer’ vs. ‘developer’ debate: ‘Programmer’ focuses on the ‘craft’. ‘Developer’ focuses on the business. Both are valuable.” — @ploeh on twitter

I am a programmer — You?

xUnit.net Attributes Execution Order

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 10 Mar 2013 00:00:00 GTB Standard Time

The test below uses the xUnit.net framework and executes twice, since it is decorated with two data sources. The first data source is the built-in [InlineData] and the second data source is the custom [StringData].

[Theory]
[InlineData("foo", "bar")]
[StringData]
[Intercept]
public void Test(string a, string b)
{
}

xUnit.net invokes in exact order:

Initialization

[InlineData] consturctor
[StringData] consturctor
[InlineData] IEnumerable<object[]> GetData(MethodInfo, Type[])
[StringData] IEnumerable<object[]> GetData(MethodInfo, Type[])

1st Run

[Intercept] consturctor
[Intercept] void Before(MethodInfo)
[Theory] supplying values for a and b taken from either [InlineData] or [StringData]
[Intercept] void After(MethodInfo)

2nd Run

[Intercept] .ctor
[Intercept] void Before(MethodInfo)
[Theory] supplying values for a and b taken from either [InlineData] or [StringData]
[Intercept] void After(MethodInfo)

Remarks

[Intercept] is defined as:

internal class InterceptAttribute : BeforeAfterTestAttribute
{
    public override void Before(MethodInfo methodUnderTest)
    {
    }

    public override void After(MethodInfo methodUnderTest)
    {
    }
}

It allows code to be run before and after each test is run.

[StringData] is defined as:

internal class StringDataAttribute : DataAttribute
{
    public override IEnumerable<object[]> GetData(
        MethodInfo methodUnderTest,
        Type[] parameterTypes)
    {
        yield return new object[] { "cow", "zoo" };
    }
}

XCOPY deployment for Code Contracts

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Mon, 04 Mar 2013 00:00:00 GTB Standard Time

If you don’t wish to install Code Contracts through the Windows Installer:

Go to \Program Files (x86)\MSBuild\4.0\Microsoft.Common.Targets\ImportAfter folder.
Create a new file with name CodeContractsAfter.targets and paste the following XML:

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <CodeContractsInstallDir Condition="'$(CodeContractsInstallDir)'==''">CONTRACTS_PATH</CodeContractsInstallDir>
  </PropertyGroup>
  <Import Condition="'$(CodeContractsImported)' != 'true' AND '$(DontImportCodeContracts)' != 'true'" 
          Project="$(CodeContractsInstallDir)MsBuild\v4.0\Microsoft.CodeContracts.targets" />
</Project>

Extract the contents from the Code Contracts Windows Installer using the lessmsi tool.
Locate the Contracts folder in the extracted contents.
Replace the CONTRACTS_PATH in CodeContractsAfter.targets with the actual Contracts folder location.

Legacy Code Risk

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 03 Mar 2013 00:00:00 GTB Standard Time

Taking the risk to adjust the architecture of a legacy system and extend it in a nice and clean way.

Creating a context:

Complex domain (e.g. life insurance)
Many technologies are used, tightly coupled (e.g. Redis, db40, iBATIS, Quartz, Sparks, etc).
The model has been designed around the Active Record (anti)pattern.
In a few places there are also DAOs and/or Repositories.
The Service Locator (anti)pattern has been applied everywhere.
Almost everywhere, the SRP has been violated.
Communication with any external Web Service is not guarded with a Circuit Breaker.
And yes.. there are no tests..

(All the above yield sad customers, bugs, and slow performance.)

Against messy, tightly coupled, legacy code.

Strive toward real SOLID principles
Instead of doing Test-After Development Sins write test code trying to drive the SUT API and safely refactoring afterwards. The non-relevant Test Fixture setup is automated with AutoFixture decleratively with the xUnit.net extension.
Instead of using the Service Locator use Dependency Injection patterns, such is Constructor Injection.
Instead of using Active Record, Repositories and DAOs consider using Queries and Commands (as described in the first half of this post). This might result in more classes but each class is going to have one responsibility instead of two or more.

Why it is a risk?

The above require a few changes in the system architecture (e.g. in order to be possible to not use Service Locators, in order to be possible to use Services to query from the database instead of the Active Record way, etc.).

While the required changes are going to (initially) slow down the development process at the end the overall development is going to be faster.

Would you take the risk?

Database Schema Synchronization with SqlPackage.exe

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Mon, 11 Feb 2013 00:00:00 GTB Standard Time

SqlPackage is the descendant of VsDbCmd command-line tool. It creates, deploys, and packages SQL Server databases snapshots into a portable artifact called a DAC package, also known as a DACPAC.

Manual Database Schema Synchronization

Create a New SQL Server Database Project
On the newly created SQL Server Database Project:
- Right Click, Import, Database…
- Right Click, Properties
  - In the Project Settings tab select target platform (e.g. SQL Server 2008)
  - In the SQLCMD Variables tab enter in the Local column the path of SQL Server installation folder. Notice that the Local path overrides the Default path.
Go to SQL > Schema Compare > New Schema Comparison
- Select as source the newly created SQL Server Database Project.
- Select as target the database containing the schema to be synchronized.

Automatic Database Schema Synchronization

When there is no network access in production environment, the synchronization process can be automated.

Thanks to Dimitris Charalampidis who provided the steps below, the database schema synchronization can be automated as follows:

Copy the created ‘.dacpac’ file from SQL Server Database Project build output path to the same folder as SqlPackage.
Open a command console and execute the following command:

sqlpackage.exe /a:Script /sf:$Yourdatabaseproject.dacpac$ /tcs:"Data Source=$ServerName$;Database=$DatabaseName$;User id=$userid$;password=$password$;Trusted_Connection=false;" /op:DBSchemaCompareScript.sql /p:ScriptDeployStateChecks=True /p:BackupDatabaseBeforeChanges=True /p:IgnoreExtendedProperties=True /p:IgnorePermissions=True /p:IgnoreRoleMembership=True /v:Path1="$Path1$" /v:Path2="$Path2$"

Replace:
- $Yourdatabaseproject.dacpac$ with the database project snapshot name you copied in the folder earlier.
- $ServerName$ with the target SQL Server instance name.
- $DatabaseName$ with the target database name.
- $userid$ and $password$ with the SQL Server Authentication credentials.
- $Path1$ and $Path2$ with the path to the SQL Server installation folder.

At this point you may want to add also the /p:GenerateSmartDefaults=True switch to provide a default value when updating a table that contains data with for columns that do not allow null values.

After a few seconds a file named DBSchemaCompareScript.sql will be created (you can change the name with the /op: switch value).

Open the script file with Microsoft SQL Server Management Studio.
Select Query > SQLCMD Mode and execute the query.

After the query executes without errors, the database schema will be synchronized with the latest changes.

Remarks

The following files are required by the SqlPackage if the Microsoft SQL Server Data Tools is not installed in production environment:

SqlPackage.exe
Microsoft.Data.Tools.Schema.Sql.dll
Microsoft.Data.Tools.Utilities.dll
Microsoft.SqlServer.Dac.dll
Microsoft.SqlServer.TransactSql.ScriptDom.dll

Compiling .NET projects in Sublime Text

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Thu, 07 Feb 2013 00:00:00 GTB Standard Time

The subject of this post is the compilation of .NET projects and solutions in Sublime Text using the Build Systems feature.

Sublime Text supports custom Build Systems.

By adding MSBuild as a new Build System, it is possible to build Visual Studio projects and solutions without the Visual Studio IDE installed.

Adding the Source Code

The following steps require a folder with MSBuild project files. In order to be pragmatic, the custom Build System is going to compile the source code of AutoFixture.

Go to File menu, click Open Folder... and select the root folder of the project to be compiled.

Adding the new Build System

Go to Tools menu, Build System, and click New Build System...

Paste the following code to a file:

{
    "cmd": ["C:\\Windows\\Microsoft.NET\\Framework\\v4.0.30319\\MSBuild.exe", "AutoFixture.sln"],
    "working_dir": "${project_path:${folder:${file_path}}}\\Src"
}

Save the file as AutoFixture.sublime-build.

Go to Tools menu, Build System, and select AutoFixture.

The above steps are per MBSuild project file. Repeat the above steps by creating a Build System per MSBuild project file.

Running the Build

Go to Tools menu, and select Build. Alternatively, use the Ctrl+B command.

In the above screenshot, on line 38 a semicolon has been intentionally removed for the demo. After running a build, the compiler detects the missing semicolon.

What about the Tests?

Currently, the easiest way to run the tests is by using a command-line interface version of the test runner.

On my machine, attempting to add a new Build System for the tests resulted in high memory usage. This has been tested while Sublime Text 3 was in beta (Build 3010).

Commit to Revision Control with Care

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Tue, 01 Jan 2013 00:00:00 GTB Standard Time

We should always commit to revision control with care.

Often, developers provide commit messages that are incomplete, lowercase, with orthographic permutations. Even worse, snapshots can contain code that doesn’t even compile.

In a signed document the rules and regulations can be altered and then another document is going to be created and signed, but the original document will always remain signed.

As signatures in documents can’t be erased so do recorded snapshots, at least it is not always an easy task.

After a snapshot has been recorded it acts like a signature for the developer – should we ever put our signature roughly?

ReSharper - The Good Parts (Static Code Analysis)

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Thu, 06 Dec 2012 00:00:00 GTB Standard Time

What I really like about ReSharper is the Static code analysis, and the quick-fixes. What I really don’t like is pretty much everything else.

Keeping only the Static code analysis

Go to ReSharper menu and clik Options…

In the Environment > General tab uncheck:

Show tips on startup
Loop selection around ends of a list
Show managed memory usage in status bar

In the Environment > Keyboard & Menus tab select:

Hide overridden Visual Studio menu items (from Menus & Toolbars)
None (from Keyboard Shortcuts)

In the Environment > Editor tab uncheck:

Highlight current line
Auto-format on semicolon brace
Auto-format on closing brace
Use CamelHumps

From Braces and Parentheses uncheck:

Highlight matching delimiters when care is ..
Auto-insert pair brackets, parentheses and quotes
Auto-insert closing brace

In the Environment > IntelliSense > General tab select:

Limited ReSharper IntelliSense and uncheck C#

Uncheck everything in the IntelliSense > Completion Behavior tab.

In the Environment > IntelliSense > Completion Appearance tab select:

Visual Studio IntelliSense font
Uncheck everything else

In the Environment > IntelliSense > Parameter Info tab select:

Arrow keys
Uncheck everything else

Enable Visual Studio IntelliSense

Since we customized ReSharper to use Visual Studio IntelliSense, we have to manually enable it from Visual Studio options.

In Visual Studio, go to Tools menu and click Options…

In the Text Editor > C# tab select:

Auto list members
Parameter information

Suspending ReSharper

There are some projects where I don’t even want to have ReSharper’s Static code analysis and the quick-fixes.

In Visual Studio, go to Tools menu and click Options…

In the ReSharper tab click Suspend.

Empty ASP.NET Web API Project Template

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Fri, 02 Nov 2012 00:00:00 GTB Standard Time

Usually, every time you create a new Web API project you:

Delete almost all the generated code.
Uninstall NuGet packages that you don’t need (yet, or at all).
Remove unused assembly references.
Manually edit the Web.config file(s) to remove the elements that point to the assemblies which have been removed.

Solution

Use the Empty ASP.NET Web API Project Template. The Visual Studio extension can be downloaded from here.

It will add a new project template Empty Web API which includes the following:

Files

Properties\AssemblyInfo.cs
favicon.ico
Global.asax
Web.config

Assemblies

System
System.Core
System.Configuration
System.Net.Http
System.Web
System.Web.Abstractions
System.Web.ApplicationServices
System.Web.Mvc
System.Web.Routing
System.Xml

NuGet packages

Microsoft.AspNet.WebApi.Client
Microsoft.AspNet.WebApi.Core
Microsoft.AspNet.WebApi.WebHost
~~Microsoft.AspNet.Providers.Core~~
Microsoft.Net.Http
Newtonsoft.Json

Remarks

The Newtonsoft.Json package is included because it is lazy loaded inside the System.Net.Http.Formatting.JsonMediaTypeFormatter type.

If you completely remove the Newtonsoft.Json assembly a System.IO.FileNotFoundException exception is thrown with message “Could not load file or assembly ‘Newtonsoft.Json, ..’ or one of its dependencies. The system cannot find the file specified.”

A favicon.ico file is included because the browser requests it so it’s better not to respond with a 404 Not Found.

Exercising the SUT asynchronously

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 28 Oct 2012 00:00:00 GTB Daylight Time

In unit testing, there are times were the SUT has to be exercised asynchronously.

How can we wait for the exercise to complete execution?

An instance of the SUT can be created on the main thread.
The main (waiting) thread spins in user mode while starting the exercise of the SUT asynchronously.
Once the result has been received, the execution continues on the main thread.
The assertion takes place.

The SpinWait synchronization type contains a method named SpinUntil which works perfect for the described scenario.

// Fixture setup
var sut = new ObjectLocalStorage();
sut.Set(@object, expected);
object result = null;

// Exercise system
new Task(() => result = sut.Get(@object)).Start();
SpinWait.SpinUntil(() => result != null);

// Verify outcome
Assert.Equal(expected, result);
// Teardown

Once the Task has been created it is immediately scheduled for execution by calling the Start method.
As long as the unit test runs fast, the waiting thread spins in user mode, which is a good thing.

There is also a SpinUntil overload accepting a TimeSpan timeout.

Truly Constrained Non-Deterministic Numbers in AutoFixture

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Mon, 08 Oct 2012 00:00:00 GTB Daylight Time

Numbers in AutoFixture are currently created using a strictly monotonically increasing sequence.

var fixture = new Fixture();

var i = fixture.CreateAnonymous<int>();
// Prints -> 1
var l = fixture.CreateAnonymous<long>();
// Prints -> 2
var f = fixture.CreateAnonymous<float>();
// Prints -> 3.0

Starting with version 2.13.0, by applying a specific customization numbers can also be created using a constrained non-deterministic sequence. The new customization is called RandomNumericSequenceCustomization.

var fixture = new Fixture()
    .Customize(new RandomNumericSequenceCustomization());

var i = fixture.CreateAnonymous<int>();
// Prints -> 122
var l = fixture.CreateAnonymous<long>();
// Prints -> 38
var f = fixture.CreateAnonymous<float>();
// Prints -> 147.0

Once the customization has been applied to a Fixture instance subsequent requests for numeric types will yield random non-repeatable numbers in the range of [1, 255]. When requesting more than 255 numbers the range is automatically changed to [256, 32767] and so on.

The default ranges are [1, 255], [256, 32767], and [32768, 2147483647].

Supplying a custom range

To supply a custom range, customize an instance of the Fixture class with an instance of the RandomNumericSequenceGenerator and pass to its constructor a sequence of integer numbers (e.g. -100, 100, 255).

The sequence must be two positive or negative numbers optionally followed by a series of greater numbers.

var fixture = new Fixture();
fixture.Customizations.Add(
    new RandomNumericSequenceGenerator(-100, 100, 255));

var i = fixture.CreateAnonymous<int>();
// Prints -> -95
var l = fixture.CreateAnonymous<long>();
// Prints -> 47
var f = fixture.CreateAnonymous<float>();
// Prints -> -82.0

After applying the customization, numbers are now created in the range of [-100, 100]. However, when requesting more numbers than the range size the range is automatically changed to [101, 255].

Statement Completion for Dynamic languages in Sublime Text

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Fri, 05 Oct 2012 00:00:00 GTB Daylight Time

This post describes how to configure Sublime Text in order to get statement completion for JavaScript, Python, (and perhaps PHP, RHTML, Smarty, Mason, Node.js, XBL, Tcl, HTML, HTML5, TemplateToolkit, XUL, Django, Perl, and Ruby).

After following the steps, statement completion will also work for Python projects installed in a virtualenv.

Download Sublime Text from here.
Install on Windows or OS X (it doesn’t really matter).

Install Package Manager

Run Sublime Text
Open the Sublime Text Console. This is accessed via the ctrl + ` shortcut.
Paste the following command into the console (it has to be all in one line):

import urllib2,os; pf='Package Control.sublime-package'; ipp=sublime.installed_packages_path(); os.makedirs(ipp) if not os.path.exists(ipp) else None; urllib2.install_opener(urllib2.build_opener(urllib2.ProxyHandler())); open(os.path.join(ipp,pf),'wb').write(urllib2.urlopen('http://sublime.wbond.net/'+pf.replace(' ','%20')).read()); print 'Please restart Sublime Text to finish installation'

Restart Sublime Text

We have just installed Sublime Package Control – A full-featured package manager that helps discovering, installing, updating and removing packages for Sublime Text 2. It features an automatic updater and supports GitHub, BitBucket and a full channel/repository system.

Configure Statement Completion

Press ctrl + shift + p (Windows, Linux) or cmd + shift + p (OS X).
Type Install Package and select it.

The Install Package command shows a list of all available packages that are available for install. This will include all of the packages from the default channel, plus any from repositories you have added.

Select SublimeCodeIntel from the list of packages.

Configure Statement Completion for Python projects in virtualenv

You may skip this if you are not using virtualenv.

Create a .codeintel directory at the root of the project
Create a config file (without any extension) inside the newly created directory.

{
    "Python": {
        "python": '~/Documents/Projects/VirtualEnvName/bin/python',
        "pythonExtraPaths": ['~/Documents/Projects/VirtualEnvName/lib/python/site-packages',
        ]
    },
}

Note that VirtualEnvName is the name of the virtualenv were the files of the project are located.

The project itself is in ~/Documents/Projects/VirtualEnvName/ProjectName

Statement Completion in action!

A screenshot for jQuery (note also the very cool theme)

Also,

A screenshot for Document Object Model

A screenshot for Python

References:

AutoFixture, xUnit.net, and Auto Mocking

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Tue, 31 Jul 2012 00:00:00 GTB Daylight Time

The features discussed in this post are available when using AutoFixture decleratively with the xUnit.net extension. In addition, it is required to have at least one of the extensions for Auto Mocking using AutoMoq, AutoRhinoMocks, or AutoFakeItEasy.

To install AutoFixture with xUnit.net data theories, run the following command in the Package Manager Console:

PM> Install-Package AutoFixture.Xunit

In the test method below we would like to use xUnit.net data theories to provide:

Auto-generated data specimens for d, s, i, a.
Auto-generated data specimens for _, s, i, a, and inline values for d.
Auto-generated data specimens for _, _, i, a, and inline values for d, s.

public void TestMethod(
    double d, string s, IInterface i, AbstractType a)
{
    Assert.True(
        d != 0    &&
        s != null &&
        i != null &&
        a != null
        );
}

That fact that argument i is an interface and argument a is an abstract class prevents us from using [InlineData], [AutoData], or [InlineAutoData] attributes.

AutoFixture allows us to easily define custom DataAttribute derived types:

By deriving from AutoDataAttribute and passing to the base constructor a customization that enables auto mocking with Moq, Rhino Mocks, or FakeItEasy.
By deriving from CompositeDataAttribute and passing to the base constructor an array of DataAttribute derived type instances, e.g. an instance of InlineDataAttribute and an instance of AutoDataAttribute derived type.

Auto Mocking using Moq

To install AutoFixture with Auto Mocking using Moq, run the following command in the Package Manager Console:

PM> Install-Package AutoFixture.AutoMoq

We decorate the test method with AutoMoqData and InlineAutoMoqData attributes:

[Theory]
[AutoMoqData]
[InlineAutoMoqData(2)]
[InlineAutoMoqData(3, "foo")]
public void WithMoq(
    double d, string s, IInterface i, AbstractType a)
{
    Write(d, s, i, a);
}

Output:

AutoMoqData:
  d = 1
  s = s05080d05-b874-4182-bba5-18678ad9b134
  i = Castle.Proxies.IInterfaceProxy
  a = Castle.Proxies.AbstractTypeProxy
  
InlineAutoMoqData:
  d = 2
  s = sce87888d-8cc8-4f69-927c-c4b1347d3147
  i = Castle.Proxies.IInterfaceProxy
  a = Castle.Proxies.AbstractTypeProxy

InlineAutoMoqData:
  d = 3
  s = foo
  i = Castle.Proxies.IInterfaceProxy
  a = Castle.Proxies.AbstractTypeProxy

Source code:

internal class AutoMoqDataAttribute : AutoDataAttribute
{
    internal AutoMoqDataAttribute()
        : base(new Fixture().Customize(new AutoMoqCustomization()))
    {
    }
}

internal class InlineAutoMoqDataAttribute : CompositeDataAttribute
{
    internal InlineAutoMoqDataAttribute(params object[] values)
        : base(new DataAttribute[] { 
            new InlineDataAttribute(values), new AutoMoqDataAttribute() })
    {
    }
}

More information on AutoFixture with Auto Mocking using Moq can be found at AutoFixture as an auto-mocking container blog post.

Auto Mocking using Rhino Mocks

To install AutoFixture with Auto Mocking using Rhino Mocks, run the following command in the Package Manager Console:

PM> Install-Package AutoFixture.AutoRhinoMocks

We decorate the test method with AutoRhinoMockData and InlineAutoRhinoMockData attributes:

[Theory]
[AutoRhinoMockData]
[InlineAutoRhinoMockData(2)]
[InlineAutoRhinoMockData(3, "foo")]
public void WithRhinoMocks(
    double d, string s, IInterface i, AbstractType a)
{
    Write(d, s, i, a);
}

Ouput:

AutoRhinoMockData:
  d = 1
  s = s01172643-5162-474f-bcfa-319ef40a8272
  i = Castle.Proxies.IInterfaceProxy201f58a5559841bfb41895881489658c
  a = Castle.Proxies.AbstractTypeProxy5a86172bbda14cc098b4c675c5b7e555

InlineAutoRhinoMockData:
  d = 2
  s = sd3b9c112-5181-4daa-9b2f-333c7498044a
  i = Castle.Proxies.IInterfaceProxy201f58a5559841bfb41895881489658c
  a = Castle.Proxies.AbstractTypeProxy5a86172bbda14cc098b4c675c5b7e555
  
InlineAutoRhinoMockData:
  d = 3
  s = foo
  i = Castle.Proxies.IInterfaceProxy201f58a5559841bfb41895881489658c
  a = Castle.Proxies.AbstractTypeProxy5a86172bbda14cc098b4c675c5b7e555

Source code:

internal class AutoRhinoMockDataAttribute : AutoDataAttribute
{
    internal AutoRhinoMockDataAttribute()
        : base(new Fixture().Customize(new AutoRhinoMockCustomization()))
    {
    }
}

internal class InlineAutoRhinoMockDataAttribute : CompositeDataAttribute
{
    internal InlineAutoRhinoMockDataAttribute(params object[] values)
        : base(new DataAttribute[] { 
            new InlineDataAttribute(values), new AutoRhinoMockDataAttribute() })
    {
    }
}

More information on AutoFixture with Auto Mocking using Rhino Mocks can be found at Rhino Mocks-based auto-mocking with AutoFixture blog post.

Auto Mocking using FakeItEasy

To install AutoFixture with Auto Mocking using FakeItEasy, run the following command in the Package Manager Console:

PM> Install-Package AutoFixture.AutoFakeItEasy

We decorate the test method with AutoFakeItEasyData or InlineAutoFakeItEasyData attributes:

[Theory]
[AutoFakeItEasyData]
[InlineAutoFakeItEasyData(2)]
[InlineAutoFakeItEasyData(3, "foo")]
public void WithFakeItEasy(
    double d, string s, IInterface i, AbstractType a)
{
    Write(d, s, i, a);
}

Output:

AutoFakeItEasyData:
  d = 1
  s = s2b4c118b-d18b-4782-992a-d4138c65fd2a
  i = Faked IInterface
  a = Faked AbstractType

InlineAutoFakeItEasyData:
  d = 2
  s = se8da7e09-ea4f-4d16-86bd-4229802e5f5d
  i = Faked IInterface
  a = Faked AbstractType

InlineAutoFakeItEasyData:
  d = 3
  s = foo
  i = Faked IInterface
  a = Faked AbstractType

Source code:

internal class AutoFakeItEasyDataAttribute : AutoDataAttribute
{
    internal AutoFakeItEasyDataAttribute()
        : base(new Fixture().Customize(new AutoFakeItEasyCustomization()))
    {
    }
}

internal class InlineAutoFakeItEasyDataAttribute : CompositeDataAttribute
{
    internal InlineAutoFakeItEasyDataAttribute(params object[] values)
        : base(new DataAttribute[] { 
            new InlineDataAttribute(values), new AutoFakeItEasyDataAttribute() })
    {
    }
}

More information on AutoFixture with Auto Mocking using FakeItEasy can be found at Auto-Mocking with FakeItEasy and AutoFixture blog post.

Composite xUnit.net Data Attributes

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Fri, 27 Jul 2012 00:00:00 GTB Daylight Time

xUnit.net extensions support data-driven tests called Theories. Such tests are similar to regular xUnit.net tests but instead of being decorated with [Fact] they are decorated with [Theory].

Below is a data-driven test with the data coming a Microsoft Excel (.xls) spreadsheet.

[Theory]
[ExcelData("UnitTestData.xls", "SELECT x, y FROM Data")]
public void Foo(object x, object y)
{
    // 'x' and 'y' are values from the .xls spreadsheet.
}

Also, a data-driven test with the data coming from a type implementing the IEnumerable<object[]>.

[Theory]
[ClassData(typeof(CollectionOfSpecifiedString))]
public void Bar(object x, object y)
{
    // 'x' and 'y' are values from the IEnumerable<object[]> type.
}

internal class CollectionOfSpecifiedString : IEnumerable<object[]>
{
    public IEnumerator<object[]> GetEnumerator()
    {
        yield return new object[]
        {
            "foo", "zoo"
        };
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

In the above samples, [ExcelData] and [ClassData] are attributes representing a data source for a data-driven test.

Using data from multiple attributes

Below is a data-driven test with the data coming from a type implementing the IEnumerable<object[]> combined with the data coming from an .xls spreadsheet.

[Theory]
[ClassExcelData(
    typeof(CollectionOfSpecifiedString),
    "UnitTestData.xls", "SELECT x, y FROM Data")]
public void Zoo(object x, object y)
{
    // 'x' is coming from the IEnumerable<object[]> type.
    // 'y' is coming from the .xls spreadsheet.
}

internal class CollectionOfSpecifiedString : IEnumerable<object[]>
{
    public IEnumerator<object[]> GetEnumerator()
    {
        yield return new object[]
        {
            "foo"
        };
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

Creating a composite attribute

The [ClassExcelData] from the previous example is a composite of two xUnit.net’s data attributes [ClassData] and [ExcelData].

All we have to do is create a type deriving from CompositeDataAttribute, passing in its base constructor an array of the data attributes we would like to compose.

[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
internal class ClassExcelDataAttribute : CompositeDataAttribute
{
    internal ClassExcelDataAttribute(Type type, string filename, string selectStatement)
        : base(new DataAttribute[] { 
                new ClassDataAttribute(type), 
                new ExcelDataAttribute(filename, selectStatement) })
    {
    }
}

The description for the CompositeDataAttribute algorithm can be found here.

When defining a composite data attribute, it is acceptable for the first attribute to provide some (or all) data for the parameters of the test method. However, subsequent data attributes must be able to provide the data for the exact position where the previous attribute stopped.

Obtaining the CompositeDataAttribute class

CompositeDataAttribute is currently bundled with AutoFixture extension for xUnit.net. You can use it by installing the AutoFixture.Xunit NuGet package.

Using the Web API Dependency Resolver with Castle Windsor's Scoped Lifetime

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Mon, 16 Jul 2012 00:00:00 GTB Daylight Time

Update: Mark Seemann has provided a solution without using the IDependencyResolver interface.

This post is the result of a very good suggestion in the comments section of the previous post.

The WindsorDependencyScope from the previous post has been modified to use the Scoped lifetime available in Castle Windsor 3.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Http.Dependencies;
using Castle.MicroKernel.Lifestyle;
using Castle.Windsor;

internal sealed class WindsorDependencyScope : IDependencyScope
{
    private readonly IWindsorContainer container;
    private readonly IDisposable scope;

    public WindsorDependencyScope(IWindsorContainer container)
    {
        if (container == null)
        {
            throw new ArgumentNullException("container");
        }

        this.container = container;
        this.scope = container.BeginScope();
    }

    public object GetService(Type t)
    {
        return this.container.Kernel.HasComponent(t) ? this.container.Resolve(t) : null;
    }

    public IEnumerable<object> GetServices(Type t)
    {
        return this.container.ResolveAll(t).Cast<object>().ToArray();
    }

    public void Dispose()
    {
        this.scope.Dispose();
    }
}

The BeginScope is an extension method for the IWindsorContainer type. It returns by default an instance of a CallContextLifetimeScope type. It uses the Call Context so it can be associated with thread pool threads and manually created threads within a single AppDomain (it does not use the Logical Call Context).

On each request the Web API calls the GetDependencyScope extension method of the HttpRequestMessage type, which, in return, calls it’s own BeginScope method to start a new resolution scope. Using our own implementation of the IDependencyResolver interface we always return a new instance of the WindsorDependencyScope type.

internal sealed class WindsorDependencyResolver : IDependencyResolver
{    
    // 'using' Directives and other type members removed for brevity.
    
    public IDependencyScope BeginScope()
    {
        return new WindsorDependencyScope(this.container);
    }
}

Since we use the Scoped lifetime we need to define it also in the registration code. Then, we will always have at most one instance of each requested type per resolution scope (that is, a request).

internal sealed class WebWindsorInstaller : IWindsorInstaller
{
    public void Install(IWindsorContainer container, IConfigurationStore store)
    {
        container.Register(Classes
            .FromAssemblyContaining<ValuesController>()
            .BasedOn<IHttpController>()
            .LifestyleScoped());
    }
}

The source code can be found here.

Using the Web API Dependency Resolver with Castle Windsor (Part 2)

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Mon, 04 Jun 2012 00:00:00 GTB Daylight Time

Update: Mark Seemann has provided a solution without using the IDependencyResolver interface.

The code in this post requires the ASP.NET MVC 4 RC. If you use the Beta version use the code from this post.

Among the many changes in ASP.NET MVC 4 RC, there is now added support for releasing object graphs, resolved on each request, using dependency scopes.

Creating a dependency scope per request

Since the IHttpControllerFactory interface has been removed, the recommendation (from the release notes) is to use the IHttpControllerSelector interface to control IHttpController selection and the IHttpControllerActivator interface to control IHttpController activation.

Below is the IHttpControllerSelector interface:

public interface IHttpControllerSelector
{
    HttpControllerDescriptor SelectController(HttpRequestMessage request);
}

// Other methods removed for brevity.

And the IHttpControllerActivator interface:

public interface IHttpControllerActivator
{
    IHttpController Create(
        HttpRequestMessage request, 
        HttpControllerDescriptor controllerDescriptor, 
        Type controllerType);
}

Both interfaces contain method(s) accepting, among others, an HttpRequestMessage. The trick here is to use the HttpRequestMessage’s extension method GetDependencyScope for resolving controllers (instead of using a DI Container directly).

Internally, the GetDependencyScope method uses the DependencyResolver (registered in the GlobalConfiguration instance) calling it’s BeginScope method which creates a new resolution scope. Objects that are resolved in that scope are tracked internally. Once the scope is disposed, those objects are released (using the container’s Release method).

Below is an implementation of the IDependencyScope interface:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Http.Dependencies;

internal class ReleasingDependencyScope : IDependencyScope
{
    private readonly IDependencyScope scope;
    private readonly Action<object> release;
    private readonly List<object> instances;

    public WindsorDependencyScope(IDependencyScope scope, Action<object> release)
    {
        if (scope == null)
        {
            throw new ArgumentNullException("scope");
        }

        if (release == null)
        {
            throw new ArgumentNullException("release");
        }

        this.scope = scope;
        this.release = release;
        this.instances = new List<object>();
    }

    public object GetService(Type t)
    {
        object service = this.scope.GetService(t);
        this.AddToScope(service);

        return service;
    }

    public IEnumerable<object> GetServices(Type t)
    {
        var services = this.scope.GetServices(t);
        this.AddToScope(services);

        return services;
    }

    public void Dispose()
    {
        foreach (object instance in this.instances)
        {
            this.release(instance);
        }
            
        this.instances.Clear();
    }

    private void AddToScope(params object[] services)
    {
        if (services.Any())
        {
            this.instances.AddRange(services);
        }
    }
}

Having a custom implementation of the IDependencyScope interface, we can now move on with the implementation of the IDependencyResolver interface. The recommendation (from the source code) is to return a new instance of IDependencyScope every time the BeginScope method is called.

An implementation of the IDependencyResolver interface for Castle Windsor could be similar to the one below:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Http.Dependencies;
using Castle.Windsor;

internal class WindsorDependencyResolver : IDependencyResolver
{
    private readonly IWindsorContainer container;

    public WindsorDependencyResolver(IWindsorContainer container)
    {
        if (container == null)
        {
            throw new ArgumentNullException("container");
        }

        this.container = container;
    }

    public object GetService(Type t)
    {
        return this.container.Kernel.HasComponent(t) ? this.container.Resolve(t) : null;
    }

    public IEnumerable<object> GetServices(Type t)
    {
        return this.container.ResolveAll(t).Cast<object>().ToArray();
    }

    public IDependencyScope BeginScope()
    {
        return new ReleasingDependencyScope(this, this.container.Release);
    }

    public void Dispose()
    {
    }
}

As we can see, the BeginScope method returns a new instance of IDependencyScope which can resolve and release objects that belong to that scope.

Moving next, when upgrading from Beta to RC there might be another thing to consider. Since the IHttpControllerFactory interface has now been removed, implementations of that interface were using the controllerName in order to resolve component instances from the DI Containers. As a result, controllers were registered in the DI Containers using names for each registration.

To keep the named registrations (and not break compatibility with any JavaScript clients) we can create a DefaultHttpControllerSelector derived type and override it’s SelectController method. We can then use the DefaultHttpControllerSelector’s GetControllerName method which returns the requested path name (e.g. “Orders”). At that point we can map that name to an ApiController derived type (ex.: OrderController).

A DefaultHttpControllerSelector derived type could be similar to the one below:

using System;
using System.Linq;
using System.Net.Http;
using System.Reflection;
using System.Web.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Dispatcher;

internal class PluralizedNameHttpControllerSelector : DefaultHttpControllerSelector
{
    private readonly HttpConfiguration configuration;
    private readonly Assembly controllerAssembly;

    public PluralizedNameHttpControllerSelector(
        HttpConfiguration configuration, Assembly controllerAssembly)
        : base(configuration)
    {
        if (configuration == null)
        {
            throw new ArgumentNullException("configuration");
        }
            
        if (controllerAssembly == null)
        {
            throw new ArgumentNullException("controllerAssembly");
        }

        this.configuration = configuration;
        this.controllerAssembly = controllerAssembly;
    }

    public override HttpControllerDescriptor SelectController(
        HttpRequestMessage request)
    {
        var controllerName = base.GetControllerName(request);
        var controllerType = this.GetControllerType(controllerName);

        return new HttpControllerDescriptor(
            this.configuration, controllerName, controllerType);
    }

    private Type GetControllerType(string name)
    {
        // Look in 'this.controllerAssembly' and find the types that can be
        // assigned from an instance of IHttpController  and return the one
        // whose name matches with the given name.
    }
}

Make sure to register the above type in Castle Windsor otherwise the framework will pick it’s default implementation.

All the above information is the result of browsing the source code on CodePlex. If any articles or blog posts are released (by the ASP.NET team or individuals) I might create a new post with updates, if necessary.

Migrating from a blogging service to Jekyll and GitHub

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Fri, 25 May 2012 00:00:00 GTB Daylight Time

Since 2010, and until a week ago, I had my site powered up and hosted by a paid blogging service.

The good thing with (paid) blogging services is that they handle:

Storage for posts
Storage for comments
Atom and/or RSS feeds
Support for social networking services
Site analytics
Themes
Customisation

The bad thing with blogging services is that they own your content and are very limited when it comes to:

Access the files via FTP client(s).
Backup/Export posts
Backup/Export comments
Customise the creation of web feeds
Add new social networking services
Add new themes

I believe that nowadays all the above stuff is trivial so it should be done in very simple way.

Thus, one should be able to:

Compose posts on Dillinger, MarkdownPad or even Notepad2.
Customize and style a site using open source templating systems, markdown engines and syntax highlighting tools.
Host the generated output on any web server.

Furthermore, I do believe that in the future we will use (even more):

Twitter for social networking and microblogging.
GitHub for open source and commercial closed source project hosting.

With all the above and since GitHub allows for publishing web content I decided to move into that direction. The migration was successful.

This site is now powered by Jekyll. Using this plugin I was able to keep all the old permalinks and redirect to the new ones.

The only limitation I came across is that GitHub runs Jekyll with the —safe switch and it will not load any custom plugins (for security reasons). However, one can run the site locally and copy the output that is being generated by the plugin and include it in the source.

Some key highlights:

Posts can now be written using Markdown.
The site can be previewed locally by installing the Jekyll Gem.
The creation of web feeds is highly customisable.
The format of permalinks is very flexible.
On each push, GitHub transforms the code (using Jekyll) into a static site.

I like it pretty good, let’s see how it goes.

xUnit.net and AsyncEnumerator to Async and Await

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 06 May 2012 00:00:00 GTB Daylight Time

Prior to .NET 4, one had to implement the APM model in order to expose asynchronous methods. After a couple of years, the AsyncEnumerator class came out to simplify the APM by leveraging the use of C# iterators for asynchrony. In the meantime, Microsoft developed a new model for asynchronous (and parallel) programming. Since the new model was targeting the .NET 4, code written in previous versions have to keep using the AsyncEnumerator class.

I have been using the AsyncEnumerator class since 2008 and it works great. Today we have the new Async and Await keywords in C# 5.0 (together with the many improvements in the CLR) that will ship with .NET 4.5 and the recently added support for async unit tests on version 1.9 of the xUnit.net. So, I decided to move some .NET 2.0 code using AsyncEnumerator to .NET 4.5 using Async and Await.

Below is an interface of the sample type (described in this article) exposing both synchronous and asynchronous versions of a time-consuming method:

public interface IMyType
{
    // Synchronous version of time-consuming method.
    DateTime DoSomething();

    // Asynchronous version of time-consuming method (Begin part).
    IAsyncResult BeginDoSomething(AsyncCallback callback, object state = null);

    // Asynchronous version of time-consuming method (End part).
    DateTime EndDoSomething(IAsyncResult asyncResult);
}

A unit test with the AsyncEnumerator can be similar to the one shown below:

public IEnumerator<int> D(AsyncEnumerator ae)
{
    var sut = new MyType(5);

    sut.BeginDoSomething(ae.End(), state: null);
    yield return 1;
    var result = sut.EndDoSomething(ae.DequeueAsyncResult());
}

However, since xUnit.net does not support methods of type IEnumerator<int>, we need to tell xUnit.net how to execute them:

[Fact]
public void D()
{
    // Drive the D method's iterator asynchronously.
    var ae = new AsyncEnumerator<DateTime>();
    ae.EndExecute(
        ae.BeginExecute(
            this.D(ae), _ => { }));
}

Moving to .NET 4.5 and xUnit.net 1.9 we can create an Extension Method that returns a Task in order to use both the Async and Await keywords in production code and the async unit tests feature of xUnit.net.

// Task-based asynchronous version of time-consuming method.
public static Task<DateTime> DoSomethingAsync(this IMyType t)
{
    return Task<DateTime>.Factory.FromAsync(
        t.BeginDoSomething,
        t.EndDoSomething,
        state: null
        );
}

Now the previous unit test with the AsyncEnumerator can be rewritten as follow:

[Fact]
public async Task D()
{
    var sut = new MyType(5);
    var result = await sut.DoSomethingAsync();
}

This looks very nice and clean. As it seems though, if the class contains many async unit tests they will not run in parallel.

As an example, the following 3 tests will take 3 x 5 = 15 seconds to complete:

[Fact]
public async Task A()
{
    var sut = new MyType(5);
    var result = await sut.DoSomethingAsync();
}

[Fact]
public async Task B()
{
    var sut = new MyType(5);
    var result = await sut.DoSomethingAsync();
}

[Fact]
public async Task C()
{
    var sut = new MyType(5);
    var result = await sut.DoSomethingAsync();
}

The output from xUnit.net:

Output from AsyncUnitTesting.xUnit.net.MyTypeTests.C:
  Started  5/5/2012 10:24:45 AM
  Finished 5/5/2012 10:24:50 AM

Output from AsyncUnitTesting.xUnit.net.MyTypeTests.B:
  Started  5/5/2012 10:24:50 AM
  Finished 5/5/2012 10:24:55 AM

Output from AsyncUnitTesting.xUnit.net.MyTypeTests.A:
  Started  5/5/2012 10:24:50 AM
  Finished 5/5/2012 10:25:00 AM

3 passed, 0 failed, 0 skipped, took 15.26 seconds (xUnit.net 1.9.0 build 1566).

That was the part of moving the unit tests from an older version of xUnit.net (and the AsyncEnumerator) to version 1.9 of xUnit.net (with Async and Await). Apparently, things become more challenging when moving to production code where one needs to deal with stuff such is the SyncrhonizationContext.

A gist with all the source code can be found here.

URI support in AutoFixture

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Thu, 19 Apr 2012 00:00:00 GTB Daylight Time

Starting with version 2.10.0, AutoFixture supports the creation of Uniform Resource Identifiers and the Uri type.

It is now possible to create an anonymous variable for Uri as with any other common type:

var fixture = new Fixture();
var uri = fixture.CreateAnonymous<Uri>();
// Prints -> scheme://257eb39a-8305-4d13-a7cb-0c481b78809a/

By default, both the scheme name and the authority part are obtained from the context. A custom UriScheme class represents the URI scheme name while the authority part is an anonymous variable of type string.

Example URIs along with their component parts can be found here. Since both parts are received from the context, they can be easily customized.

Supplying a custom scheme name

The UriScheme type provides by default the name "scheme". However, by injecting a specific instance of this type we can easily override it with something else (e.g. "http").

var fixture = new Fixture();
fixture.Inject(new UriScheme("http"));
var uri = fixture.CreateAnonymous<Uri>(); 
// Prints -> http://abc9f406-16f2-4e06-b6f9-0750dc115ac3/

Supplying a custom authority

This is preferred only when each test constructs its own instance of the Fixture type since this change will apply for all the strings received from the context.

Since the authority part is a string received from the context, it is possible to modify the base of all strings and get the desired name for the authority.

var fixture = new Fixture();
fixture.Customizations.Add(
    new StringGenerator(() => "autofixture.codeplex.com"));
var uri = fixture.CreateAnonymous<Uri>(); 
// Prints -> scheme://autofixture.codeplex.com/

Supplying a custom Uri

As with any other generated specimen, it is possible to completely take over it's creation. Using a custom ISpecimenBuilder type, each time a Uri is requested, a predefined Uri will be returned.

public class CustomUriBuilder : ISpecimenBuilder
{
    public object Create(object request, ISpecimenContext context)
    {
        if (request == typeof(Uri))
        {
            return new Uri("http://autofixture.codeplex.com");
        }

        return new NoSpecimen(request);
    }
}

var fixture = new Fixture();
fixture.Customizations.Add(new CustomUriBuilder());
var uri = fixture.CreateAnonymous<Uri>(); 
// Prints -> http://autofixture.codeplex.com/

An automatically published release created from the latest successful build can be downloaded from here. The latest version is also live on NuGet.

Extending A Legacy System to the Web

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Mon, 16 Apr 2012 00:00:00 GTB Daylight Time

An ISV sells ordering and billing systems written in C/C++ and VB6. Each system is consisted of two components and all share a relational database containing Tables, Views and Stored Procedures.

A Legacy System

The server component does the data processing, accepting commands from the clients. The commands are stored inside a predefined directory in the form of ASCII-encoded text files. The legacy* command processor repeatedly checks for new text file availability. If a text file is available, it will be processed. This is a continuous process. The only way to update the database is to create and send a command which will be picked up and handled sequentially by the command processor. When a command is handled successfully, the system updates the shared database.

The client component connects to the shared database (accessed in a read-only fashion) to display data on screen and to send pre-defined commands. The client is either a VB6 GUI or a handheld radio device similar to this one.

Nowdays, in order to reach the mobile market, it is quite difficult (and expensive) to maintain and expand the above client as-is. However, since each of the components has no knowledge of the other separate component, the client can be easily replaced.

Moving to HTTP services

The new HTML5 client will consume HTTP services. A service here act as the entry point for creating the ASCII-encoded text files which will be picked up by the legacy command processor.

When the application wants to submit data to be processed (by the legacy command processor) it sends a POST request. At this point, the new system creates a message which is send via a Datatype Channel to its receiver.

The receiver, of each particular message, forwards the processing of the command. A compatible text file is created, which will be picked up by the legacy command processor in order to update the database.

When the application wants to retrieve data it sends a GET request. At that point, the ApiController uses a Gateway (and internally Dapper) to access the shared database.

On refresh, the client sends a new GET request and the ApiController will return the updated data.

Moving to Smartphones, Tablets and HTML5

Now, the client part has to be re-built with HTML5. That way, it will be accessible from the browser, Internet Tablets (similar to this one), and Smartphones.

Initially, Sencha Touch was a very good choice. It even has a designer. There is even Sencha Architect. Everything is written in JavaScript (which is good) and everything runs fast while testing on iPhone, iPad and other similar devices with fast hardware.

The company however is willing to sell the final product to a price which includes the cost of the devices. (That is, a license for 5 users should also include the purchase of 5 mobile devices.) This means that the price for the devices can become orders of magnitude higher than the actual price of the application itself.

The above lead to the fact that the application must ship with a not-so-expensive device. After doing some testing and comparison with other devices, a Sencha Touch application did not perform smoothly in slower hardware (like this one). (The most annoying part was the scrolling.)

After trying everything it looks like jQuery Mobile combined with mustache are the best choices in terms of performance. The redistributable file is packed with PhoneGap and the application performs well even on slower hardware giving the flexibility to select among a wide range of mobile devices.

*"Legacy" The definition that Michael C. Feathers gives in his excellent book.

Using the Web API Dependency Resolver with Castle Windsor

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Fri, 16 Mar 2012 00:00:00 GTB Standard Time

The code in this post requires the ASP.NET MVC 4 Beta. If you use the RC version use the code from this post.

Update: Mark Seemann has provided a great post on this subject.

In this post I will discuss a possible solution for having Castle Windsor resolving types for both MVC controllers and Web API controllers. Since the former is well known I will focus mostly on the Web API part.

A team building a mobile web application uses the ASP.NET MVC stack combined with another web services framework. With the release of the Beta version of ASP.NET MVC 4 they decided to give Web API a try (side by side with MVC controllers) and see if it fits their needs.

The Controller-derived types are used only for rendering the views (the code is written in JavaScript) while the ApiController-derived types are used for returning data to the client.

The DependencyResolver class provides a method called SetResolver which acts as a registration point for resolving dependencies.

Be careful as there are more than one DependencyResolver types. One defined in System.Web.Mvc namespace and one defined in System.Web.Http namespace. We need the latter here.

Once we define the delegates and set a breakpoint we can see what types the framework requests.

At first an instance of the IHttpControllerFactory type is requested:

Followed by a request for an instance of the ILogger type and so on.

The first thing we want to do is to create a type implementing the IHttpControllerFactory interface.

using System.Web.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Dispatcher;
using Castle.MicroKernel;

internal class WindsorHttpControllerFactory : IHttpControllerFactory
{
    private readonly HttpConfiguration configuration;
    private readonly IKernel kernel;

    public WindsorHttpControllerFactory(
        HttpConfiguration configuration, 
        IKernel kernel)
    {
        this.configuration = configuration;
        this.kernel = kernel;
    }

    public IHttpController CreateController(
        HttpControllerContext controllerContext, 
        string controllerName)
    {
        var controller = this.kernel.Resolve<IHttpController>(controllerName);

        controllerContext.Controller = controller;
        controllerContext.ControllerDescriptor = new HttpControllerDescriptor(
            this.configuration, 
            controllerName, 
            controller.GetType());

        return controllerContext.Controller;
    }

    public void ReleaseController(IHttpController controller)
    {
        this.kernel.ReleaseComponent(controller);
    }
}

Note that inside the WindsorHttpControllerFactory class the CreateController method takes a string for the name of the controller. That means we need to use the Windsor's Named method to set a name for each controller registration. (We can also trim the "Controller" part from the name and also pluralize the remaining part.)

foreach (Type controller in typeof(OrderController).Assembly.GetTypes()
    .Where(type => typeof(IHttpController).IsAssignableFrom(type)))
{
    // https://github.com/srkirkland/Inflector/
    string name = Inflector.Pluralize(
        controller.Name.Replace("Controller", ""));

    container.Register(Component
        .For(controller)
        .Named(name)
        .LifestylePerWebRequest());
}

Let's also create a NullLogger implementing the ILogger interface.

using System;
using System.Diagnostics;
using System.Web.Http.Common;

internal class NullLogger : ILogger
{
    public void Log(string category, TraceLevel level, 
        Func<string> messageCallback)
    {
    }

    public void LogException(string category, TraceLevel level, 
        Exception exception)
    {
    }
}

For all the other instances that the framework requests there are default implementations in the System.Web.* assemblies and we can now create a Windsor Installer to encapsulate the registration logic.

using System;
using System.Linq;
using System.Net.Http.Formatting;
using System.Web.Http;
using System.Web.Http.Common;
using System.Web.Http.Controllers;
using System.Web.Http.Dispatcher;
using System.Web.Http.Metadata;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.ModelBinding;
using Castle.MicroKernel.Registration;
using Castle.MicroKernel.SubSystems.Configuration;
using Castle.Windsor;

internal class WebApiInstaller : IWindsorInstaller
{
    public void Install(IWindsorContainer container, IConfigurationStore store)
    {
        container.Register(
            Component.For<IHttpControllerFactory>()
               .ImplementedBy<WindsorHttpControllerFactory>()
               .LifestyleSingleton(),

            Component.For<ILogger>()
               .ImplementedBy<NullLogger>()
               .LifestyleSingleton(),

            Component.For<IFormatterSelector>()
               .ImplementedBy<FormatterSelector>()
               .LifestyleSingleton(),

            Component.For<IHttpControllerActivator>()
               .ImplementedBy<DefaultHttpControllerActivator>()
               .LifestyleTransient(),

            Component.For<IHttpActionSelector>()
               .ImplementedBy<ApiControllerActionSelector>()
               .LifestyleTransient(),

            Component.For<IActionValueBinder>()
               .ImplementedBy<DefaultActionValueBinder>()
               .LifestyleTransient(),

            Component.For<IHttpActionInvoker>()
               .ImplementedBy<ApiControllerActionInvoker>()
               .LifestyleTransient(),

            Component.For<ModelMetadataProvider>()
               .ImplementedBy<CachedDataAnnotationsModelMetadataProvider>()
               .LifestyleTransient(),

            Component.For<HttpConfiguration>()
               .Instance(GlobalConfiguration.Configuration));
    }
}

In the Application_Start method we add the installer and set the delegates for the SetResolver method. That way when the framework requests an IHttpControllerFactory instance, Windsor will supply the one we created earlier.

this.container = new WindsorContainer()
    .Install(new WebApiInstaller());

GlobalConfiguration.Configuration.ServiceResolver.SetResolver(
    serviceType => container.Resolve(serviceType),
    serviceType => container.ResolveAll(serviceType).Cast<object>());

In order to have Windsor resolve regular controllers (side by side) we can create and add another installer as well as an implementation of the IControllerFactory interface.

this.container = new WindsorContainer()
    .Install(new WebMvcInstaller())
    .Install(new WebApiInstaller());

GlobalConfiguration.Configuration.ServiceResolver.SetResolver(
    serviceType => container.Resolve(serviceType),
    serviceType => container.ResolveAll(serviceType).Cast<object>());

ControllerBuilder.Current.SetControllerFactory(
    new WindsorControllerFactory(this.container));

Finally, a gist with all the source code can be found here.

References:

Dynamic Proxy overriding Equals in AutoFixture Likeness

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Mon, 20 Feb 2012 00:00:00 GTB Standard Time

From version 2.9.0 of AutoFixture, the Likeness class contains a new feature for creating a dynamic proxy that overrides Equals on the destination type.

As an example, we want to compare instances of the following types:

public class DoubleParameterType<T1, T2>
{
    public DoubleParameterType(T1 parameter1, T2 parameter2)
    {
        this.Parameter1 = parameter1;
        this.Parameter2 = parameter2;
    }

    public T1 Parameter1 { get; private set; }
    public T2 Parameter2 { get; private set; }
}

public class SingleParameterType<T>
{
    public SingleParameterType(T parameter)
    {
        this.Parameter = parameter;
    }

    public T Parameter { get; private set; }
}

We can have the following syntax (prior to version 2.9.0):

[Fact]
public void TestWithLikeness()
{
    // Fixture setup
    var value = new DoubleParameterType<int, double>(1, 2.0);

    Likeness<DoubleParameterType<int, double>, SingleParameterType<int>> sut 
        = value.AsSource()
               .OfLikeness<SingleParameterType<int>>();
            
    // Exercise system
    var result = sut.Equals(value);
    // Verify outcome
    Assert.True(result);
}

However, from version 2.9.0 there is also a new CreateProxy method on Likeness which returns a proxy of the destination type overriding Equals with Likeness's instance of IEqualityComparer (the SemanticComparer class):

[Fact]
public void TestWithLikenessProxy()
{
    // Fixture setup
    var value = new DoubleParameterType<int, double>(1, 2.0);
            
    SingleParameterType<int> sut
        = value.AsSource()
               .OfLikeness<SingleParameterType<int>>()
               .CreateProxy();
            
    // Exercise system
    var result = sut.Equals(value);
    // Verify outcome
    Assert.True(result);
}

Below is also an example, where we need to verify that an expectation was met:

public class Bar
{
    public string Zip { get; set; }
}

public class Foo
{
    public Bar Bar { get; private set; }

    public void DoSomething(ISomeContext ctx)
    {
        this.Bar = new Bar { Zip = "12345" };
        ctx.DoSomething(this.Bar);
    }
}

public interface ISomeContext
{
    void DoSomething(object request);
}

[Fact]
public void Test()
{
    var foo = new Foo();
    var ctx = new Mock<ISomeContext>();
    foo.DoSomething(ctx.Object);

    var bar = new Bar().AsSource().OfLikeness<Bar>().CreateProxy();
    bar.Zip = "12345";

    ctx.Verify(x => x.DoSomething(bar));
}

Although the new Bar instance is created inside the DoSomething method, we can pass a proxied Bar instance on the mock's Verify method.

Internally, a custom Proxy Generator was written which also supports types with non-parameterless constructors. In order to create proxies of such types, the values from the source have to be compatible with the parameters on the destination constructor. (The mapping between the two is made possible by using the same semantic heuristics, as the default semantic comparison.)

Test-After Development Sins (Ignoring cross-cutting concerns)

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sat, 18 Feb 2012 00:00:00 GTB Standard Time

A series of articles exploring the impact of writing tests after the code is written on the implementation part of SDLC.

Sin No.3: Ignoring cross-cutting concerns.

The problem with this approach becomes very clear. It will be hard and tedious work, inside each test, to create stubs and mocks for each and every aspect. The intent of the unit tests will also look wrong since, in reality, these aspects should not be treated as dependencies of the SUT.

Among others, logging and caching are cross-cutting concerns that can easily slip through the services (making us treat them as normal dependencies).

While the preferred way to model these aspects is using decorators and/or dynamic interceptors, there are many times that we see classes violating the SRP containing all-in-one logging, caching, auditing and other aspects (and even violating the ISP with a coarse-grained Header Interface).

Parameterized Tests for ServiceStack Web Services

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sat, 18 Feb 2012 00:00:00 GTB Standard Time

I have been using ServiceStack's RestServiceBase class with great success. Because of that I started looking for ways to automate a Layer Test for a simple scenario where a client requests a representation of a resource using GET and/or submits data to be processed to the identified resource using POST.

public class CategoryService : RestServiceBase<Category>
{
    public override object OnGet(Category request)  { /* ... */ }
    public override object OnPost(Category request) { /* ... */ }
}

I found a very nice entry on the wiki and after writting a couple of tests I realized that I was repating the following steps over and over:

Copy the base URI on each test case.
Create a new instance of the JsonRestClient class (and preferably cast to IRestClient).

var restClient = (IRestClient)new JsonServiceClient("http://localhost:5000");

One solution is to have the base URI (and even the IRestClient) on a private field inside the test class and use it from all tests. However, a better approach would be to write Parameterized Tests that accept an instance of the IRestClient type.

Fortunately, this can be done using xUnit.net data theories. Furthermore, since the IRestClient is an interface, this is a great scenario for using AutoFixture together with xUnit.net data theories and auto mocking.

Below is a parameterized test:

[Theory, AutoWebData]
public void HttpGetReturnsnNonEmptyResult(IRestClient sut)
{
    var results = sut.Get<Category[]>("/categories");
    Assert.True(results.Any());
}
[Theory, AutoWebData]
public void HttpGetReturnsNonEmptyResultWithId(IRestClient sut)
{
    var expectedId = sut.Get<Category[]>("/categories").First().Id;
    var result = sut.Get<Category>("/categories/" + expectedId);
    Assert.Equal(expectedId, result.Id);
}

The AutoWebData attribute provides auto-generated data specimens generated by AutoFixture as an extention to xUnit.net's Theory attribute.

public sealed class AutoWebDataAttribute : AutoDataAttribute
{
    public AutoWebDataAttribute()
        : base(new Fixture().Customize(new WebModelCustomization()))
    {
    }
}

Inside this attribute class we also pass a new instance of the Fixture class customized in order to supply an instance of the JsonServiceClient when an IRestClient is requested. (You can read more about AutoFixture Customizations here.)

public class WebModelCustomization : CompositeCustomization
{
    public WebModelCustomization()
        : base(
            new RestClientCustomization(),
            new AutoMoqCustomization()) { } 

    private sealed class RestClientCustomization : ICustomization
    {
        public void Customize(IFixture fixture)
        {
            fixture.Inject<IRestClient>(
                new JsonServiceClient("http://localhost:5000"));
        }
    }
}

The advantage of this approach is that we have abstracted the creation of the IRestClient instance from the test itself. The base URI is now hardcoded in only one place (the customization class). Furthermore, we can easily pass other parameters to the test method if necessary.

While this approach is applied to ServiceStack it can be easily generalized and used on other scenarios as well.

Test-After Development Sins (Production Code First)

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sat, 28 Jan 2012 00:00:00 GTB Standard Time

A series of short articles exploring the impact of writing tests after the code is written on the implementation part of SDLC.

Sin No.1: Production Code First.

By not writing tests upfront, the code becomes most of the times a Transaction Script. It usually lives at application boundaries. If not, then it usually delegates all method arguments to a method with the same name inside a Service Layer.

Most of the times, this code is responsible for aspects such is validation and persistence violating the SRP and likely most (if not all) of the other principles of class design.

Even worse, inside those methods, dependencies might be resolved using a Service Locator (which is not good) forcing us to mock the container (if that's an option at all) in order to successfully write unit tests afterwards.

At the end, a lot of time is spent to write a few Fragile Tests, resulting in a system which is (in most other places) not covered by tests at all.

Test-After Development Sins (Header Interfaces)

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sat, 28 Jan 2012 00:00:00 GTB Standard Time

A series of articles exploring the impact of writing tests after the code is written on the implementation part of SDLC.

Sin No.2: Header Interfaces.

A good example is a data access layer combined with the use of an Object-relational mapper (ORM).

While an ORM provides (out of the box) a collection-like interface (ISession, DbContext) for accessing domain objects, most of the time a coarse-grained Header Interface is created on top of that.

Those interfaces usually contain high number of members making the overall architecture extremely inflexible.

The system is usually forced to live with only one implementation for each interface. That implementation is most of the times generalized.

Some examples,

It's nearly impossible, in performance related scenarios, to manually execute SQL or access the IDbConnection.

In order to map data between application boundaries or populate an instance of a view model the exact same implementation is used.

In the second example, the implementation eagerly loads all the entities of an Aggregate Root which hurts performance.

Test-After Development Sins

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sat, 28 Jan 2012 00:00:00 GTB Standard Time

A series of short articles exploring the impact of writing tests after the code is written on the implementation part of SDLC.

Sin No.1: Production Code First.

Sin No.2: Header Interfaces.

Sin No.3: Ignoring cross-cutting concerns.

Sin No.4: Increasing costs.

Sin No.5: Decreasing quality.

Auto-Mocking with FakeItEasy and AutoFixture

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Wed, 14 Dec 2011 00:00:00 GTB Standard Time

AutoFixture can become an auto-mocking container using Moq (described here) and Rhino Mocks (described here).

In addition to the above auto-mocking features it is now possible to use FakeItEasy.

To install AutoFixture with Auto Mocking using FakeItEasy, run the following command in the Package Manager Console:

PM> Install-Package AutoFixture.AutoFakeItEasy

To use it, add an AutoFakeItEasyCustomization to the Fixture instance:

var fixture = new Fixture()
    .Customize(new AutoFakeItEasyCustomization());

Here is a typical usage inside a test method which will automatically create mocked instances using FakeItEasy:

var fixture = new Fixture()
    .Customize(new AutoFakeItEasyCustomization());
var result = fixture.CreateAnonymous<IInterface>();

To explicitly use FakeItEasy inside a test you need to Freeze it first:

[Fact]
public void FixtureCanFreezeFake()
{
    // Fixture setup
    var fixture = new Fixture()
        .Customize(new AutoFakeItEasyCustomization());
    var dummy = new object();
    var fake = fixture.Freeze<Fake<IInterface>>();
    fake.CallsTo(x => x.MakeIt(dummy))
        .Returns(null);
    // Exercise system
    var result = fixture.CreateAnonymous<IInterface>();
    result.MakeIt(dummy);
    // Verify outcome
    A.CallTo(() => result.MakeIt(dummy)).MustHaveHappened();
    // Teardown
}

The above example can be made even more elegant by using AutoData theories:

[Theory, AutoFakeData]
public void FixtureCanFreezeFake([Frozen]Fake<IInterface> fake, IInterface sut)
{
    var dummy = new object();
    sut.MakeIt(dummy);
    A.CallTo(() => sut.MakeIt(dummy)).MustHaveHappened();
}

Below is the code for the AutoFakeDataAttribute class:

public class AutoFakeDataAttribute : AutoDataAttribute
{
    public AutoFakeDataAttribute()
        : base(new Fixture().Customize(new AutoFakeItEasyCustomization()))
    {
    }
}

An automatically published release created from the latest successful build can also be downloaded from here.

RegularExpressionAttribute support in AutoFixture

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 11 Dec 2011 00:00:00 GTB Standard Time

Continuing the support of DataAnnotations as described here and here, there is now added support for the RegularExpressionAttribute class.

Starting with version 2.6.0, when this attribute is applied on a data field AutoFixture will try to generate a value that matches the specified regular expression.

Let's take as an example the following type:

public class RegularExpressionValidatedType
{
    // Allow up to 40 uppercase and lowercase.
    [RegularExpression("^[a-zA-Z''-'\s]{1,40}$")]
    public string Name { get; set; }
    
    [RegularExpression("^http\://[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(/\S*)?$")]
    public string Url { get; set; }
}

Prior to version 2.6.0 if we request an anonymous instance from AutoFixture, by default we would get back an instance of the above type with it's properties containing values similar to those below.

However, from version 2.6.0 AutoFixture can handle requests with regular expressions, through the RegularExpressionAttribute class, by issuing a new request for the specified regular expression pattern.

The idea behind this new feature is that members of a Regular Expression (Regex) can be generated by first transforming the Regex into a Finite-state machine, particularly a Deterministic finite automaton.

You may also watch a short, introductory, video on the subject here. (Although it is for Rex, I find it very descriptive.)

The current implementation uses internally the algorithms provided by the dk.brics.automaton and Xeger packages.

An automatically published release created from the latest successful build can be downloaded from here. The latest version is also live on NuGet.

Fare - Finite Automata/Regex in .NET

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Thu, 24 Nov 2011 00:00:00 GTB Standard Time

Project Fare is an effort to bring a DFA/NFA (finite-state automata) implementation from Java to .NET. There are quite a few implementations available in other languages today. This project aims to fill the gap in .NET.

Fare is a .NET port of the well established Java library dk.brics.automaton with API as close as possible to the corresponding dk.brics.automaton classes. It also includes a port of Xeger which is a Java library for generating random text from regular expressions. The latter is possible in .NET using the Rex tool.

There are currently integration tests utilizing xUnit.net data theories using the [ClassData] attribute. This way, the same test cases can be used across the ported code, the Java code and even compared to the output of Rex.

The source code is here.

Notes from porting Java code to .NET

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sat, 19 Nov 2011 00:00:00 GTB Standard Time

Recently I needed to use a DFA/NFA (finite-state automata) implementation from a Java package in .NET. I could not find a port of this particular package and IKVMC was not an option since I preferred to depend only on the standard library (BCL). So, I decided to port the code myself.

In my case, the Java package didn't have unit tests (at least not publicly available on the website). How could I know that the results of the ported code are the same with the original code?

The solution I came up with was the following:

Write integration tests, one for the ported code and one for the Java code.
- Both tests should have the same, deterministic, input.
Keep porting enough code from the Java source in order to make the test pass.
- Verify that results are the same with the test in Java.
Recursively repeat this process until all tests pass and yield correct results.

An example can be found here with integration tests for ported code and Java (through IKVMC).

During the process of porting I came across a few differences between Java and .NET and particularly:

Multi-dimensional arrays syntax is slightly different.
Substring method parameteres have different meaning.
- In C# we pass StartIndex, Length.
- In Java we pass StartIndex, EndIndex.
In Java, the list and set implementations override equals, etc. The equivalent doesn't happen in .NET.
Java LinkedList Add method appends the specified element to the end of the list. The equivalent in .NET is the AddLast method.
Java LinkedList Remove(int) method removes the element at the specified position in the list and returns the element that was removed from the list. The equivalent in .NET exists only with the use of an extension method.

The following links helped me a lot:

Estimation Quiz

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 16 Oct 2011 00:00:00 GTB Daylight Time

Given some instructions, provide an estimate for the process of assembling a shelf (see picture below).

Academic approach

After spending several minutes thinking, you estimate it to 30 minutes and then start assembling the parts in order to build the shelf.

Pragmatic approach

Depending on the complexity of the assembling and the quality of the given instructions the whole process can fall out of any estimation.

..and from the initial estimate of 30 minutes you can end up in a 10 hours of actual work.

Using class libraries from different platforms

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Tue, 11 Oct 2011 00:00:00 GTB Daylight Time

There are times where we need to use a library written in a different platform than the one we are currently on. Most of the times a port already exists and we can choose to go with that. Before using a port there are some good considerations:

The size of the original codebase.
The kind of project (is it a logger, an ORM, etc).
The current version of the original compared with the ported one. It depends on the activity of the original but if the ported is left 1+ year behind this is not a good sign.
The quality of the ported codebase, framework usage, coding conventions. Does it use recommeded guidelines for the target framework?
The activity of the ported project. If it's low that's a sign that future versions might now show up. However, consider contributing.

Besides ported code, there are cases where we can use a tool that allows us to use the original library from a different platform. For example, when working in .NET we can use Java class libraries through IKVM.NET which has a bytecode compiler called IKVMC.

IKVMC in Action with Hamcrest

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Tue, 11 Oct 2011 00:00:00 GTB Daylight Time

In this post, we saw two possible ways for using code written on a different platform than the one we are working on. Now we will see a scenario where we need to use a Java class library from .NET using the IKVMC tool. We are going to use Hamcrest, a library of matchers for building test expressions.

Before we pass any command line argument to IKVMC we need to detect the dependencies between the jar files. JarAnalyser is a good choice and fortunately there is a tool Jar2ikvmc which uses JarAnalyser to detect dependencies between jar files and then generates command-line script for ikvmc.exe.

The version of Hamcrest that we use is 1.3RC2 and we are going to convert hamcrest-core.jar and hamcrest-library.jar.

Here is the generated script from Jar2ikvmc:

rest-core-1.3.0RC2.jar -target:library
ikvmc hamcrest-library-1.3RC2.jar -target:library -r:hamcrest-core-1.3RC2.dll

Now we can run the generated script on the ikvmc.exe tool. It will generate two .NET assemblies. We can now compare the difference in the syntax with the excellent port NHamcrest by Graham Rhay.

We are going to use the Graham Rhay's Assert class that let us use NHamcrest from xUnit.net.

Here is the code that uses NHamcrest:

public class Assert : Xunit.Assert
{
    public static void That<T>(T actual, IMatcher<T> matcher)
    {
        if (matcher.Matches(actual))
            return;

        var description = new StringDescription();
        matcher.DescribeTo(description);

        var mismatchDescription = new StringDescription();
        matcher.DescribeMismatch(actual, mismatchDescription);

        throw new MatchException(
            description.ToString(),
            mismatchDescription.ToString(),
            null);
    }
}

Here is the code that uses Hamcrest that we coverted using IKVMC:

using org.hamcrest;

public class Assert : Xunit.Assert
{
    public static void That<T>(T actual, Matcher matcher)
    {
        if (matcher.matches(actual))
            return;

        var description = new StringDescription();
        matcher.describeTo(description);

        var mismatchDescription = new StringDescription();
        matcher.describeMismatch(actual, mismatchDescription);

        throw new MatchException(
            description.ToString(),
            mismatchDescription.ToString(),
            null);
    }
}

Here is a unit-test that uses NHamcrest:

using NHamcrest.Xunit
using Xunit;

[Test]
public void Pass()
{
    Assert.That(1, Is.EqualTo(1));
}

Here is a unit-test that uses Hamcrest that we coverted using IKVMC:

using org.hamcrest.core;
using Xunit;

[Fact]
public void EqualTo()
{
    Assert.That(1, IsEqual.equalTo(1));
}

A notable difference is on the different naming conventions (Java methods start with lowercase). However, we can create header interfaces declaring those methods inside.

To sum up, if there is a good quality port we can use the port. In this case, I personally choose to go with NHamcrest. However, we already demoed the alternative approach which also works.

What goes first? (Theory or Tooling)

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Mon, 26 Sep 2011 00:00:00 GTB Daylight Time

A very good friend of mine went to an interview where the interviewer kept asking about the X, Y or Z tool without paying attention to knowledge on the theory behind those tools.

In my opinion it is always better to have a discussion, rather than a cliché interview. During the discussion it would be good to let the developer talk and express opinions on theory, design patterns and principles rather than make questions on specific tools and frameworks. The reason I strongly support that is because languages and tools tend to continuously evolve (and sometimes change directions) while the patterns and principles hardly change.

Tools are implementations of patterns and principles in a specific language. Thus a developer should give priority on the theory behind them rather on the API of a specific tool.

Let's take as an example a Dependency Injection (DI) container. It gives no real value when a developer knows only how to use Spring, Windsor or Unity if lacks fundamental knowledge of DI theory. On the other hand one, that knows how to apply proper OOD design and follows SOLID principles, will use a DI container to compose object graphs in the Composition Root and it's API to effectively apply lifetime management on them.

The same applies when making questions on a specific ORM solution.

StringLengthAttribute support in AutoFixture

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 18 Sep 2011 00:00:00 GTB Daylight Time

Continuing the support of DataAnnotations as described here, there is now added support for the StringLengthAttribute class. Starting with version 2.4.0, when this attribute is applied on a data field it can specify the maximum length of characters that are allowed.

Let's take as an example the following type:

public class StringLengthValidatedType
{
    [StringLength(3)]
    public string Property { get; set; }
}

Prior to version 2.4.0 if we request an anonymous instance from AutoFixture, by default we would get back an instance of the above type with it's Property containing a value similar to the one below.

However, after version 2.4.0 AutoFixture can handle requests with string length constraints through the StringLengthAttribute class by issuing a new request for a constrained string.

An automatically published release created from the latest successful build can be downloaded from here. The latest version is also live on NuGet.

RangeAttribute support in AutoFixture

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Tue, 13 Sep 2011 00:00:00 GTB Daylight Time

Support for types from the System.ComponentModel.DataAnnotations namespace is one of the most voted features for AutoFixture. Starting with version 2.3.1 AutoFixture supports the RangeAttribute class. When this attribute is applied on a data field it can specify the numeric range constraints for it's value.

Let's take as an example the following type:

public class RangeValidatedType
{
    [Range(10, 20)]
    public int Property { get; set; }
}

Prior to version 2.3.1 if we request an anonymous instance from AutoFixture (or better, a specimen from AutoFixture's kernel) we would get back an instance of the above type with it's Property containing a value probably out of the specified numeric range.

However, after version 2.3.1 AutoFixture can handle requests with numeric range constraints through the RangeAttribute class by issuing a new request for a value inside the specified range.

An automatically published release created from the latest successful build can be downloaded from here. The latest version is also live on NuGet.

Heuristics for Static Factory Methods in AutoFixture

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Thu, 25 Aug 2011 00:00:00 GTB Daylight Time

Here is a type with a private constructor:

public class TypeWithFactoryMethod
{
    private TypeWithFactoryMethod() 
    {
    }

    public static TypeWithFactoryMethod Create()
    {
        return new TypeWithFactoryMethod();
    }

    public static TypeWithFactoryMethod Create(object argument)
    {
        return new TypeWithFactoryMethod();
    }
}

In order to create an instance of that type we have to call one of it's static factory methods, for example:

var instance = TypeWithFactoryMethod.Create();

If we try to create an Anonymous Variable with AutoFixture right now (version 2.1) it will throw an exception since there are no public constructors:

var fixture = new Fixture();
var result = fixture.CreateAnonymous<TypeWithFactoryMethod>();

Using the latest version from trunk (and on the next public release) the above code will work. It will successfully return an instance of the type by using a set of heuristics that enable AutoFixture to search for static factory methods.

The latest build (including strong names) can be downloaded from here.

Combining Data Theories in AutoFixture.Xunit extension

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Thu, 25 Aug 2011 00:00:00 GTB Daylight Time

xUnit.net supports parameterized tests via data theories which are types deriving from the Xunit.Extensions.DataAttribute type. Some popular attributes include:

InlineDataAttribute, PropertyDataAttribute and ClassDataAttribute.

AutoFixture.Xunit extension includes a very useful type, for providing auto-data theories, called AutoMoqDataAttribute.

Imagine a Scenario where we have a unit test method with 3 parameters. We want the first parameters to be supplied by InlineData and the rest by AutoFixture using AutoMoqData.

[Theory]
[InlineAutoData("foo")]
[InlineAutoData("foo", "bar")]
public void Test(string s1, string s2, MyClass myClass)
{
}

This is now possible using the InlineAutoDataAttribute type which is now on the trunk and will be available on next public release (after version 2.1). It provides a data source for a data theory, with the data coming from inline values combined with auto-generated data specimens generated by AutoFixture.

InlineAutoDataAttribute derives from CompositeDataAttribute, an implementation of DataAttribute that composes other DataAttribute instances.

Here is how it works:

Delegate the GetData method call to the first attribute.
Loop through the results from the first attribute and check if the length of each object array matches the number of arguments required by the method.
- If so, yield the object array.
- If not, invoke GetData on the next attribute.
  - Throw away the first objects from the result in order to continue from where it ran out of objects from the first result set and concatenate the rest to the previous array.

Recursively repeat this process until all object arrays have the required length.

While this feature comes with AutoFixture.Xunit extension, the CompositeDataAttribute class depends only on the xunit.extensions assembly.

You may compile the code from the latest trunk version, alternatively the latest build (including strong names) can be downloaded from here.

S(ports) is for (Open) Source

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Tue, 23 Aug 2011 00:00:00 GTB Daylight Time

The "Loose Laces" Story

On the weekends, I usually try not to stay in Glyfada. Sometimes I go to country. There, I may invite friends and go out or stay at home.

Usually, in the afternoon I go for a run. Τhere is a 10 km route from my house to the next village. Because of the uphill road on the way back, it takes me 51-53 minutes to run.

I always try to run the route in less than 51 minutes. Nevertheless most of the time I can not do it - either I start too fast (doing first 5KM below 26 minutes) and then get tired or I begin slowly and on the way back it's impossible to go that fast.

However, the last time I run there I started fast, faster than any other time. Reached the 5KM point (the next village) on ~20 minutes and on my way back it took me other ~27 minutes. This is a total of ~47 minutes (!).

Obviously, that was a personal record.

The reason I write all these, is because that one (and only) time that I've made it below 50 minutes, I was running with loosed laces on the right shoe, plus the shoes were not running shoes at all. I noticed the loose lace when I had already started, but I could not do anything since I didn't want to stop the timer.

What I've learned is that, the equiment (non-running shoes) and the conditions (loosed laces) doesn't really matter.

What it does matter is how one truly wants to do something.

Τhe same applies for software.

Enabling Add-In functionality in ASP.NET MVC 3 (Part 2)

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Mon, 22 Aug 2011 00:00:00 GTB Daylight Time

In this post I discussed the implementation of a Unity-specific controller factory that could take a delegate as a parameter in the constructor acting as the fallback factory when the DI container can not supply a controller.

However, I did not really like the initial design. There are cases when the UnityControllerFactory can be used standalone without third party extensiblity in mind.

One possible improvement in the design is to introduce a composite implementation for an IControllerFactory. That way, we still have the chance to supply a MEF-specific controller factory.

A possible implementation of the CreateController method is the one below:

public override IController CreateController(
   RequestContext requestContext, 
   string controllerName)
{
    return (from factory in this.Factories
            let controller = factory.CreateController(
                requestContext, controllerName)
            where controller != null
            select controller).FirstOrDefault();
}

It will iterate through all controller factories calling their CreateController method. The first IController instance provided by the controller factories is returned.

With this implementation, if the Unity-specific controller factory can not provide an IController instance we will ask the next controller factory (MEF-specific controller factory in this example) to provide the IController instance, and so on.

The SetControllerFactory method can accept an instance of a CompositeControllerFactory type as shown below:

private static void BootstrapContainer()
{
    // No direct reference on the container outside this method.
    var unityControllerFactory = new UnityControllerFactory(
        new UnityContainer()
            .Install(Registrator.ForControllers,
                     Registrator.ForServices,
                     Registrator.ForEnterpriseLibrary));


    string extensionsPath = Path.Combine(
        AppDomain.CurrentDomain.BaseDirectory, "Extensions");

    var discoverableControllerFactory = new DiscoverableControllerFactory(
        new CompositionContainer(
            new DirectoryCatalog(extensionsPath))
            );

    ControllerBuilder.Current.SetControllerFactory(
        new CompositeControllerFactory(
            unityControllerFactory, 
            discoverableControllerFactory)
            );
}

Implementation, Unit tests and NuGet Package. Sample application available here.

Enabling Add-In functionality in ASP.NET MVC 3

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Mon, 08 Aug 2011 00:00:00 GTB Daylight Time

Update: Part 2

I remember, back in 2006 when I wrote my first managed add-in for AutoCAD. The fact that we could extend the functionality of a very big product, using .NET was huge. Till that time, if we wanted to use .NET for add-in functionality we had to rely on RCW or else we had to write messy and error-prone VBA code.

Today, anyone who builds applications in managed code (using .NET 4 and above) has built-in functionality for extensibility provided by the framework itself. In this post, we will be extending an ASP.NET MVC 3 application. We are going to use Unity as the Dependency Injection (DI) container and the types from the System.ComponentModel.Composition namespace (or else, MEF) for managing the composition of parts.

The host application, is the one shown below. I have selected the interesting types that I will be discussing.

DiscoverableControllerFactory

A MEF-specific DefaultControllerFactory derived type. It gets the exported types with the contract name, derived from an IController type. After the controller is supplied, the MVC framework will resolve the Views.

internal sealed class DiscoverableControllerFactory : DefaultControllerFactory
{
    private readonly CompositionContainer compositionContainer;

    public DiscoverableControllerFactory(
        CompositionContainer compositionContainer)
    {
        this.compositionContainer = compositionContainer;
    }

    public override IController CreateController(
        RequestContext requestContext, 
        string controllerName)
    {
        Lazy<IController> controller = this.compositionContainer
          .GetExports<IController, IDictionary<string, object>>()
          .Where(c => c.Metadata.ContainsKey("controllerName")
                   && c.Metadata["controllerName"].ToString() == controllerName)
          .First();

        return controller.Value;
    }
}

UnityControllerFactory

A Unity-specific DefaultControllerFactory derived type. There are many implementations around. The difference from other implementations is that this one takes a delegate as a parameter in the constructor that acts as the fallback factory when the DI container can not supply a controller. This is a very important part of our architecture because here we have the chance to supply the target controller (as an add-in) using MEF.

internal sealed class UnityControllerFactory : DefaultControllerFactory
{
    private readonly UnityContainer container;
    private Func<RequestContext, string, IController> alternativeFactoryMethod;

    public UnityControllerFactory(
        UnityContainer container,
        Func<RequestContext, string, IController> alternativeFactoryMethod)
    {
        this.container = container;
        this.alternativeFactoryMethod = alternativeFactoryMethod;
    }

    protected override IController GetControllerInstance(
        RequestContext requestContext, 
        Type controllerType)
    {
        IController controller;

        if (controllerType == null)
        {
            try
            {
                string controllerName = requestContext.HttpContext
                    .Request.Path.Replace("/", "");
                return this.alternativeFactoryMethod(
                    requestContext, 
                    controllerName);
            }
            catch
            {
                throw new HttpException(404, string.Format(
                    "The controller for path '{0}' could not be found or it 
                        does not implement IController.",
                    requestContext.HttpContext.Request.Path));
            }
        }

        if (!typeof(IController).IsAssignableFrom(controllerType))
        {
            throw new ArgumentException(string.Format(
                "Type requested is not a controller: {0}", controllerType.Name),
                 "controllerType");
        }

        try
        {
            controller = container.Resolve(controllerType) as IController;
        }
        catch (Exception e)
        {
            throw new InvalidOperationException(string.Format(
                "Error resolving controller {0}", controllerType.Name), e);
        }

        return controller;
    }
}

Global.asax

Here we specify the default path for the extensions. We create a new instance of the DiscoverableControllerFactory class passing a CompositionContainer and a DirectoryCatalog. Keep in mind that the DirectoryCatalog is one of the many choices that MEF provides for discovering parts. Besides the creation of the DiscoverableControllerFactory we also create a new instance of the UnityControllerFactory class acting as the default controller factory. Any controllers that this factory can not supply will fallback to the DiscoverableControllerFactory using it's CreateController method. One last thing to note, this is the application's Composition Root. The DI container is referenced here, where the composition happens, and nowhere else in the entire application.

private static void BootstrapContainer()
{
    string extensionsPath = Path.Combine(
        AppDomain.CurrentDomain.BaseDirectory, "Extensions");

    var discoverableControllerFactory = new DiscoverableControllerFactory(
        new CompositionContainer(
            new DirectoryCatalog(extensionsPath)));

    // No direct reference on the container outside this method.
    var unityControllerFactory = new UnityControllerFactory(
        new UnityContainer()
            .Install(Registrator.ForControllers,
                     Registrator.ForServices,
                     Registrator.ForEnterpriseLibrary),
        fallbackFactoryMethod: discoverableControllerFactory.CreateController);

    ControllerBuilder.Current.SetControllerFactory(unityControllerFactory);
}

protected void Application_Start()
{
    AreaRegistration.RegisterAllAreas();

    RegisterGlobalFilters(GlobalFilters.Filters);
    RegisterRoutes(RouteTable.Routes);

    BootstrapContainer();
}

The add-in application is a regular class library and it's structure is shown below. I have selected the interesting types that I will be discussing.

ConceptController

This is a proof of concept Controller for this demo. It is decorated with the ExportAttribute and ExportMetadataAttribute. The later is needed in order to help the DiscoverableControllerFactory to choose the right controller among all the controllers supplied by this and other add-ins. The PartCreationPolicyAttribute is needed in order to specify that a new non-shared (transient) instance will be created for each request.

[Export(typeof(IController)), ExportMetadata("controllerName", "Concept")]
[PartCreationPolicy(CreationPolicy.NonShared)]
public class ConceptController : Controller
{
    public ActionResult Index()
    {
        ViewBag.Name = this.GetType().Assembly.FullName;

        return View("~/Extensions/Views/Concept/Index.cshtml");
    }
}

Index.cshtml, Web.config

Nothing special to say here. The razor view is just any other (razor) view. The Web.config is needed as a hint for the MVC framework to compile the razor views at runtime.

Make sure to select all the views and set the property "Copy to Output directory" to "Copy if newer". This is important because each time we compile the add-in library besides the .dll with the models and the controllers we also want the views to be copied there (they are also part of the add-in).

You can download the demo application here. Upon build the Concepts.dll along with it's Views will be copied in the Web project's "Extensions" directory. When run, the application will automatically load the assembly the first time the "Concepts" tab is pressed.

The Small Shelf

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 07 Aug 2011 00:00:00 GTB Daylight Time

The "small shelf" is a shelf in my library where I store my favorite books on Software Development. I like to write code and I am not looking forward to stop, so there are no books there about management (at least, yet).

At the moment, the titles are (from right to left):

Due to the small dimensions of the shelf, when I want to store a new book I have to remove one so I need to carefully consider which one I should remove. Pretty neat process isn't it?

Here are some books not in the shelf, the three from the bottom where recently removed. That doesn't mean they are not good, or I don't like them, or I haven't read them (in any way).

By they way, these are (from bottom to top):

The last two are new, I received the past weeks.

I am curious with HTML5, I think in the following years there is going to be a switch to a unified presentation model using the combination of HTML5, CSS3 and JavaScript. I also believe that using this model, any access to external systems/services/etc is going to happen in a RESTfull way. For that reason, on my Kindle device among other is REST in Practice: Hypermedia and Systems Architecture. I use Kindle a lot, specially when I'm on the plane.

Finally, I currently maintain three Amazon.co.uk wish lists, which I have publicly available:

The last one helps me a lot, since I can save there the book titles I come across and later I can decide what I will buy.

Following the Composition Root pattern with Enterprise Library

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Thu, 04 Aug 2011 00:00:00 GTB Daylight Time

A question that frequently rises when building enterprise applications is: "Where should we compose object graphs?" and the answer is given by the Composition Root pattern: "As close as possible to the applications entry point."

The Composition Root pattern is described in the excellent book, Dependency Injection in .NET by Mark Seemann.

Here is the definition from the book:

A Composition Root is a (preferably) unique location in an application where modules are composed together.

When working with the Enterprise Library, it is very common to hide the complexities of initial context creation by using the built-in IServiceLocator implementation provided by the EnterpriseLibraryContainer class.

Since I completely agree with the statement "Service Locator is an Anti-Pattern" I would like to compose all Enterprise Library modules in the Composition Root. Then, I can use well-known DI patterns (such as Constructor Injection) to supply the Dependencies.

Fortunately, the EnterpriseLibraryContainer class contains a method named "ConfigureContainer" that reads the current configuration and supplies the corresponding type information to configure a dependency injection container (by default Unity).

var configurator = new UnityContainerConfigurator(container);
var configSource = ConfigurationSourceFactory.Create();

EnterpriseLibraryContainer.ConfigureContainer(configurator, configSource);

After configuring the container in the Composition Root we can resolve any instance of a type from Enterprise Library as with any other object.

Creating JSON-enabled ViewModels

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 17 Jul 2011 00:00:00 GTB Daylight Time

Recently, Ian Randall contributed something really cool to the DynamicViewModel codebase: Support for binding to a JSON object. I find this exciting!

In the trunk of DynamicViewModel you can find an example that uses the Stack Exchange API. It is a WPF application for searching the Stack Overflow Users.

All API responses are JSON in Stack Exchange API. Ian took advantage of that and wrote a DynamicViewModelFactory that contains the factory method below:

public static DynamicViewModel Create(string json)
{
    DynamicViewModel result;
    if (!json.TryCreateDynamic(out result))
    {
        throw new ArgumentException("parameter was not a valid JSON string");
    }

    return result;
}

This factory method creates an instance of a DynamicViewModel from a JSON formatted string. In order to use it you need to write code similar to the one below:

var uriString = "http://api.stackoverflow.com/1.1/users?filter=" + e.Argument;
var request   = CreateHttpWebRequest(uriString);
var response  = request.GetResponse();

using (var streamReader = new StreamReader(response.GetResponseStream()))
{
    var json = streamReader.ReadToEnd();
    dynamic viewModel = DynamicViewModelFactory.Create(json);
}

And some XAML action:

<TextBlock
    Grid.Column="0"
    VerticalAlignment="Center"
    Margin="4,0,0,0"
    Text="{Binding display_name}" />
<TextBlock
    Grid.Column="1"
    VerticalAlignment="Center"
    Text="{Binding reputation}" />

<local:BadgesUserControl
    Grid.Column="2"
    DataContext="{Binding badge_counts}" />

The source code is here. Thanks to Ian Randall!

Async REST Client for the Scrumy API

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 17 Jul 2011 00:00:00 GTB Daylight Time

I am a big fan of Scrumy, I must admit that! Scrumy is a simple and intuitive virtual task board based on some concepts of Scrum that helps organize and manage your projects (scrumy.com).

The last weeks I have been thinking of a Visual Studio Extension for viewing (and interacting with) an entire Scrum (Sprints, Stories, Tasks, etc) from inside the IDE. I started building a client library around the Scrumy REST API. I wanted it to be fully asynchronous because I would like to make the Extension UI responsive.

Back a few months ago, I was watching a 5hr webcast on Windows Azure called Windows Azure Deep Dive with Jeffrey Richter were Jeffrey Richter shared among the (fantastic code samples) a fully asynchronous HttpRestClient class. This class is making heavy use of the AsyncEnumerator class (which I am big fan of, till C# 5.0 with async is out) so I though I should build my client around the HttpRestClient class and make also use of the AsyncEnumerator class.

I started by looking at the GET response:

<scrumy>
    <created-at>2011-06-24T21:49:57Z</created-at>
    <time-zone>Central Time (US & Canada)</time-zone>
    <updated-at>2011-06-24T23:38:50Z</updated-at>
    <url>nikos</url>
</scrumy>

<sprints type="array">
    <sprint>
        <created-at>2011-06-24T21:50:53Z</created-at>
        <id>186884</id>
        <start-date>2011-06-24</start-date>
        <updated-at>2011-06-24T21:50:53Z</updated-at>
        <scrumy-url>nikos</scrumy-url>
    </sprint>
</sprints>

Then I created the corresponding classes:

/// <example>
///     <scrumy>
///         <created-at>2011-06-24T21:49:57Z</created-at>
///         <time-zone>Central Time (US & Canada)</time-zone>
///         <updated-at>2011-06-24T21:57:08Z</updated-at>
///         <url>nikos</url>
///     </scrumy>
/// Editable fields: url, time_zone
/// </example>
public sealed class Scrumy
{
    public DateTimeOffset CreatedAt { get; set; }

    public string TimeZone { get; set; }

    public DateTimeOffset UpdatedAt { get; set; }

    public string Url { get; set; }
}

/// <example>
///     <sprints type="array">
///        <sprint>
///            <created-at>2011-06-24T21:50:53Z</created-at>
///            <id>186884</id>
///            <start-date>2011-06-24</start-date>
///            <updated-at>2011-06-24T21:50:53Z</updated-at>
///            <scrumy-url>nikos</scrumy-url>
///        </sprint>
///    </sprints>
/// Editable fields: url, time_zone
/// </example>
public sealed class Sprint
{
    public DateTimeOffset CreatedAt { get; set; }

    public int Id { get; set; }

    public DateTimeOffset StartDate { get; set; }

    public DateTimeOffset UpdatedAt { get; set; }

    public string ScrumyUrl { get; set; }
}

Next I included generic Begin/End methods for supporting the APM inside my class:

private IAsyncResult BeginRequest(
     ScrumyRequest request, 
     Func<XElement, ScrumyResponse> processor, 
     AsyncCallback callback = null,
     object state = null)
{
    var ae = new AsyncEnumerator<ScrumyResponse>(
         string.Format("Method={0}, Uri={1}", request.Method, request.Uri));
    ae.SyncContext = null;
    return apmWrap.Return(ae,
        ae.BeginExecute(MakeRequest(ae, request, processor),
            apmWrap.Callback(ae, callback), state));
}

private new TResponse EndRequest<TResponse>(IAsyncResult result) 
     where TResponse : ScrumyResponse
{
    return (TResponse)apmWrap.Unwrap(ref result).EndExecute(result);
}

private IEnumerator<int> MakeRequest(
     AsyncEnumerator<ScrumyResponse> ae, 
     ScrumyRequest request, 
     Func<XElement, ScrumyResponse> processor)
{
    base.BeginRequest(request.Method, request.Uri, ae.End());
    yield return 1;

    XElement element = base.EndRequestXElement(ae.DequeueAsyncResult());

    ae.Result = processor.Invoke(element);
}

With these helper methods, dealing with the APM was trivial when implementing methods for the Scrumy client. Here are the methods I had to write for getting the Sprints:

public IAsyncResult BeginGetScrumy(
     GetScrumyRequest request, 
     AsyncCallback callback = null, 
     object state = null)
{
    Func<XElement, GetScrumyResponse> processor = element =>
    {
        DateTimeOffset createdAt;
        DateTimeOffset.TryParse(
             element.Element("created-at").Value, out createdAt);

        DateTimeOffset updatedAt;
        DateTimeOffset.TryParse(
             element.Element("updated-at").Value, out updatedAt);

        var scrumy = new Scrumy
        {
            CreatedAt = createdAt,
            TimeZone = element.Element("time-zone").Value,
            UpdatedAt = updatedAt,
            Url = element.Element("url").Value
        };

        return new GetScrumyResponse { Scrumy = scrumy };
    };

    return BeginRequest(request, processor, callback, state);
}

public GetScrumyResponse EndGetScrumy(IAsyncResult ar)
{
    return EndRequest<GetScrumyResponse>(ar);
}

As you notice, only the logic that creates a Sprint object from an XElement is inside the Begin part. Everything else is handled by the helper classes.

Finally, here is how to use it:

AsyncEnumerator ae = new AsyncEnumerator();            
ae.BeginExecute(GetSprint(ae), ae.EndExecute);

private IEnumerator<int> GetSprint(AsyncEnumerator ae)
{
    var request = new GetSprintRequest(client.ProjectName);
            
    client.BeginGetSprint(request, ae.End());
    yield return 1;
            
    var response = client.EndGetSprint(ae.DequeueAsyncResult());
    Assert.NotEmpty(response.Sprints);
}

I am looking forward building as much as I can and then to continue with the Visual Studio Extension.

A gist with all the source code can be found here.

The Mood Mosaic Vol. 13

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 03 Jul 2011 00:00:00 GTB Daylight Time

The Mood Mosaic series is a famous Vinyl compilation with Funk, Rare Groove and Disco tracks ('60s-'80s).

I recently got the Vol. 13 and I really enjoyed the tracks Closer Closer (Celi Bee & The Fuzzy Bunch) and Midnight Groove (Love Unlimited) among others. For the latter, there is a less known re-edit back from 2005. It can be found on Juno and also on Discogs marketplace.

That is the turntable I have (Technics 1210 M5G).

Enjoy.

Mono for Android (Threads Window)

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sat, 25 Jun 2011 00:00:00 GTB Daylight Time

(Couldn't resist..!)

Don't Rely on SQL Membership Provider database schema

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Thu, 23 Jun 2011 00:00:00 GTB Daylight Time

You take the blue pill and the story ends.

However, due to the role-centric nature of many applications, entities rely on the user and it's role(s). On registration, the user choose one or more roles. Each role is associated with behaviors. For each behavior one or more restriction policies apply, etc.

In somes cases, we could decide to take a dependency on the ASP.NET Membership tables and just map on the UserName column of Users table, and the RoleName column of Roles table (also on the UsersInRole table too).

Fabio has a post on how you can do this using ConfORM. In this post I will map only the User and Role tables. In addition, I will demonstrate an elegant approach of assigning different behaviors on the Role entity and mapping them with the RoleName column on the database.

Entities

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;

public class User : Entity<Guid>
{
    public virtual string UserName { get; set; }

    public virtual ICollection<Role> Roles { get; set; }

    public User()
    {
        Roles = new Collection<Role>();
    }
}

public class Role : Entity<Guid>
{
    public virtual string RoleName { get; set; }

    public virtual RoleType RoleType { get; set; }

    public virtual ICollection<User> Users { get; set; }

    public Role()
    {
        Users = new Collection<User>();
    }
}

Mappings

using FluentNHibernate.Mapping;

public sealed class UserMap : ClassMap<User>
{
    public UserMap()
    {
        Table("aspnet_Users");
        LazyLoad();

        Id(x => x.Id).GeneratedBy
            .Assigned().Column("UserId");

        Map(x => x.UserName);

        HasManyToMany(x => x.Roles)
            .Table("aspnet_UsersInRoles");
    }
}

public sealed class RoleMap : ClassMap<Role>
{
    public RoleMap()
    {
        Table("aspnet_Roles");
        LazyLoad();

        Id(x => x.Id).GeneratedBy
            .Assigned().Column("RoleId");

        Map(x => x.RoleName);

        HasManyToMany(x => x.Users)
            .Cascade.All()
            .Inverse()
            .Table("aspnet_UsersInRoles");
    }
}

The RoleName property on our domain model is a string, in order to get mapped with the RoleName column of the table in the database schema.

In order to assign different behaviors on the Role entity we can follow the solution of Jimmy Bogard with the Enumeration class described here.

RoleType class

public class RoleType : Enumeration
{
    public static readonly RoleType Consumer = new ConsumerType();
    public static readonly RoleType Provider = new ProviderType();
    public static readonly RoleType Referrer = new ReferrerType();

    public static readonly RoleType Administrator = new AdministratorType();

    private RoleType() { }
    private RoleType(int value, string displayName)
        : base(value, displayName) { }

    private sealed class ConsumerType : RoleType
    {
        public ConsumerType()
            : base(0, "Consumer") { }

        // TODO: Add behavior for Consumer.
    }

    private sealed class ProviderType : RoleType
    {
        public ProviderType()
            : base(1, "Provider") { }

        // TODO: Add behavior for Provider.
    }

    private sealed class ReferrerType : RoleType
    {
        public ReferrerType()
            : base(2, "Referrer") { }

        // TODO: Add behavior for Referrer.
    }

    private sealed class AdministratorType : RoleType
    {
        public AdministratorType()
            : base(3, "Administrator") { }

        // TODO: Add behavior for Administrator.
    }
}

Adding an IPostLoadEventListener on NHibernate configuration we can easily add logic to set a specific RoleType to each Role entity.

private sealed class RoleToRoleTypeEventListener : IPostLoadEventListener
{
    public void OnPostLoad(PostLoadEvent @event)
    {
        User user = @event.Entity as User;
        if (user != null)
        {
            foreach (Role role in user.Roles)
            {
                AssignRoleTypeToRole(role);
            }
        }
        else
        {
            Role role = @event.Entity as Role;
            if (role != null)
            {
                AssignRoleTypeToRole(role);
            }
        }
    }

    private static void AssignRoleTypeToRole(Role role)
    {
        switch (role.RoleName)
        {
            case "Consumer":
                role.RoleType = RoleType.Consumer;
                break;

            case "Provider":
                role.RoleType = RoleType.Provider;
                break;

            case "Referrer":
                role.RoleType = RoleType.Referrer;
                break;

            case "Administrator":
                role.RoleType = RoleType.Administrator;
                break;
        }
    }
}

The complete Configuration for the ISessionFactory is (or, could be) below:

public static ISessionFactory BuildSessionFactory(IKernel kernel)
{
    var configuration = CreateConfiguration(ForMsSql2008);
    return configuration.BuildSessionFactory();
}

public static FluentConfiguration CreateConfiguration(
     Action<IDbIntegrationConfigurationProperties> db)
{
    var cfg = new NHibernate.Cfg.Configuration();
    cfg.DataBaseIntegration(db)
        .Proxy(p => p.ProxyFactoryFactory<ProxyFactoryFactory>())
        .SessionFactory()
            .GenerateStatistics();

    cfg.EventListeners.PostLoadEventListeners = 
        new IPostLoadEventListener[] { 
            new RoleToRoleTypeEventListener() };

        return Fluently.Configure(cfg)
            .Mappings(AddMappingTypes);
}

..However we already took the red pill and staying in wonderland!

Embrace The Web!

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sat, 04 Jun 2011 00:00:00 GTB Daylight Time

When I'm on the plane, I usually read (on paper or Kindle). The last time was a couple of weeks ago and I was reading the excellent REST in Practise book.

On the first page, Advance Praise for REST in Practice I read this:

Here is the description from the Caelum Objects website:

A restful framework based on the four constraints defined by Roy Fielding. It uses HATEOAS within its core in order to be able to create loosely coupled distributed systems.

I am looking forward trying Restfulie! For those interested, I found the .NET version of the server here and the client implementation here.

Enterprise Library IContainerConfigurator implementation for Windsor

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 15 May 2011 00:00:00 GTB Daylight Time

Alternative title: "Error Management Is Sometimes Exceptionally Difficult, Part 2"

I previously tried to write an implementation of the IContainerConfigurator interface. The most tricky part was extracting the container registration entry for constructing a specific type. The entry is provided in the TypeRegistration class as a LambdaExpression and additional metadata.

The fact that EnterpriseLibraryContainer class is completely decoupled from a specific container implementation made me keep trying to figure out a way to get the entries from the LamdaExpressions.

I posted two questions on StackOverflow, and I got all the necessary info:

Architectural Refactoring overview (from this question).
Use of the ParameterValue subclasses combined with the Visitor pattern over ParameterValues to make the code cleaner (from this question).

The support I had from the project team members was accurate and detailed. That was great.

The current implementation relies heavily on Windsor's Property classes and it is based on the UnityContainerConfigurator.

Below is the WindsorParameterVisitor,

private sealed class WindsorParameterVisitor : ParameterValueVisitor
{
    public Property[] InjectionParameters { get; private set; }

    protected override void VisitConstantParameterValue(
         ConstantParameterValue parameterValue)
    {
        string key = ((MemberExpression)parameterValue.Expression).Member.Name;
        InjectionParameters = new Property[] 
        {
             Property.ForKey(key).Eq(parameterValue.Value) 
        };
    }

    protected override void VisitResolvedParameterValue(
         ContainerResolvedParameter parameterValue)
    {
        InjectionParameters = new Property[] 
        {
             Property.ForKey(parameterValue.Type).Is(parameterValue.Name) 
        };
    }

    protected override void VisitEnumerableParameterValue(
         ContainerResolvedEnumerableParameter parameterValue)
    {
        InjectionParameters = parameterValue.Names
           .Select(name => Property.ForKey(parameterValue.ElementType).Is(name))
           .ToArray();
    }
}

The ParameterValueVisitor class is needed because most TypeRegistrations are quite complex coming with both ConstructorParameters and InjectedProperties and all this stuff must be routed on the .DependsOn() method of Windsor (actually Castle.MicroKernel).

Below is some basic setup for configuring the Enterprise Library to use Windsor,

var container = new WindsorContainer();

// Add a SubResolver for components with IEnumerable<T> dependencies on .ctors.
container.Kernel.Resolver.AddSubResolver(
     new CollectionResolver(container.Kernel));

// This is the Windsor specific impl. of IContainerConfigurator interface.
var configurator = new WindsorContainerConfigurator(container);

// Configure the Enterprise Library Container to use Windsor internally.
EnterpriseLibraryContainer.ConfigureContainer(configurator, 
    ConfigurationSourceFactory.Create());

// Set Current property to a new instance of the WindsorServiceLocator adapter.
EnterpriseLibraryContainer.Current = new WindsorServiceLocator(container);

The source can be found here.

This is tested with Exception Handling application block and I was able to resolve the ExceptionManager class.

Updates on Blog's Source Code Location

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sat, 14 May 2011 00:00:00 GTB Daylight Time

Today I moved all the code samples to a single project named BonusBits.CodeSamples which can be found here. I updated (almost) all the articles and blog posts to reference the new location.

I think it's easier to have everything under a single solution and get updates for everything with a single git-pull cmd ;)

Error Management Is Sometimes Exceptionally Difficult

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Wed, 11 May 2011 00:00:00 GTB Daylight Time

Update: Please also read Part 2. The source ~~is on github~~ has been merged in Enterprise Library Contrib.

I tend to simplify exception handling at layer boundaries, when designing a distributed application. Most of the time if an exception is propagated there I try to apply some kind of policy in order to log the exception and then re-throw a different exception.

When I started using the Exception Handling Application Block from Enterprise Library I found out that I had to also deploy the Unity assemblies.

The call below resolves the registered component for the ExceptionManager class:

EnterpriseLibraryContainer.Current.GetInstance<ExceptionManager>();

The IServiceLocator.Current property of EnterpriseLibraryContainer class sets by default the Unity container (via UnityServiceLocator adapter class).

In fact, if I remove the Unity assemblies a FileNotFoundException is thrown, indicating that Microsoft.Practices.Unity assembly or one of its dependencies could not be found.

Since I use Windsor in that application I didn't like the fact that I had to deploy it with two different IoC containers (!) so I started figuring out how I can call tell the EnterpriseLibraryContainer to resolve the ExceptionManager component using Windsor.

The first thing I did was to compile the Windsor adapter of the CommonServiceLocator against the current version of Windsor that I use (and also run the unit-tests and see if they pass).

Next, I set the IServiceLocator.Current property of the EnterpriseLibraryContainer class:

EntLibraryContainer.Current = new WindsorServiceLocator(container);

The last thing I did was to call the ConfigureContainer method on the EnterpriseLibraryContainer class. This method takes an IContainerConfigurator and an IConfigurationSource as parameters.

Great, so I had to provide a class implementing the IContainerConfigurator interface for the Windsor container.

The IContainerConfigurator interface contains a single method:

void RegisterAll(
     IConfigurationSource configurationSource,        
     ITypeRegistrationsProvider rootProvider
     );

Below is the (currently incomplete) implementation:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using Castle.MicroKernel.Registration;
using Castle.Windsor;
using Microsoft.Practices.EnterpriseLibrary.Common.Configuration;
using Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ContainerModel;

internal sealed class WindsorContainerConfigurator
    : IContainerConfigurator
{
    private readonly IWindsorContainer container;

    public WindsorContainerConfigurator(IWindsorContainer container)
    {
        this.container = container;
    }

    public void RegisterAll(
        IConfigurationSource configurationSource,
        ITypeRegistrationsProvider rootProvider)
    {
        foreach (TypeRegistration registration 
            in rootProvider.GetRegistrations(configurationSource))
        {
            Register(registration);
        }
    }

    private void Register(TypeRegistration registration)
    {
        Type implementation = registration.ImplementationType;

        if (!this.container.Kernel.HasComponent(implementation))
        {
            var componentRegistration =
                Component.For(registration.ServiceType)
                            .ImplementedBy(implementation);

            if (registration.ConstructorParameters.Any())
            {
                var dependencies = GetRegistrationDependencies(
                    componentRegistration, 
                    registration.ConstructorParameters);

                componentRegistration = 
                    componentRegistration.DependsOn(dependencies);
            }

            this.container.Register(AddLifeStyleToRegistration(
                componentRegistration, registration.Lifetime));
        }
    }

    private IDictionary GetRegistrationDependencies<TInterface>(
        ComponentRegistration<TInterface> registration,
        IEnumerable<ParameterValue> constructorParameters)
    {
        var dependencies = new Hashtable();

        foreach (ParameterValue pv in constructorParameters)
        {
            MemberExpression exp = pv.Expression
                as MemberExpression;

            if (exp != null)
            {
                string key = exp.Member.Name;
                object val = GetValue(exp);

                dependencies.Add(key, val);
            }
            else
            {
                // TODO: pv.Expression is a MethodCallExpression.
            }
        }

        return dependencies;
    }

    private static ComponentRegistration<TInterface> AddLifeStyleToRegistration<TInterface>(
        ComponentRegistration<TInterface> registration, 
        TypeRegistrationLifetime typeRegistrationLifetime)
    {
        if (typeRegistrationLifetime == 
            TypeRegistrationLifetime.Singleton)
        {
            registration = registration.LifeStyle.Singleton;
        }
        else if (typeRegistrationLifetime == 
            TypeRegistrationLifetime.Transient)
        {
            registration = registration.LifeStyle.Transient;
        }
        else
        {
            throw new ArgumentOutOfRangeException(
                "typeRegistrationLifetime", 
                "Only Transient and Singleton are supported.");
        }

        return registration;
    }

    private static object GetValue(Expression member)
    {
        var objectMember = Expression.Convert(member, typeof(object));
        var getterLambda = Expression.Lambda<Func<object>>(objectMember);

        return getterLambda.Compile().Invoke();
    }
}

I really don't know what to do in the case of a MethodCallExpression as you can see inside the else block. However, after I can finish with the code inside that block I will be able to do this:

var container = new WindsorContainer();

// Add a SubResolver for components with IEnumerable<T> dependencies on .ctors.
container.Kernel.Resolver.AddSubResolver(
     new CollectionResolver(container.Kernel));

// This is the Windsor specific impl. of IContainerConfigurator interface.
var configurator = new WindsorContainerConfigurator(container);

// Configure the Enterprise Library Container to use Windsor internally.
EnterpriseLibraryContainer.ConfigureContainer(configurator, 
    ConfigurationSourceFactory.Create());

// Set Current property to a new instance of the WindsorServiceLocator adapter.
EnterpriseLibraryContainer.Current = new WindsorServiceLocator(container);

I will try to update the code as soon as I have done any changes.

NHibernate SessionPerRequest with WcfOperationSessionContext (Part 2)

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Fri, 15 Apr 2011 00:00:00 GTB Daylight Time

In the previous post I gave a brief description on how WcfOperationSessionContext can be configured to work. In this post I am going through all the basic steps required to set up a test project that uses WCF for out of process communication and NHibernate for persistence.

Hosting the WCF Service in a Managed Application

To host the service inside a managed application, define an endpoint for the service either imperatively in code, declaratively through configuration, or using default endpoints, and then create an instance of ServiceHost.

internal sealed class Program
{
    public static void Main()
    {
        var svh = new ServiceHost(
            typeof(WcfOperationSessionContextTestService));
        svh.AddServiceEndpoint(typeof(ICurrentSessionContextTestService),
            new NetTcpBinding(), "net.tcp://localhost:56789");

        Bootstrapper.Initialize();
        svh.Open();

        Console.WriteLine("Server ready. Press any key to exit..");
        Console.ReadKey(false);
        svh.Close();
    }
}

Before putting the service to start receiving messages, initialize NHibernate by calling Boostrapper's Initialize method. This creates the ISessionFactory instance that will be used through the entire application. Then call Open on ServiceHost. This creates and opens the listener for the service.

Building the default SessionFactory

internal static class Bootstrapper
{
    public static void Initialize()
    {
        if (SessionFactoryHolder.DefaultSessionFactory != null)
        {
            return;
        }

        var cfg = new Configuration();
        cfg.CurrentSessionContext<WcfOperationSessionContext>()
           .DataBaseIntegration(ForSQLiteInMemory)
           .Proxy(p => p.ProxyFactoryFactory<ProxyFactoryFactory>())
           .SessionFactory()
               .GenerateStatistics();

        SessionFactoryHolder.DefaultSessionFactory = cfg.BuildSessionFactory();
    }

    private static void ForSQLiteInMemory(
        IDbIntegrationConfigurationProperties db)
    {
        db.ConnectionString = "data source=:memory:";
        db.ConnectionReleaseMode = ConnectionReleaseMode.OnClose;
        db.Dialect<SQLiteDialect>();
        db.ConnectionProvider<DriverConnectionProvider>();
        db.Driver<SQLite20Driver>();
        db.BatchSize = 100;
    }
}

The above steps to build the SessionFactory are straightforward. The new Loquacious extension methods are used for the configuration.

Creating a WCF Service for testing the WcfOperationSessionContext

[NHibernateWcfContext]
[ServiceBehavior(
    InstanceContextMode = InstanceContextMode.PerSession)]
internal sealed class WcfOperationSessionContextTestService
    : ICurrentSessionContextTestService
{
    private static readonly ISessionFactory sessionFactory
        = SessionFactoryHolder.DefaultSessionFactory;

    public void RunTests()
    {
        // Show the current session Id for each request.
        Console.WriteLine("SessionId={0}", 
            sessionFactory.GetCurrentSession()
                .GetSessionImplementation().SessionId);

        // Calling GetCurrentSession 2 times returns the SAME instance.
        Debug.Assert(object.ReferenceEquals(
            sessionFactory.GetCurrentSession(), 
            sessionFactory.GetCurrentSession()) == true);
        Console.WriteLine("Passed..");

        // Since session is NOT thread-safe GetCurrentSession does
        // not work from other thread than the one it was created.
        var done = new ManualResetEventSlim(false);
        ThreadPool.QueueUserWorkItem((state) => {
            try
            {
                ((ISessionFactory)state).GetCurrentSession();
            }
            catch (NullReferenceException)
            { 
                Console.WriteLine("Passed..");
            }
            done.Set();
        }, sessionFactory);
        done.Wait();
    }
}

You may find more information about the NHibernateWcfContext attribute in the previous post.

The above tests shows the current session Id for each request. This is useful when debugging in order to ensure that each session is different for each separate call.

Then it checks that calling ISessionFactory's GetCurrentSession method many times it will returns the same instance.

Since the session is not thread-safe ISessionFactory's GetCurrentSession will throw when called from a thread pool thread. (On a thread pool thread one may call ISessionFactory's OpenSession method and work with the session).

WCF Client Configuration

Here is how the client connects to the service in order to run the test method.

internal sealed class Program
{
    private static void Main()
    {
        Console.WriteLine("Press any key when server is ready..");
        Console.ReadKey(false);

        var proxy = new ChannelFactory<ICurrentSessionContextTestSer>(
            new NetTcpBinding(), "net.tcp://localhost:56789");
        ICurrentSessionContextTestService svc = proxy.CreateChannel();

        // Start our loop.
        char operation = (char)0;
        while (operation != 'Q')
        {
            Console.WriteLine("R=Run Tests, Q=Quit?");
            operation = char.ToUpper(Console.ReadKey(true).KeyChar);
            if (operation == 'R') { svc.RunTests(); }
        } 

        proxy.Close();
    }
}

The code can be found here.

NHibernate SessionPerRequest with WcfOperationSessionContext

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Wed, 30 Mar 2011 00:00:00 GTB Daylight Time

Update: You may download a working example using NHibernate, WCF and SQLite in-memory. The example is described also here.

NHibernate 3 comes with out of the box support for the scenario where we want to have a single Session for the lifetime of a WCF request.

Using the Loquacious configuration we can easily set the WcfOperationSessionContext to be the default current session context.

var cfg = NHibernate.Cfg.Configuration();
cfg.DataBaseIntegration(ForMySQL5)
   .CurrentSessionContext<WcfOperationSessionContext>()
   .Proxy(p => p.ProxyFactoryFactory<ProxyFactoryFactory>())
   .SessionFactory()
        .GenerateStatistics();

We also need to inspect inbound and outbound application messages prior to dispatching a request message to an operation (for binding the Session) and before returning a reply (for unbinding the Session).

Here is a specific IDispatchMessageInspector implementation for that:

public sealed class NHibernateWcfContextInitializer
      : IDispatchMessageInspector
  {
      private static readonly ISessionFactory sessionFactory
          = Container.Resolve<ISessionFactory>();

      public object AfterReceiveRequest(
          ref Message request,
          IClientChannel channel,
          InstanceContext instanceContext)
      {
          CurrentSessionContext.Bind(
              sessionFactory.OpenSession());
          return null;
      }

      public void BeforeSendReply(
          ref Message reply,
          object correlationState)
      {
          var session = CurrentSessionContext.Unbind(
               sessionFactory);

          session.Dispose();
      }
  }

Next, we need to define a custom Service Behavior that applies to every single endpoint of a service. To do that we need to define a class that implements the IServiceBehavior interface.

[AttributeUsage(AttributeTargets.Class)]
public sealed class NHibernateWcfContextAttribute
    : Attribute, IServiceBehavior
{
    public void AddBindingParameters(
        ServiceDescription serviceDescription, 
        ServiceHostBase serviceHostBase, 
        Collection<ServiceEndpoint> endpoints, 
        BindingParameterCollection bindingParameters) { }

    public void ApplyDispatchBehavior(
        ServiceDescription serviceDescription, 
        ServiceHostBase serviceHostBase)
    {
        foreach (ChannelDispatcher channelDispatcher 
            in serviceHostBase.ChannelDispatchers)
        {
            foreach (var endpoint in channelDispatcher.Endpoints)
            {
                endpoint.DispatchRuntime.MessageInspectors.Add(
                    new NHibernateWcfContextInitializer());
            }
        }
    }

    public void Validate(
        ServiceDescription serviceDescription, 
        ServiceHostBase serviceHostBase) { }
}

We can now decorate any WCF service implementation with [NHibernateWcfContext] attribute and we can access the Session using the ISessionFactory's GetCurrentSession method.

When using the agatha-rrsl project instead of providing a WcfRequestProcessor define a custom RequestProcessor (deriving from the WcfRequestProcessor) and decorating it with the [NHibernateWcfContext] attribute.

[NHibernateWcfContext]
public sealed class NHibernateWcfRequestProcessor
    : Agatha.ServiceLayer.WCF.WcfRequestProcessor { }

I would generally recommend to try all of the NHibernate's CurrentSessionContext-derived class in order to use the one that suits better for the given context. In some projects I use the WcfOperationSessionContext for the service layer and the ThreadLocalSessionContext when running Job Schedulers.

Data-driven NHibernate with .NET 4.0 and the DynamicEntity Class

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Mon, 28 Mar 2011 00:00:00 GTB Daylight Time

The idea for this post came by a very good friend who wanted to modify his data access layer (DAL) in order to use NHibernate.

The DAL contains a base class that generates SQL queries and the application were it's used is completely data-driven. There is no domain, no classes, and the behaviour is bound in various event handler methods. Changes to the database (columns, row data, etc) dictate how the application behaves.

The problem that comes when trying to port this kind of DAL to use NHibernate is that we have to create POCOs in order to persist everything to the database. Since the application is data-driven we would end up using an anemic domain model holding just the data to persist to the database and no behaviour at all.

The solution for the problem is to use dictionaries as entities, a little-known feature of NHibernate which allows us to define our entities as dictionaries instead of statically typed objects.

Here is how to define a mapping, (notice the entity-name instead of a class name):

The only thing we have is the mapping, no classes. In order to create a Currency object we create the following dictionary:

var currency = new Dictionary<string, object>()
{
    { "ISOCode","GBP" },
    { "EnglishName","United Kingdom Pound" },
    { "ExchangeRateEURtoCurrency",0.87780 },
    { "ExchangeRateUpdatedOn",DateTime.UtcNow },
    { "IsEnabled",true },
    { "Symbol",null }
};

As you can see, the above code is cumbersome. But we can do something about it.

Taking advantage of the .NET 4.0 and the DynamicObject Class, we can create a type deriving from the DynamicObject Class and specify dynamic behaviour at run time.

Let's name our class, DynamicEntity. It must be able to:

Accept a string in the .ctor specifying the entity name.
Set properties (PropertyName = key, PropertyValue = value) on the internal dictionary.
Get properties (similar to above) from the internal dictionary.
Being able to expose the internal dictionary as property for NHibernate usage.
Being able to expose it's name as property for NHibernate usage.

Here is the DynamicEntity class:

using System;
using System.Collections.Generic;
using System.Dynamic;

public sealed class DynamicEntity : DynamicObject
{
    private readonly IDictionary<string, object> dictionary
        = new Dictionary<string, object>();

    private readonly string entityName;

    public DynamicEntity(string entityName)
    {
        this.entityName = entityName;
    }

    public string Name
    {
        get
        {
            return this.entityName;
        }
    }

    public IDictionary<string, object> Map
    {
        get
        {
            return this.dictionary;
        }
    }

    public override bool TryGetMember(
        GetMemberBinder binder, out object result)
    {
        if (!this.dictionary.TryGetValue(binder.Name, out result))
        {
            return false;
        }

        return true;
    }

    public override bool TrySetMember(
        SetMemberBinder binder, object value)
    {
        string key = binder.Name;

        if (this.dictionary.ContainsKey(key))
        {
            this.dictionary.Remove(key);
        }

        this.dictionary.Add(key, value);

        return true;
    }
}

Finally, here is an integration test in action:

[Fact]
public void NHibernateShouldBeAbleToPersistCurrency()
{
    dynamic currency = new DynamicEntity("Currency");

    currency.ISOCode                   = "GBP";
    currency.EnglishName               = "United Kingdom Pound";
    currency.ExchangeRateEURtoCurrency = 0.87780;
    currency.ExchangeRateUpdatedOn     = DateTime.UtcNow;
    currency.IsEnabled                 = true;
    currency.Symbol                    = null;

    object id;

    using (var tx = Session.BeginTransaction())
    {
        id = Session.Save(currency.Name, currency.Map);
        tx.Commit();

        Assert.NotNull(id);
    }

    Session.Clear();

    using (var tx = Session.BeginTransaction())
    {
        var loadedCurrency = Session.Load(currency.Name, id);
        tx.Commit();

        Assert.NotNull(loadedCurrency);
    }

    Session.Flush();
}

In the above test, for Session I use the ISession.GetSession(EntityMode.Map).

Download the sample code here. Updated versions will be available here.

Unit Testing Events (The SpinWait.SpinUntil Method)

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 13 Mar 2011 00:00:00 GTB Standard Time

The SpinWait.SpinUntil method spins until a specified condition is satisfied. This greatly improves the unit testing of events.

Let's see first, how we test an event using hybrid thread synchronization constructs:

[Fact]
public void FooEvent()
{
    bool raised = false;
    ManualResetEventSlim done = new ManualResetEventSlim(false);
    ThreadPool.QueueUserWorkItem(delegate
    {
        Foo += new EventHandler<FooEventArgs>(
            (sender, e) => { raised = true; done.Set(); });
        RaiseFoo();
    }, null);
    done.Wait();
    Assert.True(raised);
}

Here is how the above test looks like when using the SpinWait.SpinUntil method:

[Fact]
public void FooEvent()
{
    bool raised = false;
    ThreadPool.QueueUserWorkItem(delegate
    {
        Foo += new EventHandler<FooEventArgs>(
            (sender, e) => { raised = true; });
        RaiseFoo();
    }, null);
    SpinWait.SpinUntil(() => raised == true);
    Assert.True(raised);
}

The above tests are exactly the same. The one with the SpinWait.SpinUntil method is easier to read and it also requires less code. Pretty cool.

Persistence specification testing combined with AutoFixture

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 13 Mar 2011 00:00:00 GTB Standard Time

When working with NHibernate you need to make sure that your mappings are correct. At least, you have to make sure that when you save an item you can also qet that item back.

If you are using FluentNHibernate you can use the PersistenceSpecification<T> class. However, the PersistenceSpecification<T> class requires that you pass the property to check and also a value for that property.

By using AutoFixture you can easily create objects that you can pass inside the CheckXx methods:

[Fact]
public void ShouldVerifyTheMappings()
{
    var fixture = new Fixture();

    using (session)
    {
        new PersistenceSpecification<EventType>(session)
            .CheckProperty(x => x.EventTypeId, 
                fixture.CreateAnonymous<long>())
            .CheckProperty(x => x.EventTypeName, 
                fixture.CreateAnonymous<string>())
            .CheckProperty(x => x.ExchangeServerId, 
                fixture.CreateAnonymous<int>())
            .CheckProperty(x => x.LastUpdatedOn, 
                DateTime.Today)
            .CheckProperty(x => x.NextMarketId, 
                fixture.CreateAnonymous<long>())
            .CheckReference(x => x.Bookmaker, 
                fixture.CreateAnonymous<Bookmaker>())
            .VerifyTheMappings();
    }
}

Combining AutoFixture with the PersistenceSpecification<T> class results in writing less code when testing NHibernate mappings, specially when dealing with complex types.

Creating Test Fixtures easily with AutoFixture

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Tue, 22 Feb 2011 00:00:00 GTB Standard Time

When doing TDD there are many times that we use an ObjectMother class for test fixtures. In large domains, writing such classes can become tedious work. If we want random data things get even more complicated.

AutoFixture is a library written by Mark Seemann and can automate test fixture creation thereby saving time and making tests cleaner, faster, flexible and customizable.

Here is an example:

Here I setup Moq to return a sequence of EventItem objects when I call the FindAll method. In the Setup method I pass a delegate where I use AutoFixture to create the sequence. What I really like here is that even though the EventItem contains interfaces AutoFixture can successfully create the sequence.

This is made possible by calling the Customize method and passing an instance of the AutoMoqCustomization type. This way we instruct AutoFixture to become an auto-mocking container and mock the interface types.

AutoFixture includes an assembly called Ploeh.AutoFixture.AutoMoq that uses Moq (which in turn Moq uses Castle DynamicProxy to generate proxies on the fly at runtime).

There is also Ploeh.AutoFixture.Xunit assembly for xUnit.net data theories.

All this stuff is amazing, and I would like to mention that the source code is perfectly written, contains a lot of patterns and best practises (like the Test Data Builder pattern). I am very happy with it.

Parameterized Tests with xUnit.net

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Thu, 17 Feb 2011 00:00:00 GTB Standard Time

Sometimes you have several unit-tests implementing the same test algorithm. These tests are exactly the same, having only different data.

With Pex you can cover your code with parameterized tests (there is also a tutorial here). However, you can also do it with xUnit.net.

Add a reference to xunit.extensions.dll and decorate any parameterized test methods with [Theory] attribute (instead of [Fact]). Then decorate it with [InlineData]attribute if the data is coming from inlined values.

There are also additional attributes (each one taking parameters so xUnit.net can successfully locate the test data):

PropertyDataAttribute
ExcelDataAttribute
SqlServerDataAttribute
OleDbDataAttribute

Choose the one that suits your needs.

Edit and Continue with TestDriven.Net

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Fri, 11 Feb 2011 00:00:00 GTB Standard Time

TestDriven.Net (2.0 RTM and greater) comes with a (hidden) test runner for Edit and Continue.

To enabled it, edit the TestDriven.dll.config file and uncomment the lines with: <button command="DebuggerEaC" />

Below are the places in the .config file where the command can be found, so you may choose which one of those you wish to uncomment:

Project and Solution Context Menus/Item
Project and Solution Context Menus/Folder
Project and Solution Context Menus/Project
Project and Solution Context Menus/Cross Project Multi Project
Project and Solution Context Menus/Reference Item

After you restart Visual Studio you will have an additional option in the context menu:

This test runner may 'touch' project files when used with source control (this is why it's disabled by default). You can also can read about it here.

Why I Love My MacBook Pro

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Fri, 21 Jan 2011 00:00:00 GTB Standard Time

It is the perfect solution if you want to work out, for example at Starbucks. I take a long break every time I need to charge the battery. This means that every ~4-6* hours I will get a an hour off for full refreshment. :-)

* with Visual Studio, VirtualBox and about 25-30 open tabs in Chrome.

Code Coverage without NCover

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Fri, 21 Jan 2011 00:00:00 GTB Standard Time

Let's analyze code coverage in the DynamicViewModel project.

I currently work with Visual Studio 2010 Premium. This product comes with Code Coverage so I thought I should give it a try with, the unit testing tool I use, xUnit.net.

First of all, if you do a lot of unit testing, I suggest using the TestDriven.Net add-in for Visual Studio because it is fully integrated with xUnit.net (and many other unit testing tools).

Right-Click on the project under test, select Test With > Coverage:

The Code Coverage Results tab shows the % of Not Covered/Covered Blocks:

Using the object explorer we navigate to the methods that are not fully covered:

Right-Click on any method > Go to source code. This will navigates us to the target method:

In the target method we can now see the portion of the code that is not covered.

Here we can see that there are no unit tests covering the case for invalid property names when binding in the view model:

Let's add a unit test for that:

Again, Right-Click on the project under test, select Test With > Coverage:

That's it! Visual Studio 2010 Cove Coverage feature (on Premium and Ultimate products) plays nicely with TestDriven.Net and xUnit.net!

Replace C# primitive types with FCL types in Visual Studio

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sat, 01 Jan 2011 00:00:00 GTB Standard Time

A nice Visual Studio macro, for those who prefer not to use the C# language primitive types and use the corresponding FCL types instead.

Many people writing C# code prefer to use the FCL types:

String
Int32
etc.

As far as I know in Visual Studio there is no way to automate this process. It would be good if you could just select some code and just hide built-in type names. For that reason I wrote this Visual Studio macro.

Download here, right-click save as.

A Sneak Preview of WebSocket-enabled WCF Services

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sat, 25 Dec 2010 00:00:00 GTB Standard Time

Recently the Interoperability Bridges and Labs Center (run by the Microsoft Interoperability Strategy Group) released a prototype implementation (in managed code) of two drafts of the WebSockets protocol specification:

The prototype can be found at HTML5 Labs, however (at the time of this writing) the samples did not come with source code and they were delay signed (which means you have to follow the instructions to run them). After running the samples (and since I had no access to the source code) I opened with reflector and had a look under the hood.

What I noticed is that a WebSocket-enabled service in .NET will be written like any other WCF service with two differences:

The service implementation has to derive from the base WebSocketService class:

[ServiceBehavior(
    InstanceContextMode=InstanceContextMode.PerSession, 
    ConcurrencyMode=ConcurrencyMode.Multiple)]
internal sealed class NotificationService : WebSocketsService
{
    // ...
}

The service host is a type deriving from the ServiceHost named WebSocketsHost:

Uri baseAddress = new Uri("<uriString goes here>");            
WebSocketsHost<NotificationService> host =
    new WebSocketsHost<NotificationService>(baseAddress);
host.AddWebSocketsEndpoint();
host.Open();

Notice, that since your specify ConcurrencyMode.Multipe you have to manually handle synchronization and state using a synchronization construct. That means if the clients need only write-access to the data you can use a mutual exclusive lock (like the Monitor Class) otherwise you can use a lock like the ReaderWriterLockSlim Class (or a faster one).

Here is a summary of links about the WebSocket prototype for .NET:

HTML5 Labs, WebSockets prototype
Tomasz Janczuk's, Blog post
Interoperability @ Microsoft, Blog post

CodeProject

MVVM using POCOs with .NET 4.0 and the DynamicViewModel Class

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Fri, 17 Dec 2010 00:00:00 GTB Standard Time

This post aims to provide a way to implement the Model View ViewModel (MVVM) architectural pattern using Plain Old CLR Objects (POCOs) while taking full advantage of .NET 4.0 DynamicObject Class.

In order to apply the Model View ViewModel (MVVM) architectural pattern we need:

An instance of the View, (e.g. a UserControl type).
An instance of the ViewModel, which in most scenarios is a class implementing the INotifyPropertyChanged interface (or inherits from a base class getting the implementation for free).
An instance of the Model inside the ViewModel class, for getting the properties to display (and format them if necessary) and also for invoking commands on the model.

While we can not avoid step 1 (we need to have something to display to the user) and step 3 (we need to have something the user can read/edit), for basic scenarios we can try to avoid step 2.

Taking advantage of the .NET 4.0 and the DynamicObject Class, we can create a type deriving from the DynamicObject Class and specify dynamic behavior at run time. Furthermore, we can implement the INotifyPropertyChanged Interface on the derived type making it a good candidate for Data Binding.

Let's name our class, DynamicViewModel(Of TModel) Class. It must be able to:

Accept references types (any class - a model is usually a class).
Invoke public instance methods.
Invoke public instance methods with arguments passed as CommandParameters.
Get public instance properties.
Set public instance properties.
Notify callers when property change by raising the PropertyChanged event.
If a property change results in chaning other properties, the caller must receive the notification for the other property changes too.

Here is the DynamicViewModel(Of TModel) Class:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Dynamic;
using System.Linq;
using System.Reflection;
using System.Threading;
 
internal sealed class DynamicViewModel<TModel>
    : DynamicObject, INotifyPropertyChanged where TModel : class
{
    private static readonly IDictionary<string, MethodInfo> methodInfos
        = GetPublicInstanceMethods();
 
    private static readonly IDictionary<string, PropertyInfo> propInfos
        = GetPublicInstanceProperties();
 
    private readonly TModel model;

    private IDictionary<string, object> propertyValues;
 
    public DynamicViewModel(TModel model)
    {
        this.model = model;
        NotifyChangedProperties();
    }
 
    public DynamicViewModel(Func<TModel> @delegate)
        : this(@delegate.Invoke()) { }
 
    public override bool TryInvokeMember(InvokeMemberBinder binder,
        object[] args, out object result)
    {
        result = null;
 
        MethodInfo methodInfo;
        if (!methodInfos.TryGetValue(binder.Name,
            out methodInfo)) { return false; }
 
        methodInfo.Invoke(this.model, args);
        NotifyChangedProperties();
        return true;
    }
 
    public override bool TryGetMember(GetMemberBinder binder,
        out object result)
    {
        var propertyValues = Interlocked.CompareExchange(
            ref this.propertyValues, GetPropertyValues(), null);
 
        if (!propertyValues.TryGetValue(binder.Name,
            out result)) { return false; }
 
        return true;
    }
 
    public override bool TrySetMember(SetMemberBinder binder, object value)
    {
        PropertyInfo propInfo = propInfos[binder.Name];
        propInfo.SetValue(this.model, value, null);
 
        NotifyChangedProperties();
        return true;
    }
 
    public void NotifyChangedProperties()
    {
        Interlocked.CompareExchange(
            ref this.propertyValues, GetPropertyValues(), null);

        IDictionary<string, object> previousPropValues
            = this.propertyValues;

        IDictionary<string, object> currentPropValues
            = GetPropertyValues();
 
        this.propertyValues
            = currentPropValues;
 
        foreach (KeyValuePair<string, object> propValue
            in currentPropValues.Except(previousPropValues))
        {
            RaisePropertyChanged(propValue.Key);
        }
    }
 
    private static IDictionary<string, MethodInfo> GetPublicInstanceMethods()
    {
        var methodInfoDictionary = new Dictionary<string, MethodInfo>();
        MethodInfo[] methodInfos = typeof(TModel).GetMethods(
            BindingFlags.Public | BindingFlags.Instance);
        foreach (MethodInfo methodInfo in methodInfos)
        {
            if (methodInfo.Name.StartsWith("get_") ||
                methodInfo.Name.StartsWith("set_")) { continue; }
            methodInfoDictionary.Add(methodInfo.Name, methodInfo);
        }
 
        return methodInfoDictionary;
    }
 
    private static IDictionary<string, PropertyInfo>
        GetPublicInstanceProperties()
    {
        var propInfoDictionary = new Dictionary<string, PropertyInfo>();
        PropertyInfo[] propInfos = typeof(TModel).GetProperties(
            BindingFlags.Public | BindingFlags.Instance);
        foreach (PropertyInfo propInfo in propInfos)
        {
            propInfoDictionary.Add(propInfo.Name, propInfo);
        }
 
        return propInfoDictionary;
    }

    private IDictionary<string, object> GetPropertyValues()
    {
        var bindingPaths = new Dictionary<string, object>();
        PropertyInfo[] propInfos = typeof(TModel).GetProperties(
            BindingFlags.Public | BindingFlags.Instance);
        foreach (PropertyInfo propInfo in propInfos)
        {
            bindingPaths.Add(
                propInfo.Name,
                propInfo.GetValue(this.model, null));
        }
 
        return bindingPaths;
    }
 
    private void RaisePropertyChanged(string propertyName)
    {
        OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
    }
 
    private void OnPropertyChanged(PropertyChangedEventArgs e)
    {
        PropertyChangedEventHandler temp =
            Interlocked.CompareExchange(ref PropertyChanged, null, null);
 
        if (temp != null)
        {
            temp(this, e);
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;
}

The sample application for this post comes with a simple ContactView which has no specific viewModel but instead uses the DynamicViewModel(Of TModel) class.

The DynamicViewModel(Of TModel) Class is able to update the View which binds to an instance of this class.

Here is what the sample application does:

Changing the First Name will result in changing the Full Name and the Reversed Full Name.
The same rules apply when chaning the Last Name.
The hyper-link is enabled only if the user presses the Clear Names button.
The Clear Names button is enabled only when the Full Name text is not empty.

Here is the POCO model class that I have used:

using System;
 
internal sealed class ContactDetails
{ 
    public string FirstName
    {
        get
        {
            return this.firstName;
        }
 
        set
        {
            this.firstName = value;
 
            SetFullName();
            SetReversedFullName();
        }
    }
 
    public string LastName
    {
        get
        {
            return this.lastName;
        }
 
        set
        {
            this.lastName = value;
 
            SetFullName();
            SetReversedFullName();
        }
    }
 
    public string FullName
    {
        get
        {
            return this.fullName;
        }
 
        set
        {
            this.fullName = value;
        }
    }
 
    public void ClearFullName()
    {
        FirstName = string.Empty;
        LastName  = string.Empty;
    }
 
    /// <summary>
    /// Navigates to this contact's website.
    /// </summary>
    /// <param name="uriString">The URI string.</param>
    public void NavigateTo(string uriString)
    {
        System.Diagnostics.Process.Start(uriString);
    }
 
    private void SetFullName()
    {
        FullName = FirstName + " " + LastName;
    }
 
    // (Less important members not shown)
}

As you notice, this class does not implement any interface or base class. In fact, this class can be used successfully in ORM scenarios too (when you need to bind on the same classes that are used in your mappings).

Finally, I would like to show how the View's DataContext is initialized properly to accept the DynamicViewModel(Of TModel) Class wrapper around the model class:

/// <summary>
/// Interaction logic for ContactView.xaml
/// </summary>
internal partial class ContactView : UserControl
{
    public static readonly RoutedCommand ClearNamesCommand
        = new RoutedCommand();
 
    public static readonly RoutedCommand NavigateUriCommand
        = new RoutedCommand();
 
    public ContactView()
    {
        InitializeComponent();
 
        // Create a new instance. Once created
        // do not call methods directly on this
        // object. (Use the dynamic viewModel).
        var instance  = new ContactDetails() {
            FirstName = "Nikos",
            LastName  = "Baxevanis"
        };
 
        dynamic viewModel = new DynamicViewModel<ContactDetails>(instance);
 
        // Wire the ClearNamesCommand from the view to the viewModel.
        CommandManager.RegisterClassCommandBinding(typeof(ContactView),
            new CommandBinding(
                ClearNamesCommand,
                (sender, e) => { viewModel.ClearFullName(); },
                (sender, e) => { e.CanExecute = !string.IsNullOrWhiteSpace(
                     viewModel.FullName); }));
 
        // Wire the NavigateUriCommand from the view to the viewModel.
        CommandManager.RegisterClassCommandBinding(typeof(ContactView),
            new CommandBinding(
                NavigateUriCommand,
                (sender, e) => { viewModel.NavigateTo(e.Parameter); },
                (sender, e) => { e.CanExecute =                
                    string.IsNullOrWhiteSpace(viewModel.FullName); }));
 
        DataContext = viewModel;
    }
}

Notice that wiring between the ICommand Interface and the model class is done outside the dynamic ViewModel wrapper using the CommandManager Class which acts as a mediator between the View and the ViewModel. This give us the flexibility to define static reusable commands or specific commands for each view (as I've done above).

The sample application can be found here.

ComponentBase(Of T) Class for NHibernate Components

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Fri, 10 Dec 2010 00:00:00 GTB Standard Time

This post aims to provide a way to implement a base class for NHibernate components also known as Value Objects in Domain-driven design.

In my previous post I discussed about the case where you want to map a component with NHibernate and introduced the ComponentBase(Of T) class. However, to make it straightforward that you need to override Equals (you also need to override GetHashCode) in your derived classes, I modified the ComponentBase(Of T) class to implement the IEquatable(Of T) interface. Furthermore, since NHibernate works only with reference types (that is, a class) I also constrained it to accept only reference types.

Here is the Component(Of T) class:

using System;
 
public abstract class ComponentBase<T> 
    : IEquatable<T> where T : class 
{
    /// <summary>
    /// Indicates whether the current object is equal to another
    /// object of the same type.
    /// </summary>
    /// <param name="other">An object to compare with this object.
    /// </param>
    /// <returns>true if the current object is equal to the other
    /// parameter; otherwise, false.</returns>
    public abstract bool Equals(T other);
 
    /// <summary>
    /// Serves as a hash function for a particular type,
    /// suitable for use in hashing
    /// algorithms and data structures such as a hash table.
    /// </summary>
    /// <returns>
    /// A hash code for this instance of the type.
    /// </returns>
    public abstract int GetHashCodeForType();
 
    /// <summary>
    /// Determines whether the specified <see cref="System.Object"/>
    /// is equal to this instance.
    /// </summary>
    /// <param name="obj">The <see cref="System.Object"/> to
    /// compare with this instance.
    /// </param>
    /// <returns>
    ///     <c>true</c> if the specified <see cref="System.Object"/>
    ///     is equal to this instance;
    ///     otherwise, <c>false</c>.
    /// </returns>
    public sealed override bool Equals(object obj)
    {
        // The given object to compare to can't be null.
        if (obj == null) { return false; }
 
        // If objects are different types, they can't be equal.
        if (this.GetType() != obj.GetType()) { return false; }
 
        return Equals(obj as T);
    }
 
    /// <summary>
    /// Returns a hash code for this instance.
    /// </summary>
    /// <returns>
    /// A hash code for this instance, suitable for
    /// use in hashing algorithms and data structures
    /// like a hash table.
    /// </returns>
    public sealed override int GetHashCode()
    {
        return GetHashCodeForType();
    }
}

Below are some test cases:

using System;
using Xunit;
 
public sealed class ComponentBaseTest
{
    private sealed class MockType 
         : ComponentBase<MockType> { /* ... */ }
 
    [Fact]
    public void TheSameInstanceHasTheSameHashCode()
    {
        MockType mt1 = new MockType(5);
        MockType mt2 = mt1;
        Assert.Equal(mt1.GetHashCode(), mt2.GetHashCode());
    }
 
    [Fact]
    public void DiffInstancesWithSameCtorParamsHaveTheSameHashCode()
    {
        MockType mt1 = new MockType(5);
        MockType mt3 = new MockType(5);
        Assert.Equal(mt1.GetHashCode(), mt3.GetHashCode());
    }
 
    [Fact]
    public void TestDiffInstancesWithSameCtorParamsAreEqual()
    {
        MockType mt1 = new MockType(5);
        MockType mt3 = new MockType(5);
        // Objects are equal.
        Assert.True(mt1.Equals(mt3));
        // References are not equal.
        Assert.False(object.ReferenceEquals(mt1, mt3));
    }
 
    [Fact]
    public void TestDiffInstancesWithDiffCtorParamsAreNotEqual()
    {
        MockType mt1 = new MockType(1);
        MockType mt3 = new MockType(3);
        // Objects are not equal.
        Assert.False(mt1.Equals(mt3));
        // References are not equal.
        Assert.False(object.ReferenceEquals(mt1, mt3));
    }
}

You can use this class in your component collections. If you want to map a Set (that is, an unordered collection of unique entities where duplicates are not allowed) just derive your component types from ComponentBase(Of T). Derived types need to implement the strongly-typed version of Equals and also the GetHashCode methods.

Component Collections in NHibernate

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Thu, 09 Dec 2010 00:00:00 GTB Standard Time

Update: In this post I discuss further about the ComponentBase(Of T) Class.

Objects that are used to describe certain aspects of a domain, and which do not have identity, are named Value Objects (do not confuse them with .NET Value Types). Value Object is a term used in Domain-driven design (DDD). In NHibernate, such kind of objects are declared using the component tag. However, collections of components are declared with a composite-element tag.

Here is an example with Fluent NHibernate:

/*
<set name="MandatoryCoverages"
    table="CarUseMandatoryCoverageFees" mutable="true">
<key>
    <column name="CarUse_id" />
</key>
<composite-element class="Domain.Car.CarCoverageFee, ..">
    <property name="NetFeePercentage" type="System.Double, ..">
    <column name="NetFeePercentage" />
    </property>
    <many-to-one class="Domain.Car.CarCoverageFee,
                fetch="join" name="Coverage">
    <column name="Coverage_id" />
    </many-to-one>
</composite-element>
</set>
*/
HasMany<CarCoverageFee>(x => x.MandatoryCoverages)
    .AsSet()
    .Table("CarUseMandatoryCoverageFees")
    .Component(fee =>
    {
        fee.References<Coverage>(x => x.Coverage).Fetch.Join();
        fee.Map(x => x.NetFeePercentage);
    });

/*
<set name="OptionalCoverages"
    table="CarUseOptionalCoverageFees" mutable="true">
<key>
    <column name="CarUse_id" />
</key>
<composite-element class="Domain.Car.CarCoverageFee, ..">
    <property name="NetFeePercentage" type="System.Double, ..">
    <column name="NetFeePercentage" />
    </property>
    <many-to-one class="Domain.Car.CarCoverageFee,
                fetch="join" name="Coverage">
    <column name="Coverage_id" />
    </many-to-one>
</composite-element>
</set>
*/
HasMany<CarCoverageFee>(x => x.OptionalCoverages)
    .AsSet()
    .Table("CarUseOptionalCoverageFees")
    .Component(fee =>
    {
        fee.References<Coverage>(x => x.Coverage).Fetch.Join();
        fee.Map(x => x.NetFeePercentage);
    });

The CarCoverageFee class is a component (a Value Object for DDD) so it does not have an identity field. This creates a lot of noise between the application and the database as we can see from the image below:

We can define an abstract base class for our components. Inside this class we override the Equals method and immediately throw an exception to the caller indicating that this method must be overridden by the caller:

public abstract class ComponentBase
{
    /// <summary>
    /// Determines whether the specified
    /// <see cref="System.Object"/> is equal
    /// to this instance.
    /// </summary>
    /// <param name="obj">The <see cref="System.Object"/>
    /// to compare with this instance.</param>
    /// <returns>
    ///     <c>true</c> if the specified
    ///     <see cref="System.Object"/> is equal to this
    ///     instance; otherwise, <c>false</c>.
    /// </returns>
    /// <exception cref="T:System.NullReferenceException">
    /// The <paramref name="obj"/> parameter is null.
    /// </exception>
    public override bool Equals(object obj)
    {
        throw new MethodAccessException(
            "Components must be compared using property values.");
    }
 
    /// <summary>
    /// Returns a hash code for this instance.
    /// </summary>
    /// <returns>
    /// A hash code for this instance, suitable for
    /// use in hashing algorithms and data structures
    /// like a hash table.
    /// </returns>
    public override int GetHashCode()
    {
        throw new MethodAccessException(
            "Components must be hashed using property values.");
    }
}

Here is the class, modified to inherit from the ComponentBase class:

public class CarCoverageFee : ComponentBase
{
    /// <summary>
    /// Gets or sets the coverage.
    /// </summary>
    /// <value>The coverage.</value>
    public virtual Coverage Coverage { get; set; }
 
    /// <summary>
    /// Gets or sets the fee.
    /// </summary>
    /// <value>The fee.</value>
    public virtual double NetFeePercentage { get; set; }
 
    /// <summary>
    /// Determines whether the specified
    /// <see cref="System.Object"/> is equal
    /// to this instance.
    /// </summary>
    /// <param name="obj">The <see cref="System.Object"/>
    /// to compare with this instance.</param>
    /// <returns>
    ///     <c>true</c> if the specified
    ///     <see cref="System.Object"/> is equal to this
    ///     instance; otherwise, <c>false</c>.
    /// </returns>
    /// <exception cref="T:System.NullReferenceException">
    /// The <paramref name="obj"/> parameter is null.
    /// </exception>
    public override bool Equals(object obj)
    {
        // The given object to compare to can't be null.
        if (obj == null) { return false; }
 
        // If objects are different types, they can't be equal.
        if (this.GetType() != obj.GetType()) { return false; }
 
        // At this point, we really know that obj is really
        // a CarCoverageFee object. Cast obj to CarCoverageFee.
        if (Coverage.Code != ((CarCoverageFee)obj)
            .Coverage.Code) { return false; }
 
        return true;
    }
 
    /// <summary>
    /// Returns a hash code for this instance.
    /// </summary>
    /// <returns>
    /// A hash code for this instance, suitable for
    /// use in hashing algorithms and data structures
    /// like a hash table.
    /// </returns>
    public override int GetHashCode()
    {
        return Coverage.Name.GetHashCode()
             + Coverage.Code.GetHashCode();
    }
}

After overriding Equals and GetHashCode methods, I compared the Sessions:

Now, everything looks fine; No necessary inserts and deletes.

Building a Metro UI with WPF

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Wed, 01 Dec 2010 00:00:00 GTB Standard Time

Have you ever used the Zune software? I guess so, but I haven't until version 4.7.1404.0 came out. This version comes with significant changes: Windows Phone 7 support and integration with Windows Live Essentials 2011 among other.

When I first run the software I got amazed by the user interface (UI). I told to myself, "this must not be WPF, no way!". The text was so clear and the UI was so responsive. I also looked in Wikipedia and read that the first versions of Zune software were released back in 2006. At this time WPF was about to be released with .NET 3.0 (release date was Nov 2006).

Since the UI is not built with WPF then what kind of technology did the Zune team used? Could it be MFC or some other unmanaged UI? To find out, I launched the Process Explorer utility and looked for the Zune executable. By default, .NET Processes are highlighted with yellow as shown in the image below.

Great, so Zune software is a managed application, or better, if it's an unmanaged application at least it hosts the CLR in it's process. (Any Windows application can host the CLR). A quick look in the installation directory yield the following output:

Followed by a quick view with Reflector:

As you can see, the root namespace is Microsoft.Iris. A quick search returned this blog post and this one. It looks like some kind of WPF ancestor combined with MCML.

Is it possible to build a similar UI with WPF?

The first difficulties came when setting the WindowStyle enumeration to None. We need that because with this style only the client area is visible - the title bar and border are not shown.

The image above is not what we want. We need to hide the window boundaries. This can be done by setting the ResizeMode enumeration to NoResize. But now, we can't move the window, we can't resize it and the mouse events are not raised! Here is a very nice blog post discussing in very detail (among other) the reason for that.

How can we move the window?

By adding a Shape (ex. a Rectangle) and registering on it's PreviewMouseDown event:

// Is this a double-click?
if (DateTime.Now.Subtract(this.headerLastClicked) <= doubleClick)
{
    // Execute the code inside the event handler for the
    // restore button click passing null for the sender
    // and null for the event args.
    HandleRestoreClick(null, null);
}
 
this.headerLastClicked = DateTime.Now;
 
if (Mouse.LeftButton == MouseButtonState.Pressed)
{
    DragMove();
}

How can we resize the window?

By adding Shapes (ex. Rectangles) one on each side of the window (left, top, right, bottom) and registering on it's PreviewMouseDown event:

Rectangle clickedRectangle = (Rectangle)sender;
 
switch (clickedRectangle.Name)
{
    case "top":
        Cursor = Cursors.SizeNS;
        ResizeWindow(ResizeDirection.Top);
        break;
    case "bottom":
        Cursor = Cursors.SizeNS;
        ResizeWindow(ResizeDirection.Bottom);
        break;
    // ...
}

Here is the code for resizing the window. It uses the underlying Windows USER component.

/// <summary>
/// Resizes the window.
/// </summary>
/// <param name="direction">The direction.</param>
private void ResizeWindow(ResizeDirection direction)
{
    NativeMethods.SendMessage(this.hwndSource.Handle, WM_SYSCOMMAND,
        (IntPtr)(61440 + direction), IntPtr.Zero);
}
 
[DllImport("user32.dll", CharSet = CharSet.Auto)]
internal static extern IntPtr SendMessage(
    IntPtr hWnd,
    UInt32 msg,
    IntPtr wParam,
    IntPtr lParam);

How can we add a drop shadow to the window?

At the time of this writing, I know two ways of doing this:

The first one (which is described here) uses the Desktop Window Manager (DWM) API. Specifically it uses the DwmSetWindowAttribute Function combined with the DwmExtendFrameIntoClientArea Function to place a drop shadow around the window area. This method works by registering at the SourceInitialized event. When this event is raised, it is a good place to call any code that can interoperate with the underlying Win32 window.

/// <summary>
/// Raises the <see cref="FrameworkElement.Initialized"/> event.
/// This method is invoked whenever
/// <see cref="P:FrameworkElement.IsInitialized"/>
/// is set to true internally.
/// </summary>
/// <param name="e">The <see cref="T:RoutedEventArgs"/>
/// that contains the event data.</param>
protected override void OnInitialized(EventArgs e)
{
    AllowsTransparency    = false;
    ResizeMode            = ResizeMode.NoResize;
    Height                = 480;
    Width                 = 852; 
    WindowStartupLocation = WindowStartupLocation.CenterScreen;
    WindowStyle           = WindowStyle.None;
 
    SourceInitialized    += HandleSourceInitialized;
 
    base.OnInitialized(e);
}
 
/// <summary>
/// Handles the source initialized.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.EventArgs"/>
/// instance containing the event data.</param>
private void HandleSourceInitialized(object sender, EventArgs e)
{
    this.hwndSource = (HwndSource)PresentationSource.FromVisual(this);
 
    // Returns the HwndSource object for the window
    // which presents WPF content in a Win32 window.
    HwndSource.FromHwnd(this.hwndSource.Handle).AddHook(
        new HwndSourceHook(NativeMethods.WindowProc));
 
    // http://msdn.microsoft.com/en-us/library/aa969524(VS.85).aspx
    int DWMWA_NCRENDERING_POLICY = 2;
    NativeMethods.DwmSetWindowAttribute(
        this.hwndSource.Handle,
        DWMWA_NCRENDERING_POLICY,
        ref DWMWA_NCRENDERING_POLICY,
        4);
 
    // http://msdn.microsoft.com/en-us/library/aa969512(VS.85).aspx
    NativeMethods.ShowShadowUnderWindow(this.hwndSource.Handle);
}

Without the drop shadow

With the drop shadow

There is a problem here though. If the user goes to System Properties, Performance Options and uncheck the "Show shadows under windows" checkbox, the shadow will not be visible.

The Zune software still keeps it's drop shadow visible even if the "Show shadows under windows" checkbox is unchecked.

How can this possibly be?

Well, the Zune software does not use the DWM API to place drop shadows. Instead, it uses four external, transparent, windows on each size to create an illusion of a drop shadow. The drop shadow is actually "composed" by four transparent windows on each side.

The second way, of placing the drop shadows, via external windows is the main reason for this post.

Here is what I had to do:

Create a transparent window in code (and also set it's background).
Find the Main Window position on screen. Fortunately I could access the Left and Top properties and by it's width and height I could calculate the window boundary.
Calculate position for each external window.
When moving the Main Window the external windows had to "glue" or better "dock" with the Main Window.
When resizing the Main Window the external windows had to resize as well, according to the Main Window size.

..Sounds like a lot of work to do for displaying a drop shadow that remains visible even if the user unchecks the "Show shadows under windows" checkbox!

Creating the transparent window in code was easy:

/// <summary>
/// Initializes the surrounding windows.
/// </summary>
private void InitializeSurrounds()
{
    // Top.
    this.wndT = CreateTransparentWindow();
 
    // Left.
    this.wndL = CreateTransparentWindow();
 
    // Bottom.
    this.wndB = CreateTransparentWindow();
 
    // Right.
    this.wndR = CreateTransparentWindow();
 
    SetSurroundShadows();
}
 
/// <summary>
/// Creates an empty window.
/// </summary>
/// <returns></returns>
private static Window CreateTransparentWindow()
{
    Window wnd             = new Window();
    wnd.AllowsTransparency = true;
    wnd.ShowInTaskbar      = false;
    wnd.WindowStyle        = WindowStyle.None;
    wnd.Background         = null;
 
    return wnd;
}
 
/// <summary>
/// Sets the artificial drop shadow.
/// </summary>
/// <param name="active">if set to <c>true</c> [active].</param>
private void SetSurroundShadows(bool active = true)
{
    if (active)
    {
        double cornerRadius = 1.75;
 
        this.wndT.Content = GetDecorator(
            "Images/ACTIVESHADOWTOP.PNG");
        this.wndL.Content = GetDecorator(
            "Images/ACTIVESHADOWLEFT.PNG", cornerRadius);
        this.wndB.Content = GetDecorator(
            "Images/ACTIVESHADOWBOTTOM.PNG");
        this.wndR.Content = GetDecorator(
            "Images/ACTIVESHADOWRIGHT.PNG", cornerRadius);
    }
    else
    {
        this.wndT.Content = GetDecorator(
            "Images/INACTIVESHADOWTOP.PNG");
        this.wndL.Content = GetDecorator(
            "Images/INACTIVESHADOWLEFT.PNG");
        this.wndB.Content = GetDecorator(
            "Images/INACTIVESHADOWBOTTOM.PNG");
        this.wndR.Content = GetDecorator(
            "Images/INACTIVESHADOWRIGHT.PNG");
    }
}
 
[DebuggerStepThrough]
private Decorator GetDecorator(string imageUri, double radius = 0)
{
    Border border       = new Border();
    border.CornerRadius = new CornerRadius(radius);
    border.Background   = new ImageBrush(
        new BitmapImage(
            new Uri(BaseUriHelper.GetBaseUri(this),
                imageUri)));
 
    return border;
}

Calculating the position, width and height for each external window was also not difficult:

/// <summary>
/// Raises the <see cref="FrameworkElement.Initialized"/> event.
/// This method is invoked whenever
/// <see cref="FrameworkElement.IsInitialized"/>
/// is set to true internally.
/// </summary>
/// <param name="e">The <see cref="T:RoutedEventArgs"/>
/// that contains the event data.</param>
protected override void OnInitialized(EventArgs e)
{
    // ...
 
    LocationChanged += HandleLocationChanged;
    SizeChanged     += HandleLocationChanged;
    StateChanged    += HandleWndStateChanged;
 
    InitializeSurrounds();
    ShowSurrounds();
 
    base.OnInitialized(e);
}
 
/// <summary>
/// Handles the location changed.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.EventArgs"/>
/// instance containing the event data.</param>
private void HandleLocationChanged(object sender, EventArgs e)
{
    this.wndT.Left   = Left  - edgeWndSize;
    this.wndT.Top    = Top   - this.wndT.Height;
    this.wndT.Width  = Width + edgeWndSize * 2;
    this.wndT.Height = edgeWndSize;
 
    this.wndL.Left   = Left - this.wndL.Width;
    this.wndL.Top    = Top;
    this.wndL.Width  = edgeWndSize;
    this.wndL.Height = Height;
 
    this.wndB.Left   = Left  - edgeWndSize;
    this.wndB.Top    = Top   + Height;
    this.wndB.Width  = Width + edgeWndSize * 2;
    this.wndB.Height = edgeWndSize;
 
    this.wndR.Left   = Left + Width;
    this.wndR.Top    = Top;
    this.wndR.Width  = edgeWndSize;
    this.wndR.Height = Height;
}
 
/// <summary>
/// Handles the windows state changed.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.EventArgs"/>
/// instance containing the event data.</param>
private void HandleWndStateChanged(object sender, EventArgs e)
{
    if (WindowState == WindowState.Normal)
    {
        ShowSurrounds();
    }
    else
    {
        HideSurrounds();
    }
}

I hope you find this post useful, there is a lot of information around but I think this post connects the pieces.

The solution contains two projects. The first one uses the 1st method for displaying the drop shadow. The second one uses the method described above.

Due to popular demand, you can download the sample projects here and here.

CodeProject

SingleInstance(Of T) Class for Windows Phone 7

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sat, 20 Nov 2010 00:00:00 GTB Standard Time

When building applications for a mobile operating system such as Windows Phone 7 (WP7) you might want (at times) to defer the creation of large objects, specifically when this creation is going to increase memory consumption.

While in the desktop CLR there is the Lazy(Of T) Class, when working on WP7 this class does not exist (at least not at the time of this writing).

I find it a very repetitive task to manually produce a single instance object:

Make it's constructor private.
Write the code for initialization.
Provide a getter method that returns the one and only instance.

While you can not avoid step 2, it is possible to create a generic class that produces step 1 and step 3. Then, from the class constructor, you can pass the code that creates the object using a Func(TResult) Delegate.

SingleInstance(Of T) Class

using System;
using System.Threading;
 
internal sealed class SingleInstance<T> where T : class
{
    private readonly object  lockObj = new object();
    private readonly Func<T> @delegate;
    private bool isDelegateInvoked;
 
    private T @value;
 
    public SingleInstance()
        : this(() => default(T)) { }
 
    public SingleInstance(Func<T> @delegate)
    {
        this.@delegate = @delegate;
    }
 
    public T Instance
    {
        get
        {
            if (!this.isDelegateInvoked)
            {
                T temp = this.@delegate();
                Interlocked.CompareExchange<T>(ref this.@value, temp, null);
 
                bool lockTaken = false;
 
                try
                {
                    // WP7 does not support the overload with the
                    // Boolean indicating if the lock was taken.
                    Monitor.Enter(this.lockObj); lockTaken = true;
 
                    this.isDelegateInvoked = true;
                }
                finally
                {
                    if (lockTaken) { Monitor.Exit(this.lockObj); }
                }
            }
 
            return this.@value;
        }
    }
}

The code inside the "T Instance" public property uses interlocked constructs to produce a single T object. It has been discussed in the book CLR via C#, 3rd Edition, Microsoft Press, page 846.

The SingleInstance(Of T) class has many differences from the System.Lazy(Of T) class in the desktop CLR.

The System.Lazy(Of T) class takes a LazyThreadSafetyMode enumeration. This enumeration contains 3 members (None, PublicationOnly, ExecutionAndPublication). The SingleInstance(Of T) class uses the interlocked constructs to produce a single instance. This is similar with passing LazyThreadSafetyMode.ExecutionAndPublication in the System.Lazy(Of T) class.
The System.Lazy(Of T) class works with classes (reference types) and structs (value types). The value types are boxed internally. The SingleInstance(Of T) class works only with reference types.
Finally, the System.Lazy(Of T) class is written, tested and supported by Microsoft, while the SingleInstance(Of T) is not.

Keep in mind that the SingleInstance(Of T) class uses a Func(TResult) Delegate. There is a known performance hit when calling delegates compared to direct method calls. (See the Delegates section here).

Going Asynchronous with Sterling for Windows Phone 7

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sat, 13 Nov 2010 00:00:00 GTB Standard Time

In this post I discuss about the various programming models that can be used with Sterling Isolated Storage Database for Windows Phone 7. Further, I discuss how one can benefit from the Power Threading Library when using Sterling.

I have already discussed about the basics of Sterling Isolated Storage Database (Sterling) when building application for Windows Phone 7 (WP7). At times you might want to do some operation on the background while your code executes something else.

Sterling supports the Event-based Asynchronous Pattern (EAP) which means you can write the following code against the ISterlingDatabaseInstance interface:

private void ExecuteWithEventBased()
{
    IList<Cargo> cargos = new List<Cargo>();
    for (int n = 0; n < iterations; n++)
    {
        Cargo cargo = CargoFactory.CreateNew("Glyfada" + n, "Perachora" + n);
        cargos.Add(cargo);
    }
 
    var bw = App.Database.SaveAsync<Cargo>(cargos);
    bw.RunWorkerCompleted += (sender, e) => {
        SetStatus("Event-based completed.", StatusState.Ready); };
 
    bw.RunWorkerAsync();
}

I can imagine, the reason the EAP is implemented is because you can have progress notification while the I/O executes in the background and also for handling the SynchronizationContext and/or the Dispatcher internally.

In my applications, I prefer to use the IAsyncResult, the CLR’s Asynchronous Programming Model (APM). For that reason, I wrote some extension methods for the ISterlingDatabaseInstance interface that allows you to use the APM when working with Sterling.

Power Threading library comes with an implementation of the IAsyncResult interface, so one can take a method that executes synchronously and implement the APM. In the code above you can see the APM for the object Save<T>(T instance) where T : class, new(); method in ISterlingDatabaseInstance interface.

/// <summary>
/// Asynchronous version of ISterlingDatabaseInstance Save method (Begin part).
/// </summary>
public static IAsyncResult BeginSave<T>(
    this ISterlingDatabaseInstance sterling,
    T instance,
    AsyncCallback callback,
    object state) where T : class, new()
{
    // Create IAsyncResult object identifying the asynchronous operation.
    AsyncResult ar = new AsyncResult(callback, state);
 
    // Use a thread pool thread to perform the operation.
    ThreadPool.QueueUserWorkItem((obj) =>
    {
        var asyncResult = (AsyncResult)obj;
        try
        {
            // Perform the operation.
            sterling.Save<T>(instance);
            asyncResult.SetAsCompleted(null, false);
        }
        catch (Exception e)
        {
            // If operation fails, set the exception.
            asyncResult.SetAsCompleted(e, false);
        }
    }, ar);
 
    return ar; // Return the IAsyncResult to the caller.
}
 
///<summary>
/// Asynchronous version of ISterlingDatabaseInstance Save method (End part).
/// </summary>
public static void EndSave(
    this ISterlingDatabaseInstance instance,
    IAsyncResult asyncResult)
{
    AsyncResult ar = (AsyncResult)asyncResult;
    ar.EndInvoke();
}

AsyncResult class resides in the PowerThreading library. It is written by Jeffrey Richter and can be obtained from the Wintellect website.

Sterling Isolated Storage Database can be obtained from the CodePlex website.

Armed with the above extension method you can write the following code which combines the APM implementation with the AsyncEnumerator class.

// Inside your method create an instance of an AsyncEnumerator class,
// specifying the iterator method to be driven by the AsyncEnumerator.
AsyncEnumerator ae = new AsyncEnumerator();
ae.BeginExecute(ExecuteWithAsyncEnumerator(ae), ae.EndExecute, null);

private IEnumerator<int> ExecuteWithAsyncEnumerator(AsyncEnumerator ae)
{
    for (int n = 0; n < iterations; n++)
    {
        Cargo cargo = CargoFactory.CreateNew("Glyfada" + n, "Perachora" + n);
        App.Database.BeginSave<Cargo>(cargo, ae.End(), null);
    }
 
    // AsyncEnumerator captures the calling thread's SynchronizationContext.
    // Set the SyncContext to null so that the callback continues
    // on a ThreadPool thread.
    ae.SyncContext = null;
 
    yield return iterations;
 
    for (Int32 n = 0; n < iterations; n++)
    {
        App.Database.EndSave(ae.DequeueAsyncResult());
    }
 
    // AsyncEnumerator captures the synchronization context.
    SetStatus("AsyncEnumerator completed.", StatusState.Ready);
}

The sample Windows Phone 7 application can be found here.

Testing Domain-Driven Design with Sterling for Windows Phone 7

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Wed, 10 Nov 2010 00:00:00 GTB Standard Time

When building applications targeting the Windows Phone 7 (WP7) you often need to create and maintain any kind of data. And while (for security reasons we all understand) you can't access the local file system, you can benefit from the Isolated Storage. It's API is similar with the one exposed in the Silverlight namespace.

A good design of a Domain model knows nothing about persistence. You can use an in-memory database, a relational database, or .."an Object-Oriented Database for WP7 that works with Isolated Storage classes and supports full LINQ to Object queries over keys and indexes for fast retrieval of information from large data sets!" Enter Sterling.

Here is a sample repository implementation using Sterling to store and retrieve data:

internal class SterlingRepository<T> where T: class, new()
{
    public void Save(T instance)
    {
        App.Database.Save<T>(instance);
    }
 
    public T LoadById<TKey>(TKey id) where TKey : class
    {
        var query = App.Database.Query<T, TKey>()
                                .Where((table) => table.Key == id)
                                .FirstOrDefault();
 
        return query.LazyValue.Value ?? default(T);
    }
 
    public ICollection<T> FindAll<TKey>()
    {
        var items = App.Database.Query<T, TKey>()
                                .Select((table) => table.LazyValue.Value)
                                .ToList<T>();
        return items;
    }
}

In the sample application I use the domain model based on the cargo example used in Eric Evans' book which can be found here.

CargoRepository

internal sealed class CargoRepository : 
    SterlingRepository<Cargo>, ICargoRepository
{

    public void Store(Cargo cargo)
    {
        Save(cargo);
    }
 
    public Cargo Find(TrackingId trackingId)
    {
        return LoadById(trackingId.IdString);
    }
 
    public ICollection<Cargo> FindAll()
    {
        return FindAll<string>();
    }
}

CargoFactory

internal static class CargoFactory
{
    public static Cargo CreateNew(string origin, string destination)
    {
        // Method implementation can be found in the sample application.
    }
}

Armed with the above classes you can create a Cargo, save it using the CargoRepository and load it. Sterling will save the whole object graph and when you load, it will defer the creation of the whole object using the Lazy<T> class.

public sealed class CargoPageViewModel : PropertyChangedBase
{
    private readonly ICargoRepository repository;
 
    public SterlingPageViewModel(ICargoRepository repository)
    {
        this.repository = repository;
    }
 
    public void StoreAndFind()
    {
        Cargo cargo = CargoFactory.CreateNew("Glyfada", "Perachora");
        this.repository.Store(cargo);
 
        Cargo saved = this.repository.Find(cargo.TrackingId);
 
        Debug.Assert(cargo.RouteSpecification.Equals(saved.RouteSpecification));
        Debug.Assert(cargo.Delivery.Equals(saved.Delivery));
        Debug.Assert(cargo.Equals(saved));
    }
}

Your domain model classes can be POCOs. That is, you don't have to inherit from anything in order to persist an instance of a type in the database. It just works!

The documentation can be found here. The sample application can be found here.

Using Reflection to Dynamically Invoke the NHibernate Profiler

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Wed, 03 Nov 2010 00:00:00 GTB Standard Time

If you are using NHibernate as your Object-relational mapping (ORM) solution, then chances are you are also using the NHibernate Profiler. You can see the exact SQL queries sent to the database and also detect common pitfalls, among others.

NHibernate Profiler is developed by Hibernating Rhinos and Blue Spire Consulting, Inc. The main contributers behind this tool are Oren Eini (NHibernate, Castle Project, RavenDB), Christopher Bennage (Sams Teach Yourself WPF in 24 Hours) and Rob Eisenberg (Sams Teach Yourself WPF in 24 Hours, Caliburn, Caliburn Micro). As you can see, this tool is not only interesting for what it does, but it has also interesting people behind it.

Using the NHibernate Profiler in your application is very easy:

Add a reference to HibernatingRhinos.Profiler.Appender.dll assembly.
Invoke the NHibernateProfiler.Initialize method from your code.

The problem is, you (might) need to remove the referenced assembly every time you ship. Even if you decide to keep it, you need to invoke the Initialize method from your code inside a method marked with the ConditionalAttribute class so the compiler ignores it unless you are running in debug mode.

You can avoid adding a reference (step 1), and invoke the Initialize method dynamically using reflection:

1. In the <appSettings> element include the following keys:

<appSettings>
    <add key="NHibernate_ProfilerAssembly"
         value="HibernatingRhinos.Profiler.Appender.dll"/>
    <add key="NHibernate_ProfilerDirectory"
         value="<your_path>"/>
    <add key="NHibernate_ProfilerMethod"
         value="Initialize"/>
    <add key="NHibernate_ProfilerType"
         value="NHibernateProfiler"/>
</appSettings>

2. For housekeeping you can define an interface.

public interface IIntegrateProfiler
{
    void SetNHibernateProfiler(string directory, string assembly);
 
    bool CanUseProfiler { get; }
 
    string ProfilerPath { get; }
}

3. Inside the your bootstrapper class, or the class where the ISessionFactory is built, implement the above interface.

In the example below the ValidateDirectory and ValidateFileName methods are not included as well as the this.profilerPath private instance field.

public void SetNHibernateProfiler(string directory, string assembly)
{
    if (ValidateDirectory(directory))
    {
        string profilerPath = Path.Combine(directory, assembly);
 
        if (ValidateFileName(profilerPath))
        {
            this.profilerPath = profilerPath;
        }
        else
        {
            this.profilerPath = string.Empty;
        }
    }
}

public bool CanUseProfiler
{
    get { return !string.IsNullOrWhiteSpace(this.profilerPath); }
}
 
public string ProfilerPath
{
    get { return this.profilerPath; }
}

4. Finally, from your code you can check whether the CanUseProfiler property returns true and call the InitializeProfiler method below:

private void InitializeProfiler()
{
    Assembly asm  = Assembly.LoadFileLoadFrom(this.options.ProfilerPath);
    Type profiler = asm.GetExportedTypes().Where(x => 
        x.Name == ConfigurationManager.AppSettings["NHibernate_ProfilerType"])
            .FirstOrDefault();
 
     if (profiler != null)
     {
         MethodInfo initialize = profiler.GetMethods().Where(x => 
           x.Name == ConfigurationManager
             .AppSettings["NHibernate_ProfilerMethod"]).FirstOrDefault();
         if (initialize != null)
         {
             initialize.Invoke(null, null);
         }
     }
}

Actually, the same technique can be used for the other profilers too (EFProf, L2SProf, etc).

Don't forget to remove the referenced assembly from your project.

The Task-based Asynchronous Pattern - Part 1 (The Basics)

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 31 Oct 2010 00:00:00 GTB Daylight Time

The future of asynchronous programming in C# adheres to a new language feature and a new framework pattern.

Asynchronous programming will be similar to synchronous programming.

Today hosting in the cloud has become popular. You’re paying for each virtual machine (VM) that is running so your service must scale or else you have to pay for another VM to handle the load. Both the classic APM and the EAP require you to split your code in a callback function so many people even chose to write their code synchronous. No matter if you call a web service or access a file on disk (that is, I/O-Bound Asynchronous Operations) or if you want to compute PI (a Periodic Compute-Bound Operation) your application has to be scalable and responsive.

I have already discussed about the two patterns that are available in the .NET Framework for asynchronous programming.

Callback-based Asynchronous Pattern (APM)
Event-based Asynchronous Pattern (EAP)

I like the APM because with a good IAsyncResult implementation in hand you can easily expose asynchronous features to all versions of the .NET Framework (1.0-today) and also target Microsoft Silverlight, Windows Phone 7, etc.

To start, here is some code that executes synchronously:

private void FetchStockQuotesSync(WebService svc)
{
    // This blocks. You don't know when the FetchStockQuotes
    // method returns. It may takes from minutes, to hours or
    // it may not return at all.
    IStockQuote qt = svc.FetchStockQuotes();
}

Fortunately the WebService class implements the IAsyncResult interface, so the same code can be executed asynchronously:

private void FetchStockQuotesApm(WebService svc)
{
    // This never blocks. Your code returns immediately.
    svc.BeginFetchStockQuotes(FetchStockQuotesApmCallback, svc);
}
 
private void FetchStockQuotesApmCallback(IAsyncResult ar)
{
    // The operation completed asynchrnously.
    WebService svc = (WebService)ar.AsyncState;
    IStockQuote qt = svc.EndFetchStockQuotes(ar);
}

Event if the WebService class does not implement the IAsyncResult interface, you can define a delegate and invoke it asynchronously, via BeginInvoke.

The following code below is here just for the demo. There is a known performance hit when calling delegates compared to direct method calls. (See the Delegates section here).

private void FetchStockQuotesApm(WebService svc)
{
    // This never blocks. Your code returns immediately.
    Func<IStockQuote> @delegate = svc.FetchStockQuotes;
    @delegate.BeginInvoke(FetchStockQuotesApmCallback, @delegate);
}
 
private void FetchStockQuotesApmCallback(IAsyncResult ar)
{
    // The operation completed asynchrnously.
    Func<IStockQuote> @delegate = (Func<IStockQuote>)ar.AsyncState;
    IStockQuote qt  = @delegate.EndInvoke(ar);
}

Unfortunately, it turns out that the APM does not look so sexy and most of the developers just don't use it.

The future of asynchronous programming in C# adheres to a new framework pattern called the Task-based Asynchronous Pattern (TAP).

The new language features async and await and the TAP allow you to do this:

private async void FetchStockQuotesAsyncCtp(WebService svc)
{
    IStockQuote qt = await svc.FetchStockQuotesTaskAsync();
}

Well, this is exciting. The method is marked as async. This means that the method body is compiled specially, allowing parts of it to be turned into callbacks. The FetchStockQuotesTaskAsync method returns a Task<IStockQuote> by converting the BeginFetchStockQuotes/EndFetchStockQuotes methods into a task. Until the task completes, there is nothing to do but await for it.

Here is how the FetchStockQuotesTaskAsync method is written:

public static Task<IStockQuote> FetchStockQuotesTaskAsync(this IWebService svc)
{
    return Task<IStockQuote>.Factory.FromAsync(
        svc.BeginFetchStockQuotes, // BeginPart
        svc.EndFetchStockQuotes,   // EndPart
        null);                     // State, Options
}

FetchStockQuotesTaskAsync is an extension method, because adding this feature directly to the WebService class will break compatibility with previous versions of the .NET Framework (1.0, 1.1, 2.0). Also, if you don't own the code of the WebService class you would define it as an extension method anyway.

It becomes very clear that in the near future it's the programming language that will handle most of the asynchronous stuff and not the programmer. Currently, you can download and install the Async CTP. For more information around the new features you can visit the official website here.

The sample application can be found here.

An alternative (.NET 2.0) to the Task-based Asynchronous Pattern

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 31 Oct 2010 00:00:00 GTB Daylight Time

Write code that looks like synchronous but actually executes asynchronously with the PowerThreading library and the AsyncEnumerator class.

In the previous post I discussed about the new language features that will help the developers write asynchronous code easily without having to split their flow in callback methods. In this post I want to show you an alternative way of doing this using the AsyncEnumerator class. This works for .NET 2.0+ and it is very similar with the upcoming features.

AsyncEnumerator class resides in the PowerThreading library. It is written by Jeffrey Richter and can be obtained from the Wintellect website.

I will start, again, with some code that executes synchronously:

private void FetchStockQuotesSync(WebService svc)
{
    // This blocks. You don't know when the FetchStockQuotes
    // method returns. It may takes from minutes, to hours or
    // it may not return at all.
    IStockQuote qt = svc.FetchStockQuotes();
}

Fortunately the WebService class implements the IAsyncResult interface, so the same code can be executed asynchronously using the AsyncEnumerator class:

// Inside your method create an instance of an AsyncEnumerator class,
// specifying the iterator method to be driven by the AsyncEnumerator.
AsyncEnumerator ae = new AsyncEnumerator();
ae.BeginExecute(GetStockQuotesAsyncEnumerator(ae, svc), ae.EndExecute);
 
private static IEnumerator<int> GetStockQuotesAsyncEnumerator(
    AsyncEnumerator ae, WebService svc)
{
    svc.BeginGetStockQuotes(ae.End(), null);
    yield return 1;
    IStockQuote qt = svc.EndGetStockQuotes(ae.DequeueAsyncResult());
}

This technique is similar to the new language features for asynchronous programming. In fact, what I've discussed works from .NET 2.0 up to any future version.

A very interesting topic regarding the AsyncEnumerator class and the Async CTP can be found at the PowerTheading discussion group.

Until the Async CTP is shipped you can benefit from what already exists. I have been using the AsyncEnumerator class for quite a long time and I am very happy with it. However, the Async CTP looks promising but it would be very interesting to see some performance measurements in the future.

CodeProject

The sample application can be found here.

A pragmatic approach on open source software

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Wed, 27 Oct 2010 00:00:00 GTB Daylight Time

Using a product because you can view or modify the source code is not the point. It is like watching a movie that is split in 2 parts (or 2 disks) and you are in the beginning of the first one. Can you guess the ending yet? (Only if you are not watching it for the first time). Some people are cinephile and can really guess a lot still from the beginning. But such kind of people are not the majority.

The same applies when building a product. You need to be an experienced architect in order to choose the right tools from the beginning, trying to look as far as possible in the future to prevent drawbacks and bottlenecks.

There are really too many kinds of combinations:

Those that don't have a clue about open-source software, (period).
Those that don't have a clue about open-source software, but they are using it.
Those that know what open-source software is, but don't actually use it, maybe because they are retired, or whatever (I don't want to be negative).
Those that know what open-source software is, they use it, but they never modify it (the majority).
Those that know what open-source software is, they use it, modify it, send patches (maybe they commit also).

From the above, if I run a company (ISV) or if I was a manager in a large organization doing enterprise software, I would only chose to work with people from the last 2 bullets. Do you know why? Well let me give you an example: What components do you need for an enterprise software using .NET?

AOP
Caching
Data Access
DI
Logging
Policy
Security
Validation

Ask now a few which tools they would use for the above? You will get answers like "NHibernate for Data Access" and "Castle Windsor or StructureMap for DI". These are the most popular not to say the de facto. So, why bother writing your own ORM since you can use NHibernate, why bother writing your own DI container since you can use an existing (and mature) one?

Let's be pragmatic.

Why we are getting paid? We are getting paid to deliver a responsive, scalable, working product. In order to achieve this we need to get equipped with the components mentioned above. Why not write our owns? Because (repeat) "we are getting paid to deliver a responsive, scalable, working product" we are not getting paid to build a specific reusable application block. But since we need to reuse as much code as possible we try to build around reusable application blocks. Why we are not using commercial (closed-source) products? Because if something fails in 02:00 AM we won't have access to the source code? This is a false statement, in 02:00 AM even if you have access to the source, you have no brain to study it. Actually you may, even, need some time to to build from source and start debuggin.

Wake up at 02:00 AM and try to workaround on what I have previously discussed.

Let's say though, you build the source, find the bug and fix it. Then what? You would send a patch and hope that it will be out with the next release. If not, then you need to maintain your local copy and keep it sync with the current public stable release.

What happens if you don't find the bug? Or don't know how to fix it? Or you can't get support in the forums? Do you know that there are companies out there selling commercial support for open-source software? Yes, you read it, commercial support for open-source software! What's the difference with using a commercial product now? The difference is the community :-) It's about the community of the open-source users, the culture, and knowledge sharing in forums, discussion groups and blogs. Yes, I buy this! But I don't buy commercial support for an open-source product. If I had to chose this way, I would prefer to change career.

Knockout! MVVM with HTML + JavaScript

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 24 Oct 2010 00:00:00 GTB Daylight Time

Download notepad2.
Unzip, Run.
Copy-paste the markup below.
Save.

<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <script type="text/javascript"
        src="http://knockoutjs.com/js/knockout-2.1.0.js"></script>
  </head>
  <body>
    <div>
      <p>
        In this example, the two text boxes are bound to
        <em>observable</em> variables on a data model. The "full name"
        display is bound to a <em>dependent observable</em>, whose value
        is computed in terms of the observables.</p>
      <h2>
        Live example</h2>
      <div>
        <p>
          First name:
          <input data-bind="value: firstName" /></p>
        <p>
          Last name:
          <input data-bind="value: lastName" /></p>
        <h2>
          Hello, <span data-bind="text: fullName"></span>!</h2>
        <script type="text/javascript">
          var viewModel = {
            firstName: ko.observable(""),
            lastName : ko.observable("")
          };
          viewModel.fullName = ko.dependentObservable(function () {
            return viewModel.firstName() + " " + viewModel.lastName();
          });
          ko.applyBindings(viewModel);
        </script>
      </div>
    </div>
  </body>
</html>

Don’t forget to visit the Knockout website.

Hosting Agatha in a Managed Application

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sat, 23 Oct 2010 00:00:00 GTB Daylight Time

When designing your Service Layer you need to choose a communication mechanism according to your needs. Duplex, Fire and Forget, Reliable Sessions and Request Response are the most common messaging patterns.

With Request-response, the client expects to receive a response for every message that's been sent. You can design such a Service Layer using an ESB architecture if you need to connect different applications (even from different platforms). Though, if you need to write a typical client - back-end - database application you can choose not to go with an ESB (Rhino ServiceBus, NServiceBus) and use WCF.

When using NHibernate in an enterprise application the most common issue is how to automatically open and close a Session (per Request). With WCF you need to follow the steps described here. Also for each of your services you need to expose an ABC via app.config. On the other hand using Rhino ServiceBus and NServiceBus makes your life a lot easier.

Davy Brion mentions here with more detail what I've discussed above and he provides the Agatha project. With it, you define RequestHandlers (like Consumers in the ESB world) and Agatha infrastructure will handle the rest. Everything is done with a single endpoint which makes you forget about app.config and ABCs.

With Agatha NHibernate Session-per-Request is easy. You can use your favorite DI container and have a session provided through your handler's constructor. You can even abstract the session by following the steps described here.

With Agatha, you can host your services easily on IIS or in a Console Application using AlwaysUp. If you choose the latter there are a few things to do inside your Main() method.

Uri  baseAddress = new Uri("<uriString goes here>");
ServiceHost host = new ServiceHost(typeof(WcfRequestProcessor), baseAddress);
host.Open();
 
// Agatha's WcfRequestProcessor handles the requests.
// Your service is up. There is really nothing else to do here.

System.Console.ReadKey(false);
host.Close();

Here I create an instance of the ServiceHost class, passing a WcfRequestProcessor type that represents the service type and the base address Uniform Resource Identifier (URI) to the ServiceHost.

Here is the generic app.config that Agatha needs:

<?xml version="1.0"?>
<configuration>
  <system.serviceModel>
    <services>
      <service name="Agatha.ServiceLayer.WCF.WcfRequestProcessor"
               behaviorConfiguration="RequestProcessorBehavior">
        <endpoint address=""
                  contract="Agatha.Common.WCF.IWcfRequestProcessor"
                  binding="basicHttpBinding"
                  bindingConfiguration="RequestProcessorBinding"/>
      </service>
    </services>
    <bindings>
      <basicHttpBinding>
        <binding name="RequestProcessorBinding"
                 maxReceivedMessageSize="2147483647"
                 receiveTimeout="00:30:00"
                 sendTimeout="00:30:00">
          <readerQuotas maxStringContentLength="2147483647"
                        maxArrayLength="2147483647"/>
          <security mode="None" />
        </binding>
      </basicHttpBinding>
    </bindings>
    <behaviors>
      <serviceBehaviors>
        <behavior name="RequestProcessorBehavior">
          <serviceMetadata httpGetEnabled="true"/>
          <serviceDebug includeExceptionDetailInFaults="true"/>
          <dataContractSerializer maxItemsInObjectGraph="2147483647"/>
          <serviceThrottling maxConcurrentCalls="500"
                             maxConcurrentInstances="500"/>
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>
  <startup>
    <supportedRuntime version="v4.0"
                      sku=".NETFramework,Version=v4.0"/>
  </startup>
  <runtime>
    <gcServer enabled="true"/>
  </runtime>
</configuration>

I included the <gcServer> element to instruct CLR to use server garbage collection. Inside your Main() method you can include the code below:

Console.WriteLine("{0} is {1}running with server GC.",
    Assembly.GetEntryAssembly().GetName().Name,
    GCSettings.IsServerGC == true ? string.Empty : "not ");

I would really like to share how it looks in Process Explorer when handling 6000 requests using Agatha.

Agatha 6000 request-response synchronous

Agatha 6000 request-response asynchronous

Why in the asynchronous case the memory consumption is a little higher? Well, this is something expected. Every asynchronous call creates an IAsyncResult object. So even that the calls are non-blocking we have an overhead of 6000 IAsyncResult objects on the heap (yes, on the heap since they are not value types). Though, as you can see from the screenshot, when the GC kicks in the memory is reclaimed.

Well that's it! Agatha works great, it's great, I really like it. Goodbye to the existing (and conservative, and painful) WCF usage.

The sample application can be found here.

Make sure you are running the application with elevated priviledges else a System.ServiceModel.AddressAccessDeniedException will be thrown indicating that your process does not have access rights to get registered at the base address were your service is hosted.

Adventures using Rhino ServiceBus

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Wed, 20 Oct 2010 00:00:00 GTB Daylight Time

Recently, with the team I work, we tried Rhino ServiceBus on a project. The fact that it has it's own queuing subsystem Rhino Queues (which requires no installation or administration) and it is integrated with the IoC container (we had already chosen for that project), Castle Windsor, made it a good candidate for spending some weeks trying it.

While we were doing some sort of stress testing (about 6000 requests), we noticed that the memory was increasing (like it does in a memory leak situation).

Since the behavior was unexpected, we spent some time on ways to workaround it, incl. reading the source code, building with the latest and greatest. My colleague, G. Nikolaropoulos, started also a thread on the Rhino Tools Dev discussion group. We got feedback very fast: the memory is held inside Rhino Queues, to avoid replying with the same message more than once in case of network loss. Every 3 minutes, Rhino Queues cleans the list up and memory is freed.

We built a very basic sample application but we also tested the article code that was published on MSDN (there is also a second part). The behavior was the same even after 3 minutes wait (not to say worse).

We thought it should be fair to investigate even further and ask in person via E-mail. We got a reply fast, instructing that we should set the Extensible Storage Engine (ESE) CacheSizeMax parameter to 1024. Rhino Queues use ESE internally for message storage.

In the sample application which can be found on here, I set the CacheSizeMax to 512.

But what exactly is the CacheSizeMax parameter?

Well, Rhino Queues uses the ManagedEsent library which provides managed access to ESE. I opened the library with Reflector and searched for the CacheSizeMax which is declared inside the JET_param enum.

Microsoft.Isam.Esent.Interop.JET_param, CacheSizeMax This parameter configures the maximum size of the database page cache. The size is in database pages. If this parameter is left to its default value, then the maximum size of the cache will be set to the size of physical memory when JetInit is called.

Setting the Microsoft.Isam.Esent.Interop.SystemParameters.CacheSizeMax to 1024 or 512 seems to solve the problem with the increasing memory usage. The question is, if this call sets a global variable then it may have a negative impact to the rest applications using the ESE (ex. Microsoft Exchange).

I decided to contact Laurion Burchall, a Software Engineer on the ESE/ESENTteam, with my question. The answer: The setting is per-process so it won’t cause problems with other applications that use ESENT. By default ESENT will automatically manage the cache size so you shouldn’t need to worry. We look at the amount of free memory on the system, the amount of paging activity and the amount of database I/O when deciding on the cache size. Although the cache is growing you should find that the system isn’t paging and that if you start using memory in other applications ESENT will actually shrink its cache.

It is very easy to use and deploy with Rhino ServiceBus. If you are planning to use it, I hope you find this information useful.

Exposing asynchronous features to client code for Windows Phone 7

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 17 Oct 2010 00:00:00 GTB Daylight Time

Today, line of Internet and multimedia-enabled smartphones have become popular. Fortunately if you are a .NET developer you can use your existing skills and language and target some of the most popular mobile operating systems.

Windows Phone 7 is a mobile operating system developed by Microsoft, and is the successor to their Windows Mobile platform.

You can expose asynchronous features to client code using one of the following .NET Framework's Asynchronous Programming Models:

IAsyncResult The CLR’s Asynchronous Programming Model (APM)
Event-based Asynchronous Pattern (EAP)

IAsyncResult has been around since .NET 1.0 and has been used in most BCL classes, while the main benefit of the EAP is that it integrates with the Visual Studio UI designers. You can learn how to properly implement the IAsyncResult interface (APM) from the excellent article on MSDN, Implementing the CLR Asynchronous Programming Model, by Jeffrey Richter.

In this post I will show you how easy it to use types implementing the IAsyncResult interface on Windows Phone 7. I will use the PowerThreading library because it provides a similar (not to say an improved) implementation of the one described in the original MSDN article. I will explain how to use it and how this becomes easier using the AsyncEnumerator class.

AsyncEnumerator class resides in the PowerThreading library. It is written by Jeffrey Richter and can be obtained from the Wintellect website.

The sample Windows Phone 7 application can be found here.

Sync I/O pauses the UI

The code below shows how ExecuteWithSyncIO method is implemented. The application shows a MessageBox to the user that the UI will pause while the execution is in progress.

private void ExecuteWithSyncIO()
{
    for (int n = 0; n < iterations; n++)
    {
        this.webService.GetStockQuotes();
    }
    SetStatus("Sync/IO completed.", StatusState.Ready);
}

Delegate's BeginInvoke method is not supported

private void ExecuteWithDelegateBeginInvoke()
{
    Func<IStockQuote> stockQuoteDelegate = this.webService.GetStockQuotes;
    // NOTE: Calling delegates asynchronously is NOT supported in WP7.
    stockQuoteDelegate.BeginInvoke((ar) =>
    {
        stockQuoteDelegate.EndInvoke(ar);        
    }, null);
}

The code below shows how ExecuteWithDelegateBeginInvoke method is implemented.

This method is here just for the demo, since it is not allowed to invoke a delegate asynchronously in the Compact Framework.

private void ExecuteWithDelegateBeginInvoke()
{
    Func<IStockQuote> stockQuoteDelegate = this.webService.GetStockQuotes;
    // NOTE: Calling delegates asynchronously is NOT supported in WP7.
    stockQuoteDelegate.BeginInvoke((ar) =>
    {
        stockQuoteDelegate.EndInvoke(ar);        
    }, null);
}

IAsyncResult interface

The code below shows how the ExecuteWithIAsyncResult method is implemented. The only problem is that, when using the IAsyncResult, you need to specify a method to be called when a corresponding asynchronous operation completes. This can result in using synchronization constructs to avoid race conditions. It also splits the flow of your code. You can inline the callback method using Anonymous Methods or Lamda Expressions as shown below but if your logic is complicated your code will not be beautiful.

private void ExecuteWithIAsyncResult()
{
    SetStatus("Working..", StatusState.Busy);
 
    for (int n = 0; n < iterations; n++)
    {
        this.webService.BeginGetStockQuotes((ar) =>
        {
            // Callback method inlined using Lamda Expressions.

            // NOTE: Code can become ugly here, specially if you need to do 
            // a lot of stuff that touch properties bounded with UI elements.
            if (Interlocked.Increment(ref this.numDone) == iterations)
            {
                Execute.OnUIThread(() =>
                {
                    SetStatus("IAsyncResult APM completed.",
                        StatusState.Ready);
                });
            }
        }, null);
    }
}

AsyncEnumerator class

The code below shows how ExecuteWithAsyncEnumerator method is implemented. As you can see this method makes your code looks like it's executing synchronously but actually it executes asynchronously. You do not have to split your code in callback methods or inlined delegates. You do not need to marshall calls in the UI thread using the Dispacher or the SynchronizationContext. All this stuff is handled by the AsyncEnumerator class.

private IEnumerator<int> ExecuteWithAsyncEnumerator(AsyncEnumerator ae)
{
    for (int n = 0; n < iterations; n++)
    {
        this.webService.BeginGetStockQuotes(ae.End(), null);
    }
 
    // AsyncEnumerator captures the calling thread's SynchronizationContext.
    // Set the Wintellect.Threading.AsyncProgModel.SynchronizationContext to
    // null so that the callback continues on a ThreadPool thread.
    ae.SyncContext = null;
    yield return iterations;

    for (int n = 0; n < iterations; n++)
    {
        this.webService.EndGetStockQuotes(ae.DequeueAsyncResult());
    }
 
    // AsyncEnumerator captures the synchronization context.
    SetStatus("AsyncEnumerator completed.", StatusState.Ready);
}

While what I've discussed in this post applies to Mobile application development, the same principles can be applied to Rich Internet applications and Smart client. I have been using the AsyncEnumerator class for over two years and I have to say that it changed the way I think about using the APM. At the end.. delivering responsive applications makes the end-users happy.

List of software engineering topics

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Thu, 14 Oct 2010 00:00:00 GTB Daylight Time

This list along with this one completes the list of topics a software engineer should be aware of (well, almost!).

GitHub + Visual Studio = Love

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Thu, 14 Oct 2010 00:00:00 GTB Daylight Time

I love GitHub. It's Network Graph Visualizer is outstanding! It solves one of the biggest challenges in open-source world; keeping track of what other people have done with the code base.

If you use Windows for writing your code you can use the tools described here to have Git on shell context-menu. For Visual Studio support you can use GitExtensions and/or Joshua Flanagan's GitMacros. The last one requires you to do some steps for adding the macros manually but it's worth it, since you can have some basic GitHub functionality in minutes (like opening the GitHub page for the current file).

Quick Comparison of NHibernate Books

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Mon, 11 Oct 2010 00:00:00 GTB Daylight Time

NHibernate is an Object-relational mapping (ORM) solution for the Microsoft .NET platform. It provides a framework for mapping an object-oriented domain model to a traditional relational database. It is open-source, easy to use (if you are familiar with good design principles) and offers a lot of extensibility points (logging and interception to name a few). The story begins with Hibernate in Java. In fact, there are many books out there for Hibernate but only a few for NHibernate (so far):

NHibernate In Action (Manning, 2009)
NHibernate 2 Beginner's Guide (Packt Publishing, 2010)
NHibernate 3.0 Cookbook (Pack Publishing, 2010)

NHibernate In Action is written by members of NHibernate (Pierre Henri Kuaté, Tobin Harris) and Hibernate (Christian Bauer, Gavin King) team. It contains a lot of stuff about the internals, such as, the persistence lifecycle, the persistence manager, transitive persistence, the NHibernate type system, advanced query techniques, optimizing object retrieval (I could go on).

NHibernate 2 Beginner's Guide, written by Aaron Cure, targets those who have not used an ORM yet. It helps you find about what is NHibernate, why would you use it, where do you get it, and more. It guides you on how to create mappings (XML and Fluently), types, relationships and more. It contains a whole chapter about Code Generation and even talks about Burrow.

NHibernate 3.0 Cookbook, written by Jason Dentler, is the most recent and most updated. In the chapter about mappings, (besides XML and Fluently) it discuss about creating mappings in code using ConfORM. It describes the Conversation per Business Transaction pattern, the use of Futures, NHibernate Spatial and more! It focus on testing and describes the use of NHibernate Profiler and the Fluent NHibernate Persistence Tester among other. It even promotes design patterns and talks about using dependency injection with entities.

Allowing only one instance of a WPF application to execute

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Mon, 11 Oct 2010 00:00:00 GTB Daylight Time

Sometimes, for any reason, you want to have only one instance per application.

Search on the internet and you will find many different ways of doing this. However, inside Jeffrey Ricther's excellent book there is a way of allowing only one instance of an application (Console, WinForms, WPF) to execute at any given time using kernel-mode constructs.

Using what has been described in the book and searching at P/Invoke.net, I wrote some code that works with WPF applications. The code also attempts to set focus on the window and if it's minimized it will attempt to restore it.

using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows;
 
internal partial class App : Application
{
    private static readonly Semaphore singleInstanceWatcher;
    private static readonly bool createdNew;
 
    static App()
    {
        // Ensure other instances of this application are not running.
        singleInstanceWatcher = new Semaphore(
            0, // Initial count.
            1, // Maximum count.
            Assembly.GetExecutingAssembly().GetName().Name,
            out createdNew);
 
        if (createdNew)
        {
            // This thread created the kernel object so no other instance
            // of this application must be running.
        }
        else
        {
            // This thread opened an existing kernel object with the same
            // string name; another instance of this app must be running now.
 
            // Gets a new System.Diagnostics.Process component and the
            // associates it with currently active process.
            Process current = Process.GetCurrentProcess();
 
            // Enumerate through all the process resources on the share
            // local computer that the specified process name.
            foreach (Process process in
                 Process.GetProcessesByName(current.ProcessName))
            {
                if (process.Id != current.Id)
                {
                    NativeMethods.SetForegroundWindow(
                        process.MainWindowHandle);
                    NativeMethods.ShowWindow(process.MainWindowHandle, 
                        WindowShowStyle.Restore);
                    break;
                }
            }
 
            // Terminate this process and gives the underlying operating 
            // system the specified exit code.
            Environment.Exit(-2);
        }
    }
 
    private static class NativeMethods
    {
        /// <summary>
        /// Brings the thread that created the specified window into the
        /// foreground and activates the window. Keyboard input is directed
        /// to the window, and various visual cues are changed for the user.
        /// The system assigns a slightly higher priority to the thread that
        /// created the foreground window than it does to other threads.
        /// </summary>
        /// <param name="hWnd">A handle to the window that should be
        /// activated and brought to the foreground.
        /// </param>
        /// <returns>If the window was brought to the foreground, the
        /// return value is nonzero. </returns>
        [DllImport("user32.dll")]
        internal static extern bool SetForegroundWindow(IntPtr hWnd);
 
        /// <summary>Shows a Window</summary>
        /// <remarks>
        /// <para>To perform certain special effects when showing or hiding a
        /// window, use AnimateWindow.</para>
        /// <para>The first time an application calls ShowWindow, it should use
        /// the WinMain function's nCmdShow parameter as its nCmdShow ..
        /// Subsequent calls to ShowWindow must use one of the values in the
        /// given list, instead of the one specified by the WinMain function's
        /// nCmdShow parameter.</para>
        /// <para>As noted in the discussion of the nCmdShow parameter, the
        /// nCmdShow value is ignored in the first call to ShowWindow if the
        /// program that launched the application specifies startup information
        /// in the structure. In this case, ShowWindow uses the information
        /// specified in the STARTUPINFO structure to show the window. On
        /// subsequent calls, the application must call ShowWindow with ..
        /// set to SW_SHOWDEFAULT to use the startup information provided by ..
        /// program that launched the application. This behavior is designed ..
        /// the following situations: </para>
        /// <list type="">
        ///    <item>Applications create their main window by calling ..
        ///    with the WS_VISIBLE flag set. </item>
        ///    <item>Applications create their main window by calling ..
        ///    with the WS_VISIBLE flag cleared, and later call ShowWindow ..
        ///    SW_SHOW flag set to make it visible.</item>
        /// </list></remarks>
        /// <param name="hWnd">Handle to the window.</param>
        /// <param name="nCmdShow">Specifies how the window is to be shown.
        /// This parameter is ignored the first time an application calls
        /// ShowWindow, if the program that launched the application provides a
        /// STARTUPINFO structure. Otherwise, the first time ShowWindow .. ,
        /// the value should be the value obtained by the WinMain function ..
        /// nCmdShow parameter. In subsequent calls, this parameter ..
        /// the WindowShowStyle members.</param>
        /// <returns>
        /// If the window was previously visible, the return value is nonzero.
        /// If the window was previously hidden, the return value is zero.
        /// </returns>
        [DllImport("user32.dll")]
        internal static extern bool ShowWindow(IntPtr hWnd,
            WindowShowStyle nCmdShow);
    }
 
    /// <summary>
    /// Enumeration of the different ways of showing a window.</summary>
    internal enum WindowShowStyle : uint
    {
        /// <summary>Hides the window and activates another window.</summary>
        /// <remarks>See SW_HIDE</remarks>
        Hide = 0,
        /// <summary>Activates and displays a window. If the window ..
        /// or maximized, the system restores it to its original size and
        /// position. An application should specify this flag when displaying
        /// the window for the first time.</summary>
        /// <remarks>See SW_SHOWNORMAL</remarks>
        ShowNormal = 1,
        /// <summary>Activates the window and displays it ..</summary>
        /// <remarks>See SW_SHOWMINIMIZED</remarks>
        ShowMinimized = 2,
        /// <summary>Activates the window and displays it ..</summary>
        /// <remarks>See SW_SHOWMAXIMIZED</remarks>
        ShowMaximized = 3,
        /// <summary>Maximizes the specified window.</summary>
        /// <remarks>See SW_MAXIMIZE</remarks>
        Maximize = 3,
        /// <summary>Displays a window in its most recent size and position.
        /// This value is similar to "ShowNormal", except the window is not
        /// actived.</summary>
        /// <remarks>See SW_SHOWNOACTIVATE</remarks>
        ShowNormalNoActivate = 4,
        /// <summary>Activates the window and displays it in its current size
        /// and position.</summary>
        /// <remarks>See SW_SHOW</remarks>
        Show = 5,
        /// <summary>Minimizes the specified window and activates the next
        /// top-level window in the Z order.</summary>
        /// <remarks>See SW_MINIMIZE</remarks>
        Minimize = 6,
        /// <summary>Displays the window as a minimized window. This value is
        /// similar to "ShowMinimized", except the window ..</summary>
        /// <remarks>See SW_SHOWMINNOACTIVE</remarks>
        ShowMinNoActivate = 7,
        /// <summary>Displays the window in its current size and position. This
        /// value is similar to "Show", except the window ..</summary>
        /// <remarks>See SW_SHOWNA</remarks>
        ShowNoActivate = 8,
        /// <summary>Activates and displays the window. If the window is
        /// minimized or maximized, the system restores it to its original size
        /// and position. An application should specify this flag ..
        /// a minimized window.</summary>
        /// <remarks>See SW_RESTORE</remarks>
        Restore = 9,
        /// <summary>Sets the show state based on the SW_ value specified ..
        /// STARTUPINFO structure passed to the CreateProcess function by the
        /// program that started the application.</summary>
        /// <remarks>See SW_SHOWDEFAULT</remarks>
        ShowDefault = 10,
        /// <summary>Windows 2000/XP: Minimizes a window, even if the thread
        /// that owns the window is hung. This flag should only be used when
        /// minimizing windows from a different thread.</summary>
        /// <remarks>See SW_FORCEMINIMIZE</remarks>
        ForceMinimized = 11
    }
}

One improvement would be to restore the window only if it's minimized by checking the return value of SetForegroundWindow method. I leave this to you, go on and adapt it to your own needs.

Let's Pack! Nubular, HornGet and NuPack

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Fri, 08 Oct 2010 00:00:00 GTB Daylight Time

Update: At the time of this writting NuGet was called NuPack.

Package Management is not easy, unless you are doing very (very) small projects. It can be quite complex if your project is developed in-house for a company (enterprise).

If you haven't tried anything yet, have a look at the following Package Management tools:

Nubular was pretty much the same with RubyGems.org There are pre-uploaded packages that you can download and use in your project. For example, to use Castle Active Record you don't need to follow the steps described here. Just grab the package, unpack and you are done.

What many don't understand is the situation where you reference for example Moq, AutoMapper and Castle Windsor, all in one project (version numbers are fictional):

Moq uses Castle.DynamicProxy.dll v1.1
AutoMapper uses Castle.DynamicProxy.dll v1.2
Castle Windsor uses Castle.DynamicProxy.dll v.1.3 (in fact, latest public release of Windsor has DynamicProxy merged in the same assembly)."

HornGet was able to deal with this situation, it could build Moq using the latest and greatest, AutoMapper and Windsor too. You end up with three assemblies that referenced the same version of the depenency/ies.

Even if you choose this path, it is the hardest one because you need to run all the unit-tests in the projects (Moq, AutoMapper, Windsor) and make sure they pass with the latest version in /trunk of DynamicProxy. And this is not enough, you need to run all the tests (unit and intergration) of your project. After all the above pass, you can go home early. But I am sure that it is already early afternoon and you spent at least 4 hours doing this.

Of course you may not choose to go with this path and install the different versions of Castle.DynamicProxy.dll in GAC. That way Nubular worked great!

NuPack is a new Package Management tool for the .NET Framework that aims to make your life a lot more easier. It integrates with Visual Studio 2010 and there are a some interesting people behind it.

Have a look at the documentation and start using it.

Building Castle ActiveRecord from Source at GitHub

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Thu, 07 Oct 2010 00:00:00 GTB Daylight Time

To follow the steps described in the post you will need:

Visit https://github.com/castleproject/ActiveRecord and copy to clipboard the URL for Read-Only access.

Create an empty directory and select the entry named "Git Clone..." on the Windows Explorer Context Menu.

Click OK in the next screen and wait while Git is downloading the project files.

When finished, you can browse the project files in the specified directory.

The default is to build for version 4.0 of the .NET Framework. If you need to build for an older version you can edit the build.cmd file (it is actually a batch file).

The project's build platform is MSBuild as you can see from the Console Output above.

Open folder "build" which is the project's build output.

As you may notice, the project now uses Remotion's re-linq provider.

To have a working data access layer in minutes, add a reference to:

Castle.ActiveRecord.dll
Castle.Components.Validator.dll

The documentation is here. Feel free to contribute.

BindingBase.StringFormat Property (System.Windows.Data)

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Thu, 07 Oct 2010 00:00:00 GTB Daylight Time

By default the WPF binding engine uses 2 fractional digits when displaying double values. When those digits are zero though, they are omitted. You can override this by specifying the StringFormat Property on the binding.

Text="{Binding Path=Price, StringFormat={}{0:0.00}}"

StringFormat can be a predefined, composite, or custom string format. For more information about string formats, see Formatting Types here.