My frient Guardian blogged some minutes ago explaining how you can change the mapping of your codeplex project now that codeplex is migrated to TFS2010. There is even a simpler solution, first of all open Visual Studio, then connect to the new tfs server. As you can see in Figure 1 I have projects in three project collection, I select to connect to the TFS08 project collection where I’m contributor to two project

Figure 1: Connect to the new codeplex address

Now, after you are connected to the right project collection, simply open the code from the local workspace that still maps to the old server, and Visual Studio should upgrade everything automatically. To verify if everything is ok, go to menu: File –> Source Control –> Workspaces and verify the server mapped in the workspace as in Figure 2.

Figure 2: The workspace has automatically changed server and now points to the right one.

alk.

I need in a simple project the ability to communicate various type of messages through different View Model in a WPF application, some VM raise some message about something that is happened in the system, and other VM can listen for messages and doing something with them.

I know that there are a lot of framework out of there, but sometimes you need a quick implementation that you can share with the team, without the need to tell to others “Hey you need to master xxx framework for understanding what is happening”. The result is a really 30 minutes implementation of a primitive broker. I want a central component where every View Model can register/unregister for a specific kind of a message, and send messages.

I decided to discriminate messages based on the type of data contained in the message, the message itself is a simple class with a message string and a payload.

View Models register for a specific kind of payload, as an example I want to be able of issue this code to register whenever someone send a message with a  payload of type List<ActionLogViewModel>.

   1: broker.RegisterForMessage<List<ActionLogViewModel>>(ReceiveLog);

The result is this really simple class, that is based on delegate

It maintains internally a dictionary of registered action based on type of the payload

   1: private Dictionary<Type, List<Object>> _registeredActions = 

   2:     new Dictionary<Type, List<Object>>();

The RegisterForMessage<T> is really simple, because I simply need to save an Action<Message<T>> into the dictionary.

   1: public void RegisterForMessage<T>(Action<Message<T>> action)

   2: {

   3:     List<Object> actions;

   4:     if (!_registeredActions.ContainsKey(typeof(T)))

   5:     {

   6:         actions = new List<Object>();

   7:         _registeredActions.Add(typeof(T), actions);

   8:     }

   9:     else

  10:     {

  11:         actions = _registeredActions[typeof(T)];

  12:     }

  13:  

  14:     actions.Add(action);

  15: }

The send message is a very simple function too because it look for registered action in the internal dictionary, and executes them one after the other.

I know that this is really a too simple implementation for a serious brocker system, but for a  simple program, where my only need is to dispatch some messages between windows, it is enough. The main advantage of this approach, is that it is really simple to understand, and I can avoid to force other members of the team to learn new framework.

alk.

The situation is the following: I have a class that has a Status property of type SingleAnalysisStatus enum, and I want to show a different png image, based on the status of the object.

The solution is to write a custom IValueConverter that convert from the enum to a valid resource file, but we need to pay specific attention. In WPF you can include images as resources in a very simple way, just include the images in the project and set the “build Action” to Resource, as shown in Figure 1.

Figure 1: include an image file as resource in a WPF application

In this way you can simply use this syntax to assign a resource image to an object of type Image

   1: <Image 

   2:     HorizontalAlignment="Left" 

   3:     Height="100" 

   4:     Width="100" 

   5:     Source="/Images/NotMatch.png"/>

You can simply specify the path of the image in the Source property of an Image Element, but to show a different image depending on the value of an enum requires a specific ValueConverter, and you need to be aware that this converter need to convert from the original type to a BitmapImage object, because the Source property of an <image> will not accepts string during binding. Here is how you can accomplish this.

   1: <Window.Resources>

   2:    <Converter:SingleAnalysisStatusConverter x:Key="statusconverter" />

   3:    <DataTemplate x:Key="ItemTemplate">

   4:      <DockPanel> 

   5:         <Image HorizontalAlignment="Right" Height="24" Margin="0"

   6:                       Source="{Binding Status, Converter={StaticResource statusconverter}}"

   7:                       VerticalAlignment="Bottom" Width="24" Stretch="Fill" />

In this snippet of code I’m showing how to bind the Source property of an Image to the Status property of the underling ViewModel, and thanks to the SingleAnalysisStatusConverter object I’m able to convert the status to a valid BitmapImage object. This is the full code of the IValueConverter object.

   1: class SingleAnalysisStatusConverter: IValueConverter 

   2: {

   3:     

   4:     #region IValueConverter Members

   5:  

   6:     public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

   7:     {

   8:         if (!(value is SingleAnalysisStatus))

   9:             throw new NotImplementedException("SingleAnalysisStatusConverter can only convert from SingleAnalysisStatus");

  10:  

  11:         String path = null;

  12:         switch ((SingleAnalysisStatus ) value)

  13:             {

  14:                 case SingleAnalysisStatus.NotAnalyzed:

  15:                     path = "Images/NotAnalyzed.png";

  16:                     break;

  17:                 case SingleAnalysisStatus.DuringAnalysis:

  18:                     path = "Images/DuringAnalysis.png";

  19:                     break;

  20:                 case SingleAnalysisStatus.Match:

  21:                     path = "Images/Match.png";

  22:                     break;

  23:                 case SingleAnalysisStatus.NotMatch:

  24:                     path = "Images/NotMatch.png";

  25:                     break;

  26:                 case SingleAnalysisStatus.ErrorDownload:

  27:                     path = "Images/DownloadError.png";

  28:                     break;

  29:             default :

  30:                     throw new NotSupportedException();

  31:             }

  32:         return new BitmapImage(new Uri("/AssemblyName;component/" + path, UriKind.Relative));

  33:     }

  34:  

  35:     public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

  36:     {

  37:         throw new NotImplementedException();

  38:     }

  39:  

  40:     #endregion

  41:  

  42: }

The key part is the line

return new BitmapImage(new Uri("/AssemblyName;component/" + path, UriKind.Relative));

that creates the BitmapImage passing an uri composed by the: assemblyname + semicolon + component/ + imagepath. With this simple converter I’m able to show different images based on content of a specific property.

Alk.

With Visual Studio 2010 we are expecting a great number on new adding, made possible from the new extension point offered by MEF, and in general with the migration of part of the interface to WPF. One of the most exiting addin is the Productivity Power Tool released by Microsoft. It has a great number of features, but one of the most useful is the ability to browse code in a really advanced way. If you simply hover over a class name or a variable a tooltip appears, as showed in Figure 1

Figure 1: hover on a class name or variable and a tooltip will appear.

Clicking on the tooltip will open a nice toolbar that shows a lot about the class, as visible in Figure 2.

Figure 2: you can browse a lot of information about the class.

Surely one of the most useful information is given by the reference tab as shown in Figure 3.

Figure 3: all references of a given type is shown in the windows

As you can see, you can immediately visualize every point in code where the class is used. This kind of Smart Browsing of code, is clearly avaliable even for method or properties, and permits you to quickly identify how a specific part of the code is used. And this is only one of the many features of this tool, so go and download it.

Alk.

Microsoft have just released the 1.0 version of the scrum template for TFS. The reason behind this, is that a lot of person wish a template that closely match the scrum process, as described in the literature.

With this template we now have two agile process template, the first is the classic MSF Agile 5.0, that is based on scrum, but is more generic and is not strictly based on a Scrum process, and the new Scrum template to satisfy those one that want to implement a full feature Scrum process.

Go and take a look at it.

alk.

One of the coolest news of TFS 2010 is the presence of Team Explorer Everywhere, a plugin for eclipse and a command line cross platform tool to access TFS. I do not work with Java, but I want to have a look at it, just to understand the level of integration with TFs.

First impression is really good, because the look and feel of the IDE is really similar to those of Visual Studio, as you can spot from Figure 1, where I show the connection windows to a local tfs.

Figure 1: Connect to a Tfs Server from Eclipse

After you connect to the Tfs, you can see the very familiar windows where I can choose project collection and team project I want to connect to, again in Figure 2 you can see that the look and feel is really similar to those one of Visual Studio.

Figure 2: Choose the list of team project you want to connect to.

Now the system suggest you to create a workspace, and you can immediately edit and map it to some source folder as you can see in Figure 3.

Figure 3: Create a workspace and map source to a local folder.

Now you can use eclipse like Team Explorer, it is quite identical, look at Figure 4 to see the Source Control windows that permits you to browse into the source code, it is really fast.

Figure 4: Source control windows to browse files into the repository

First impression is really good, I’m able to do query against Work Item, defining and editing builds, creating query etc etc. The Work Item viewer has all the functions of Team Explorer, and you can edit the query, choose column to view etc etc, as visible in Figure 5.

Figure 5: Work Item view, buttons to manage WI and Hierarchical View

The first impression on Team Explorer Everywhere, from the point of view of a developer that never worked seriously on eclipse is really good, because it has all the feature that TE has in Visual Studio.

alk.

To deploy application that use mshtml with clickonce, you need to be sure that microsoft.mshtml.dll is included in the setup of click once, or the application will not install if mshtml.dll is not present on the machine at the time of deploy. But if you include it sometimes clients are not able to install application due to the following error

Strong name signature not valid for this assembly Microsoft.mshtml.dll

this is due to the fact that you reference a partially signed version in your project. To solve this remove the reference to mshtml.dll and reference the dll in

C:\Program Files (x86)\Microsoft.NET\Primary Interop Assemblies\Microsoft.mshtml.dll

Remove the (x86) if you are on a 32 bit system. Now with the reference to this assembly be sure that is included in the clickonce application files and everything should now work.

alk.

It is time to connect together a couple of posts of mine, in the first I simply explained how to deploy a web application to a remote machine with the use of Beyondexec2, in another one I explained how to create a simple tfs build, that actually does not build anything, but execute a simple workflow.

In this post I’ll cover a primitive build workflow to deploy the result of another build. The starting point is having a build called “Demo” that builds a web site and create the installer package, plus the script described here. You need to insert the scripts and the PsExec utility in the source code of your team project, to be available from the build agent during the build, as shown in Figure 1. Note: in this example I’ll use the PsExec tools instead of beyondexecv2, but they are exactly equivalent, PsExex is more maintained tool and works better when execute in services.

Figure 1: Include deploy related files into source control system

Now you need to modify the deploy script created in the other blog post, adding all the operations needed to deploy a build, first of all you need to define some more parameters (Figure 2). These one are the number of the build to use (Es. demo_20100607.3) machine name where you want to install and the password of the administrator account of that machine.

Figure 2: Parameters of the workflow

Now, since the tools and script to do remote deploy are stored in source control system, the build scripts needs to create a workspace and do a getlatest; to do this, you can reuse the relative section of the standard workflow showed in Figure 3.

Figure 3: Details of workspace management

The steps from Figure 3 is taken from the standard workflow, and it is a common sequence of operation to create a workspace and do a getlatest plus managing some variables. If you run this workflow, as is, you can verify that in the build machine a new workspace is created, and you can browse to the build directory (usually c:\builds\1\teamprojectname\etcetc) to see downloaded files. But before doing this, you need to specify folder to grab in the workspace section of build configuration. As you can see in Figure 4, I simply need to grab the BuildTools subdirectory, because there is no need to do a get latest of project sources, but only of the deploy scripts.

Figure 4: Configuration of the workspace
Now I need only to execute the PsExec process to do a remote execution of the script in the machine where I want my web application to be deployed, and this can be done thanks to a simple Invoke Process Activity, as shown in Figure 5.

Figure 5: Invoke Process activity permits execution of an external process.

FileName property specify the process to execute, for this example is

SourcesDirectory + "\psexec.exe"

Since SourcesDirectory is the one used to map the workspace, I can execute the psexec directly from there. The other important property is the Arguments one:

"\\" + DeployMachine +  " -u " + DeployMachine + "\administrator -p " + DeployMachinePassword +
" /accepteula -i -f -h -c " + SourcesDirectory + "\deploy\Deployweb.bat " + BuildToUse

This is only a combination of Workflow Parameters to create the argument list, the /accepteula parameter is needed because the psexec shows an eula that should be accepted, and clearly there is noone to click on accept when executed on a service , then the option –c force a file to be copied to remote computer and executed. After the Invoke process, in Figure 6 I showed the end of the workflow, with a condition that verifies if the PsExec return value is zero (success) or greater than zero (error).

Figure 6: Check return value of PsExec and fail the build if greater than zero.

The SetBuildProperties activity permits to set a property of the build, in this situation I set the status as Failed. Now you can configure a build, configure parameters and see the result.

Figure 7: Log of a successful build.

The only drawback is that you only see output of the psexec program and does not see the output of the execution of DeployWeb.Bat on remote machine. Since you can specify, machine and build number to use, this is a good build script to deploy something on remote machine with a simple click.

alk.

P.S. this is the first post following Adam Cogan’s SSW Rules (thanks Adam, you rock)

- the balloon rule, instead of walls of text

http://sharepoint.ssw.com.au/Standards/Communication/RulesToBetterEmail/Pages/HowToUseBalloons.aspx

- the figure/caption rule

http://www.ssw.com.au/ssw/Standards/Rules/RulesToBetterWebsitesLayout.aspx#AlwaysAddFiguretoImages

Thanks to AOP concept, creating a cache layer that is transparent to the caller is not a big deal. I have a piece of code that in a loop calls this method

   1: ClientCompetitor competitor = Repository.ClientCompetitor.GetByCriteria(

   2:     Query.CreateEq("AssociatedClient", clieid))

   3: .SingleOrDefault();

   4:            

This is based on a standard implementation of repository and a Specification Pattern as a query model. With nhibernate profiler I see that during the execution of this task, a lot of identical query are issued, because it gets called around 1000 times always with the same clieid.

Now before changing the code of the class to store in a dictionary<ClieId, ClientCompetitor> cached result, I like to handle this with a transparent cache layer used with AOP. This could be achieved registering this interceptor.

   1: <component

   2:         id="RepositoryCache"

   3:         service="Castle.Core.Interceptor.IInterceptor, Castle.Core"

   4:         type="xxx.BaseServices.Castle.Cache2Interceptor, xxx.BaseServices"

   5:         lifestyle="transient">

   6:     <parameters>

   7:         <invocationCache>${WindowsCache}</invocationCache>

   8:         <Rules>

   9:             <dictionary>

  10:                 <entry key="ClientCompetitor.*GetByCriteria">.classname(ClientCompetitor) .absolute(600)</entry>

  11:             </dictionary>

  12:         </Rules>

  13:     </parameters>

  14: </component>

I simply create a Cache2Interceptor object that has a property called Rules to define regular expression to specify witch methods I want to apply cache to. With this configuration I ask to put cache in ClientCompetitor repository and with GetByCriteria method. The cache component use the Specification Pattern object for retrieving the key to the real cache implementation, and I tell cache component that the classname is (ClientCompetitor). The className is used because I can register other method as cache invalidator, as an example I can tell that the method Save of ClientCompetitor repository will invalidate the entire ClientCompetitor class.

When the interceptor is configured, I can simply tell castle to apply it to ClientCompetitor repository class, and the game is done.

Then I rerun the code and only one query gets issued, with no modification to the original code.

alk.

When you deal with continuous integration, building source is just one part of the problem, you need to run test, calculate metrics, deploy on test server and so on. To orchestrate the execution of integration scripts you need an infrastructure that is capable of scheduling, logging, distribution of agent and a central point of manteniance, TFS2010 build system has all this characteristics and many other that makes is suitable to run integration script, not only build one.

Tfs2010 build system essentially runs a window workflow 4.0 script to do some standard operation like, build, run test, gated checkin, and bla bla bla, but nothing prevents you to use it to execute operation different from building sources. To make a very trivial example, just go to the source folder of a team project, locate the folder BuildProcessTemplate and create a copy of DefaultTemplate.xaml, now check in and start modifying it removing arguments, variable etc.

Figure1: A simple build to log something.

In Figure1 I show a very trivial build, I removed completely everything, I create a sequence with very few actions, just to demonstrate that you can create a build that actually does not build anything, but it just execute an arbitrary workflow.

Figure2: A detailed view of the build steps.

In Figure2 I give you a more detailed description of the trivial build, the first two activities are needed to recover build details and to update the build number, because build number is used in the logging system of TFS and if you do not update it, you will end with build called 1, 2, 3, etc. For this example I’ve decided to give the build a number composed by the name of the build, followed by the sequential id. Finally I insert a couple of WriteBuildMessage activities, just to log something on the build. Since I’m planning to build a skeleton to create a custom workflow that deploy a specific build, in Figure1 you can see that there is a parameter called BuildToUse, when you create a new build, and choose this new workflow, you are presented with this only parameter in the “process” tab, as visible in Figure3.

Figure3: Choose your new workflow from a build definition

In Figure4 you can see the result of a build after the execution completes, as you can see, it simply logged something to the deploy log.

Figure4: The result of the build

This example is really trivial, but it shows you that you can use tfs2010 build to execute an arbitrary workflow, but thanks to tfs infrastructure you have all the benefit of a standard build: distributed agent, centralized log inside tfs, etc etc.

The next step is to modify this trivial workflow to execute something useful, like the deploy of a specific build on a test server.

alk.

Clearly Lab Management is really good to manage virtual environments and give a lot of flexibility on how to deploy your application on virtual machines, but if you do not have Lab Management you can still use the same technique to deploy application in remote computer during a build with the use of a simple scripts. The key is the ability to execute code on a remote computer with beyondexec or similar tool. Suppose you need to deploy an application called demo, you have a Tfs build called Demo, and you want to be able to deploy a specific build on a remote server, the solution could be this simple script

@echo off

set RemotePath= \\10.0.0.220\drops\demo\%1\_PublishedWebsites\Demo_Package\*.*
set LocalPath=c:\setup\demo

if exist %LocalPath% (
rmdir /s /q %LocalPath%
)
mkdir %LocalPath%

if not exist %RemotePath% (
echo remote path %RemotePath% doesn’t exist
goto Error
)
xcopy /c %RemotePath% %LocalPath%\.
%LocalPath%\Demo.deploy.cmd /Y

echo Demo Copied to LocalPath %LocalPath%
exit /b 0

:Error
echo Unable to Copy Demo Scripts
exit /b 1

The script is really simple, it simply compose the drop folder \\10.0.0.220\drops\demo with the single argument of the batch to find the path where the build had dropped the packages, then it creates a local directory where to copy all deploy plackage and run it.

Now you can store this script in source control, and use it with a tfs build, to deploy on a remote server, you can for example run from a command prompt:

beyondexecv2 \\10.0.0.220 -p "pa$$word” -c Deploy\DeployWeb.bat demo_20100607.3

This will copy the script on the 10.0.0.220 server, and launch the script with the argument demo_20100607.3 (the build number), here is the result.

BeyondExec V2.05 – Spawn Remote Processes on Windows NT/2000/XP WorkStations.
Copyright(C) 2002-2003 Craig.Peacock@beyondlogic.org
[10.0.0.220] Establishing Connection . . .
[10.0.0.220] BeyondExec service already installed on remote machine.
[10.0.0.220] Copying Deploy\DeployWeb.bat to \\10.0.0.220\ADMIN$\temp\DeployWeb.bat
[10.0.0.220] Command Successfully Issued to 10.0.0.220 on Pipe 1.
[win-y4onzs094up] Process started, ProcessID = 9780, ThreadID = 9788
\\10.0.0.220\drops\demo\demo_20100607.3\_PublishedWebsites\Demo_Package\Demo.deploy-readme.txt
\\10.0.0.220\drops\demo\demo_20100607.3\_PublishedWebsites\Demo_Package\Demo.deploy.cmd
\\10.0.0.220\drops\demo\demo_20100607.3\_PublishedWebsites\Demo_Package\Demo.SetParameters.xml
\\10.0.0.220\drops\demo\demo_20100607.3\_PublishedWebsites\Demo_Package\Demo.SourceManifest.xml
\\10.0.0.220\drops\demo\demo_20100607.3\_PublishedWebsites\Demo_Package\Demo.zip
5 File(s) copied
=========================================================
SetParameters from:
"c:\setup\demo\Demo.SetParameters.xml"
You can change IIS Application Name, Physical path, connectionString
or other deploy parameters in the above file.
——————————————————-
Start executing msdeploy.exe
——————————————————-
"C:\Program Files\IIS\Microsoft Web Deploy\\msdeploy.exe" -source:package=’c:\setup\demo\Demo.zip’ -dest:auto,includeAcls=’False’ -verb:syn
c -disableLink:AppPoolExtension -disableLink:ContentExtension -disableLink:CertificateExtension -setParamFile:"c:\setup\demo\Demo.SetParamet
ers.xml"
Info: Adding sitemanifest (sitemanifest).
Info: Updating createApp (Default Web Site/Demo_deploy).
Info: Adding contentPath (Default Web Site/Demo_deploy).
…
Info: Adding setAcl (Default Web Site/Demo_deploy).
Total changes: 37 (36 added, 0 deleted, 1 updated, 0 parameters changed, 737702 bytes copied)
[win-y4onzs094up] Process terminated with exit code 0 after 00:00:03.850s
[win-y4onzs094up] Removing C:\Windows\temp\DeployWeb.bat

As you can verify, the beyondexec tool was able to connect to remote machine, copied the deployweb.bat script on the remote machine and launched it with the right argument, now I can verify with IIS that the new web application was created in target machine.

Et voilà, we deployed a web application to a remote machine with a simple command. You can use this technique in a tfs build to deploy to a remote server.

Alk.

I’m currently profiling a web application, and I noticed that for some combination of input, a specific search into the database is really really slow. After verifying that the query is not responsible for this problem I fire a profiler, load the page, issue the search and then verify with ant profiler the method that need more time to be executed. The result was that the method that needs more time to be executed is one called Send Alert, that simply logs with log4net to a specific logger called Alert.

I noticed a lot of SocketException, so I verify the configuration, and find that the Alert logger has a reference to a SmtpAppender that points to a wrong smtp server. The page was slow because it is waiting to send an alert with a wrong mailserver, then it waits for timeout before proceeding on.

Ok, this is a configuration problem, but I do not want my email alert to be sent synchronously, because there is no point in slowing the application if I need to send an alert. Remember that sending an E-Mail is a slow operation even if the smtp is ok. In this situation Log4Net has a specific appender called AsyncAppender that can be used to solve this problem. The AsyncAppender is a specific appender that is used to wrap any other appender, and make the log asyncronous. The only part I need to change is to add this to configuration

   1: <appender name="AsyncSmtpAppender"

   2: type="SampleAppendersApp.Appender.AsyncAppender,SampleAppendersApp">

   3:   <appender-ref ref="SmtpAppender" />

   4: </appender>

and use the AsyncSmtpAppender in logger definition.

   1: <logger name="Alerter" additivity="false">

   2:     <level value="WARN" />

   3:     <appender-ref ref="AsyncSmtpAppender" />

   4: </logger>

Then I reload the page again, and now, even with a wrong smtp server, the page loads almost instantaneously.

Alk.

While I was upgrading a project to the latest version of nhibernate I encounter this error

filter-def for filter named UserContext was never used to filter classes nor collections

The code worked perfectly with the older version of nhibernate, but with the new version it does not work. Thanks to my friend Guardian we have found the problem. The problem is due to a filter used only into a formula, the validator of nhibernate configuration, does not find the filter used in any mapping, does not scan formula, and thinks that the filter is never used.

The solution is really simple, in the class that uses the filter, simply add a filter definition that is always verified such as.

   1: <filter name="UserContext" condition="Id > 0" />

And everything works ok.

alk.

One of the most exiting addin for VS2010 is the Visual Studio 2010 Pro Power Tools that has a great number of features, but the most interesting one is the Document well, you can read everything about it in this post.

This really boost productivity for those one having wide monitor, such as 24’’ that has a horizontal resolution of 1920 pixels, because I really loved the ability to use vertical document well, with project colored tab. I can immediately visualize the file by project with different color, and visualize a large number of opened files, instead of having them showed in the top, where very few of them are visible.

Alk.

If you have problem collecting intellitrace during a test run with MTM for an asp.net web application, and you really checked everything but cannot find any clue, check the user you are using to run the application. I have an installation where, using the default application pool will result in intellitrace being collected, while if I use a domain user to run application pool, when I try to signal a bug from MTM, no intellitrace is in the bug’s attachment.

The reason of this problem could derive from missing User Profile. Intellitrace is using User Profile to inject environment variables per owner of the application pool, and since User Profile is an OS feature, if no User Profile is loaded by OS, intellitrace could not inject variables, and data gets no collected.

The solution to this problem is to force OS to load user profile for the user before starting the test. Suppose the user that runs the application pool is named tfslab\webAppUsr, you simply need to run this command from a command prompt before you start the test

runas  /user:tfslab\webAppUsr /profile cmd.exe

This command simply opens a command prompt with the credentials of the user, thus the OS will create the User Profile. Now keep the cmd.exe windows open during the test, run the test again, and this time intellitrace data should be collected.

alk.

Sometimes there is the need to change the return value of an expectation to a Mock with a value based on parameters used in the call. Suppose you need to create a mock, and want to verify that the method DoInt() gets called with a value greater than 42 and it should return the value augmented by one, how you can setup the expectation?

The secret is in the WhenCalled method exposed by the mock, that permits you to access the full MethodInvocation object that gets generated during the real invocation. Here is the solution.

   1: public interface IDo

   2: {

   3:     Int32 DoInt(Int32 param);

   4: }

   5:  

   6: [Test]

   7: public void Name()

   8: {

   9:     IDo mock = MockRepository.GenerateStub<IDo>();

  10:     mock.Expect(m => m.DoInt(Arg<Int32>.Matches(param => param > 42)))

  11:         .WhenCalled(mi => { mi.ReturnValue = (Int32) mi.Arguments[0] + 1; })

  12:         .Return(99);

  13:     Int32 retint = mock.DoInt(432);

  14:     Assert.That(retint, Is.EqualTo(433));

  15: }

As you can see in the WhenCalled Method I can modify the ReturnValue using the value of a parameter, so if I call mock.DoInt(900) it will return 901. This technique is really powerful, because in WhenCalled you specify a delegate that gets called at each invocation, so you can write code like this.

   1: IDo mock = MockRepository.GenerateStub<IDo>();

   2: Int32 valueToIncrement = 2;

   3: mock.Expect(m => m.DoInt(Arg<Int32>.Matches(param => param > 42)))

   4:     .WhenCalled(mi => { mi.ReturnValue = (Int32)mi.Arguments[0] + valueToIncrement; })

   5:     .Repeat.Any()

   6:     .Return(99);

   7: Int32 retint = mock.DoInt(432);

   8: Assert.That(retint, Is.EqualTo(434));

   9: valueToIncrement = 100;

  10: retint = mock.DoInt(432);

  11: Assert.That(retint, Is.EqualTo(532));

I use a local variable to hold the quantity used to increment argument value, if I change the value between invocations, I can change returned value, showing that I can have full dynamic control on the value returned by an expectation on a Mock.

alk.

One of the coolest feature of Tfs2010 is Lab Management, an infrastructure tool that permits you to manage Virtual Environment to test your applications. Once you have defined some template machine in SCVMM you can import them into your Lab to be used in defining Virtual Environment.

When you imported all the templates you need from SCVMM, to create a new environment you simply need to go to Environment tab, and create new virtual environment, then you can choose VM template to compose a test environment, like in the following picture where I choose three machine, a web server, a db server and a client machine.

This is the great power of Lab Management, the ability to compose virtual machines to create a test environment that permits you to run tests in a variety of different situations. Once you have deployed an environment you can view it into Lab Management, in this screenshot the environment is starting, so Workflow capability is still not ready. All machine to be used in lab environment should in fact have the necessary agent to be controllable from the lab, you can find a prep tool at this address (http://vslabmgmt.codeplex.com/) that can dramatically cut down the time needed to prepare machines.

Once an environment is up and running, you can use it to do a lot of interesting operations, but the most interesting one is setup a Lab Management enabled Tfs Build, that has the purpose to compile the application and to deploy the latest version into the virtual environment and running automatic test, everything with a simple click. Defining a Lab Management build is quite simple, first of all I login into database server and IIS machine and prepares them to host my application, I created IIS sites, create the first skeleton of the database, create deploy scripts (they will be examined later), moved to the servers everything is needed to deploy script, and when everything is ready I did a snapshot to save everything. Then I create a standard Tfs Build with this only little difference: I want msbuild to create deploy packages for my web site, so I specify a couple of property to MsBuild.

Now I can create another build, this one with the LabDefaultTemplate.xaml, and when you configure the settings you can do very interesting stuff, in the first screenshot I can choose an environment where to run the build, and a valid snapshot to restore before the build take place

For all those people that does continues integration, you know the pain of maintaining scripts when the test environment can be messed up by dev/tester. I remember situation where the integration fails because a dev had stopped IIS Site to do some configuration then he never restart it again, sometimes they mess the application pool or the machine, etc etc. Having the environment restored to a clean snapshot is a real good thing, because we are sure that deploy scripts will run in a clean and tested scenario.

This is especially interesting for production upgrade, I can setup an environment that is the exact copy of production, then take a snapshot, and verifying that deploy script are able to upgrade production environment without messing things. With this approach, testers will run tests against a copy of production environment upgraded to latest version, and this can give you great confidence with the upgrade procedure.

Then you can choose the build to use to generate artifacts, you can choose a build definition and ask to queue another build, or use an existing one, or simply gets a build having a location.

Then it comes the most feared part, the deploy one

Apart the fact that you can take a snapshot of the environment after the deploy succeeded (useful to having a repeatable test), you need to create deploy scripts.

Scripts are used because each environment could be isolated from other ones thanks to network fencing, so the simplest stuff to install software on an environment is: copy a batch file in one of the machine, run the batch file and let him deploy the application. This part seems to be really complex, but thanks to database project, and new installer capability of VS2010 for Web application, building such a scripts is really straightforward for web application. First of all, the Virtual Machine column listed logical name of the machines in the environment, so lab management is responsible to understand the real name of the machine, then there is the script to launch, and finally in the last column, the directory in the target machine where the script should be run. Here is an example of how to specify the script

$(BuildLocation)\Scripts\DeployDb.bat "$(BuildLocation)"

Scripts are located into the web project under the scripts directory, and are part of the solution, so they gets deployed during the build, and are available to the build location. All the scripts accepts only the build location as single argument.

Essentially each script has a first part that is common to each one, it verifies that the directory passed as argument exists, then it creates a local directory where the deploy should take place, setup some variables, and then it does the deploy, for the database we need two lines.

xcopy /c %RemotePath%\IBuySpy*.* %LocalPath%\.
C:\Setup\vsdbcmd\vsdbcmd.exe /a:Deploy /ConnectionString:"xxx" /dsp:SQL /manifest:%LocalPath%\IBuySpyDatabase.deploymanifest /p:TargetDatabase=Store /dd

It essentially copy all the database project output files into a local folder, then it run the vsdbcmd.exe command to update local database. The vsdbcmd.exe command was already copied to the server in the preparation phase. The good fact is that deploy is just a matter of a couple of lines of code, for the web application the situation is quite the same.

xcopy /c %RemotePath%\_PublishedWebsites\WebApplication5_Package\*.* %LocalPath%\.
%LocalPath%\WebApplication5.deploy.cmd /Y

The first line is used to copy the deploy package, from the build location to a local path, the script knows that the build will drop the packages in a _PublishedWebSites subdirectory, and finally it can simply launch the command file to deploy the application to IIS.

As you can see, deploying a solution into a virtual environment can seem complicated as first, but is is only a matter of a couple of lines into a bat file, for standard project. Moreover, having such a script is a good things because you can use them to automatically deploy application even outside of lab management build.

Now you can choose test to run and launch the lab management build, here is a simple result

If you look at detailed build output you can find the whole output of the scripts

Thanks to lab management, you can, with a simple click, having your latest source deployed to an environment and be ready to be used from tester. If you have good servers and space on disk, you can build as many environment as you need. As an example you can deploy a environment with two IIS machine, just to test your app in a load balancing scenario.

Managing virtual environment with lab management is really funny and productive, and can cut off dramatically the time and cost needed to test your application.

alk.

I really believe that such a word (Hackability) does not exists but a tweet I saw minutes ago makes me think a little bit, the tweet was this one

I hear about Wordpress blogs getting hacked HOURLY. What is it about WP that makes it so hacker friendly?

The answer is simple IMHO, wordpress is the most used blog engine, so hackers always try to break it, because if you hack wordpress you virtually hack a large amount of blogs, while if you hack other blog platform you will hack a minor number of sites. I’m not an hacker, but I think that even if a site engine is really hard to break, if it is used by millions of people it worth trying to break it, and since no product is bugfree, surely some flaws will be found. Every program used by millions of people can be hacker friendly

Alk.

I have a simple scenario, I have an application deployed internally with click once, and some of the internal versions are made avaliable externally. The problem is that I need to change the application configuration file before deploying them to production server. To accomplish this you can simply locate the file applicationname.exe.config.deploy in the deploy directory of clickonce, but if you change it you will got an error during installation similar to this one

Application manifest has either a different computed hash than the one specified or no hash specified at all

Probably the exact error is different, but the general problem is that the manifest of your application contains hashes of all the file, and when you change a file you need to update all the mamifests. To accomplish this you need to enter to the directory with the version you want to change (Es. \Application files\applicationname_1_2_0_0) and issue from a visual studio command prompt the following command

mage –u applicationname.application

then go to the root of the deployed application and issue the command

mage -u applicationname.application -Version x.x.x.x -AppManifest "Application Files\applicationname_x_x_x_X\applicationname.exe.manifest" -Processor msil

this will recompute your hashes and now you should be able to install application again.

alk.

I have a winform application that is distributed internally through a dev server with IIS, the application is distributed in the address

http://10.8.0.5:10444/MyApplicationNameInternal/publish.htm

This application is deployed for internal use and test, and when it is stable it gets deployed to customers machine. To avoid problem I need simply to take the version deployed in our internal server and move it in production machine. To do this you can simply move all the content of the IIS folder from the dev server to production server, then use the MageUi.exe program to change the url.

Thanks to mage, I can simply use my internal test server to deploy test version, and release to outside customers only specific versions.

alk.

One of the most exiting capability of Lab Environment is the ability to

1) Record a Coded Ui Test
2) Assign it to a test
3) Run the test in an lab management virtual environment.

It is possible that running the test will return an error, and in the log you find an error like

Error adding test case [xx] to test run: There is no test with specified Id {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}.

The error is due to the fact that you are running your test against a build that does not contain the coded UI Test associated with the Test case. This is a common error if you:

1) register the coded UI Test
2) assign to a Test Case 
3) go to MTM and run the test, without changing the build.

To solve this error: queue a build, verify that the build succeeded, then change the build associated with the test plan.

Be sure that the build in use is one that contains the test associated with automation, then run the test again and everything should succeed.

Alk.

Today I configured an environment in lab management, when it finishes the deploy phase I see that the machine has testing capabilities “Error” and the details of the error is

The real error is the TF267055 

he machine is not ready to run tests because of the following error: Unable to connect to the controller on labrtmhost.tfslab.nablasoft.com:6901′. Reason: A connection attempt failed because the connected party did not properly respond after a period of time…… host has failed to respond 10.0.0.110:6901

This is the configuration of this test machine.

Physical machine has a wirless in 10.0.0.110 IP, that communicates with my office network, then it has the 10.10.1.3 ip on a Internal Virtual Network of Hyper-V where the lab manager environment is running. Since the error states that the agent is trying to contact the controller on 10.0.0.110 ip it is clear that configuration fails, because the lab machine has only the ip 10.10.1.100 and has no way to connect to the 10.0.0.x network.

If I connect to the lab Machine and did a ping labrtmhost  I got a correct answer from the ip 10.10.1.3, but the problem happened during configuration of test controller. To solve this problem first of all you need to check the Active Directory DNS, and I verified that for labrtmhost machine both ip are recorded. Since the Active Directory is active only on the 10.10.1.x subnetwork there is no need to have other ip registered, so I deleted from the dns. This is not enough, because I needed to go to labrtmhost, open the configuration of the wireless network card (the one with 10.0.0.110 ip) and prevent it to register ip into the dns.

Then I verified that from all machine in the network if I try to resolve labrtmhost with nslookup it gives me only the address 10.10.1.3. Now I reopened the “TEst Controller Configuration Tool” and configured again the test controller from the labrtmhost machine, this time it got registered in tfs with the correct Ip. Now I repair testing capabilities on the lab management deployed machine and everything is now ok.

So, wenever you got a TF267055 error, always check the dns and dns registration and verify that the test controller is registered with the correct ip.

Alk.

In last post I explain how to run code coverage during a Tfs Build and I mentioned the fact that to run code coverage you need to have Visual Studio premium or ultimate in the build machine. But what happens when you have multiple configured test agent, and only some of them have VS installed?

The solution to such a problem is using tags with the build agents. Basically a tag is a string that gets assigned to a build agent, and identify some capabilities of the Agent Itself. In our example, we can define a tag called VSUltimate that is used for each build agent that runs on a machine with Visual Studio Ultimate installed. Adding a tag is just a matter of going to the Agent Configuration

One good aspect of tagging, is that TFS remembers all inserted tags, so when it is time to configure tagging on another build agent, you got a list of all tags already used. You can verify from the above picture that this agent has the VSUltimate tag, but not the Windows7 one.

Now you can simply choose in the build definition the tag you require for the build. In our example, since our build should collect code coverage result, I want it to be executed from an agent that has Visual Studio Ultimate installed.

Thanks to the tag system you can simply specify in the build the feature you need to run the build itself.

alk.

To have Code Coverage collection for test execution during a build, you first need to create a .testsettings file in the solution with code coverage enabled. To enable code coverage simply open the testsetting file, go to “Data And Diagnostics” and check the “Code coverage” option. This is not enough, because when you check the code coverage option, the “Configure” link highlighted in the picture become enabled.

Since Code Coverage works with instrumentation, you need to configure the assemblies you want to instrument, in my examplce only the MyMath assembly

To verify that everything is ok just run the test locally and verify that code coverage data is collected. Now you can specify the testsetting file in the build configuration.

You need also to know that in order to collect code coverage settings, you need to have visual studio Premium or Visual Studio Ultimate installed in the machine with the build agent. If you got no code coverage during the build you should check the detailed log, that contains detailed reason and test run output.

If you see this message it means that tests were executed in a machine that has not visual studio ultimate, so the code coverage is disabled. If everything is ok, you should see code coverage result directly in the build output.

To look at code coverage details, you need to click on “View Test Results” and view code coverage output as if it were executed locally.

Alk.

Even if you are in workgroup environment, without a domain, you can distribute your build agent in different machines. The key to achieve this is shadow accounts. I’ve installed as an example a build controller in the tfs machine, then I created an agent, and everything runs as BuildAgent account, created in the Tfs Server and added to the “Project collection Build Service account”.

The next step is creating a user called BuildAgent with the same password of the Tfs Server in another machine, suppose a Windows 7 one. Then I log into the Windows 7 machine as Administrator, install Tfs Build and proceed to configuration. When it is time to choose the project collection it asks for credentials, and you should login as BuildAgent, choose the ProjectCollection and then proceed on.

In the next screen you are asked if you want to scale out an existing build controller adding agents to it.

When it is time to choose the user for the build service, simply specify the BuildAgent created in the first step. Since an identical user exists on the tfs machine, it is allowed to access TFS and building projects.

Finally you can verify that the agent is configured correctly.

As you can see in the machine there is an agent configured for machine win-y4onzs094UP that is the tfs basic test machine I used for demo purpose. If you manage the build controller from Visual STudio Team Explorer you can verify that now you have two build agents to use

Even without a domain tfs build environment is really flexible and scalable.

alk.

Previous Part of the series

Part 1 – The basic of interception

Some people, after looking at interceptor concept, are not fully convinced that castle can support all concepts of AOP and the first question usually is: “How can I choose witch method intercept, instead of intercepting calls to all methods, and how can I configure this with XML file or fluent configuration?”. This answer can have various solutions, but in my opinion the simplest one is doing a little manual logic on interceptor.

Since the interceptor is resolved by castle it is possible to add a list of valid regular expressions used to select methods to intercept, and simply check the method name to decide if it needs to be intercepted. This approach is the most simple one because it is based only on the basic structure of castle, and it has the advantages of change the list of methods to intercept simply changing the configuration of the interceptor. You can put this code on an interceptor or create a base interceptor class that contains the base logic.

   1: public class BetterDumpInterceptor : IInterceptor

   2: {

   3:     public List<String> RegexSelector { get; set; }

   4:  

   5:     public void Intercept(IInvocation invocation)

   6:     {

   7:         if (!CanIntercept(invocation)) {

   8:             invocation.Proceed();

   9:             return;

  10:         }

This is a simple example on how you can filter method to intercept, the CanIntercept() can be implemented in this way.

   1: private Boolean CanIntercept(IInvocation invocation)

   2: {

   3:     if (RegexSelector == null || RegexSelector.Count == 0) return true;

   4:     foreach (var regex in RegexSelector)

   5:     {

   6:         if (Regex.IsMatch(invocation.Method.Name, regex))

   7:             return true;

   8:     }

   9:     return false;

  10: }

The only modification is during registration, because now you need to specify the list of regexes to identify methods that needs to be intercepted

   1: container.Register(

   2:     Component.For<IInterceptor>()

   3:     .ImplementedBy<BetterDumpInterceptor>()

   4:     .Named("myinterceptor")

   5:     .DependsOn(Property.ForKey("RegexSelector").Eq(new List<String>() { "DoSomething" })));

This is really a simple solution, and you can verify from the output that only selected methods are intercepted.

In red I highlighted the calls to regex.Match(), and since they are a little bit expensive, to speedup execution we can add caching using a dictionary, to store result of methods already scanned, just to avoid using too much regex at each call; the basic concept is always the same:

   1: public class BetterDumpInterceptor : IInterceptor

   2: {

   3:     public List<String> RegexSelector { get; set; }

   4:  

   5:     private Dictionary<RuntimeMethodHandle, Boolean> _scanned

   6:         = new Dictionary<RuntimeMethodHandle, bool>();

I stored the result of the CanIntercept directly in a dictionary, and I use RuntimeMethodHandle just to save a little bit of memory not storing the full MethodInfo object. Then I modify the CanIntercept function in this way.

   1: private Boolean CanIntercept(IInvocation invocation)

   2: {

   3:     if (!_scanned.ContainsKey(invocation.Method.MethodHandle))

   4:     {

   5:         if (RegexSelector == null || RegexSelector.Count == 0) return true;

   6:         foreach (var regex in RegexSelector)

   7:         {

   8:             if (Regex.IsMatch(invocation.Method.Name, regex))

   9:             {

  10:                 _scanned[invocation.Method.MethodHandle] = true;

  11:                 return true;

  12:             }

  13:         }

  14:         _scanned[invocation.Method.MethodHandle] = false;

  15:     }

  16:     return _scanned[invocation.Method.MethodHandle];

  17: }

Now the same configuration produces this output.

As you can see the regex are called only for the first call of a method, each subsequent calls does not requires Regex.Match anymore.

And with this little trick I simply end with an interceptor that permits to select methods you want to intercept with configuration.

If you do not like doing this manually, Castle offers a native way to decide which method to intercept, based on the interface IInterceptorSelector, that contains a single method with this signature.

   1: public IInterceptor[] SelectInterceptors(Type type, System.Reflection.MethodInfo method, IInterceptor[] interceptors)

Basically it receives the Type and MethodInfo for the method being called, and a list of interceptors configured for that method, the purpose of the selector is to return an array containing only the interceptors that are allowed to be used on that method. A possible implementation is the following one.

   1: public Dictionary<Type, List<String>> RegexSelector { get; set; }

   2:  

   3: public InterceptorSelector(Dictionary<Type, List<string>> regexSelector)

   4: {

   5:     RegexSelector = regexSelector;

   6: }

   7:  

   8: private Boolean CanIntercept(MethodInfo methodInfo, IInterceptor interceptor)

   9: {

  10:     List<String> regexForInterceptor;

  11:     if (!RegexSelector.TryGetValue(interceptor.GetType(), out regexForInterceptor))

  12:         return false;

  13:     if (regexForInterceptor == null) return false;

  14:  

  15:     foreach (var regex in regexForInterceptor)

  16:     {

  17:         if (Regex.IsMatch(methodInfo.Name, regex))

  18:         {

  19:             return true;

  20:         }

  21:     }

  22:     return false;

  23: }

  24:  

  25: #region IInterceptorSelector Members

  26:  

  27: public IInterceptor[] SelectInterceptors(Type type, System.Reflection.MethodInfo method, IInterceptor[] interceptors)

  28: {

  29:     Utils.ConsoleWriteline(ConsoleColor.Red, "Called interceptor selector for method {0}.{1} and interceptors {2}",

  30:         type.FullName,

  31:         method.Name,

  32:         interceptors

  33:         .Select(i => i.GetType().Name)

  34:         .Aggregate((s1, s2) => s1 + " " + s2));

  35:     return interceptors.Where(i => CanIntercept(method, i)).ToArray();

  36: }

  37:  

  38: #endregion

This selector contains a dictionary of Type and List<String>, basically for each interceptor type it contains a list of regex to identify methods to be intercepted. The rest of the selector is really simple, with a little bit of LINQ we can select only the interceptors that are in the dictionary and have at least one match with the method name. You can use it in this way.

   1: Dictionary<Type, List<String>> RegexSelector = new Dictionary<Type, List<string>>();

   2: RegexSelector.Add(typeof(DumpInterceptor), new List<string>() { "DoSomething" });

   3: RegexSelector.Add(typeof(LogInterceptor), new List<string>() { "Augment" });

   4: InterceptorSelector selector = new InterceptorSelector(RegexSelector);

I created a selector that permits to select a couple of interceptors, one is the DumpInterceptor, and I want it to intercept the “DoSomething” method, while the LogInterceptor should intercept only the “Augment” method. Once the selector is configured you can simply use it in fluent configuration.

   1: container.Register(

   2:    Component.For<IInterceptor>()

   3:    .ImplementedBy<DumpInterceptor>()

   4:    .Named("DumpInterceptor"));

   5: container.Register(

   6:    Component.For<IInterceptor>()

   7:    .ImplementedBy<LogInterceptor>()

   8:    .Named("LogInterceptor"));

   9:  

  10: container.Register(

  11:     Component.For<ISomething>()

  12:     .ImplementedBy<Something>()

  13:     .Interceptors(

  14:          InterceptorReference.ForKey("DumpInterceptor"),

  15:          InterceptorReference.ForKey("LogInterceptor"))

  16:          .SelectedWith(selector).Anywhere);

Now you can run the program and look at the output.

With red color I highlight the calls to the SelectInterceptors method, and you can immediately see that Castle does caching internally and does not call the SelectInterceptors() method more than once for each method, so we does not need to cache stuff. As you can see from the output the result is the one I expect, dumpInterceptor is intercepting only the method DoSomething while the LogInterceptor intercepts only the Augment.

You can use the approach you prefer .

Alk.

In a Tfs Test machine I have I see that there are error in the System log

The application-specific permission settings do not grant Local Activation permission for the COM Server application with CLSID {<CLSID>} to the user <user> SID (<SID>). This security permission can be modified using the Component Services administrative tool.

To solve this problem simply open “Component Services” tool, expand the Computers/MyComputer/DCOMConfig, then locate the entry with the CLSID you find in the message, then right click and select property

This will open a property windows, you need to locate the Security Tab, and customize the “Launch and Activation Permissions”

From here add to the user the required security permission and the Error Log should not appears anymore.

alk.

Some minutes ago I installed Expression studio 4.0, while I’m working with a couple of solution in VS2008, when I close the solution and open another solution I see that I was not able anymore to work with test projects.

All test projects inside any solution appear as folder, and I was not able anymore to create a test project. I do not know if something get wrong during installation of Expression tools while I have a couple of VS instances opened or there was some problem on my machine that happened for any other reason , but whenever you got problem with project templates in Visual Studio, such as missing project types, you can try to run

devenv /InstallVSTemplates

that restores all templates in Visual Studio, it worked for me

alk.

Web projects in VS2010 has a great flexibility when it is time to deploy to the server, and it has a great option to generate a Deploy Package with a single click

But if you build a web project with a tfs2010 build you can verify that in the drop folder you simply have the published web site that contains only all the files, and not package to install

To generate the deploy package during a build you need to set to true a couple of msbuild properties

/p:CreatePackageOnPublish=true /p:DeployOnBuild=true

These two properties ask to MSBuild to generate the build deployment package during the build. You can put them in the MSBuild Arguments part of the build definition, it is really simple

If you run this build, you can verify from msbuild log that the package was generated.

The good part is that if you look at the drop folder you can notice that the build automatically copied the Package into the output.

This is good because you will end with an installable web site always available in the drop folder.

alk.

DateTime values are one of the most feared type of data to store in database. Suppose you have an entity with a datetime Property, and you want to do a standard report finding the count of each entity for each day in a date range, if you groupBy the DateTime property, surely you will get wrong results, because you will end with a lot of entries with count = 1, because it is really difficult that two entities will have the very same datetime value. What you want is to group by only with the date part of the datetime property.

Since NHibernate does not come with a predefined date function, you need to create a custom dialect to solve the problem, first of all I have a custom dialect for my SqlLite unit tests.

   1: public class SqlLiteDialect : NHibernate.Dialect.SQLiteDialect

   2: {

   3:     public SqlLiteDialect()

   4:     {

   5:         RegisterFunction("date", new SQLFunctionTemplate(NHibernateUtil.Date, "date(?1)"));

   6:     }

   7: }

Since SqlLite already have a date function that extract the date part of a date, I simply need to instruct NHibernate dialect that such function exists registering the function “date” with a SqlFunctionTemplate, this means that whenever the HQL parser will find a call to date() function it will substitute the date(?1) string, where ?1 will be substituted with the real parameter of the function.

In production, the code will run against a sql server 2008, and we have already defined a function called dbo.trunc that will truncate the time part of the date in our databases, so I create a similar dialect for sql server.

   1: public class MySqlDialect : NHibernate.Dialect.MsSql2008Dialect

   2: {

   3:     public MySqlDialect ()

   4:     {

   5:         RegisterFunction("date", new SQLFunctionTemplate(NHibernateUtil.Date, "dbo.trunc(?1)"));

   6:  

   7:     }

   8: }

The great advantage of the dialect approach, is that you are able to write a hql query like this:

   1: Select date(A.ActionDate), count(*) 

   2: from Action A 

   3: where A.ActionDate >= :startdate and A.ActionDate <= :enddate

   4: group by date(A.ActionDate)

Where I’m able to use date() function, but at the same time it gets translated in different way respect the dialect I use. If in the future I will need to use Oracle, I’ll simply create another dialect, without the need to modify any HQL query.

alk.