Development

A relook at my Windows service template project

Ryan Schreiber — Tue, 07 Jun 2011 09:00:15 GMT

A while ago I blogged about a template project that I often use as my starting point for Windows services. I’ve recently been introduced to a component called TopShelf that makes writing a service even simpler as well as taking just about all the plumbing code needed for installing/uninstalling and running in debug mode.

Here’s an example of the code that goes into the Main method. It sets up the service, name, description, and you tell it what to call on the Start and Stop service control events.

        static void Main(string[] args)

            const string name = "My Service Host";

            const string description = "My Service Host Description";

            var host = HostFactory.New(configuration =>

                configuration.Service<ServiceHostControl>(

                    callback =>

                        callback.SetServiceName(name);

                        callback.ConstructUsing(s => new ServiceHostControl());

                        callback.WhenStarted(service => service.Start());

                        callback.WhenStopped(service => service.Stop());

});

                configuration.SetDisplayName(name);

                configuration.SetServiceName(name);

                configuration.SetDescription(description);

                configuration.DependsOnMsSql(); //Just here as an example of some of the features

                configuration.RunAsLocalService();

});

            host.Run();

I make reference in the code above to a class called ServiceHostControl. This class is the only other code I have in my template project as of now – it provides the stub methods for starting and stopping the service.

    internal class ServiceHostControl

        public void Start()

            Console.WriteLine("starting...");

            //Do everything here to start up the service...

            Console.WriteLine("started.");

        public void Stop()

            Console.WriteLine("stopping...");

            //Do everything here to shut the service down...

            Console.WriteLine("stopped.");

There is no longer a need to have a service installer class anymore either in the project – all this functionality is brought to the party by the Topshelf component. To install your service, you simply drop to a command prompt and type in:

{serviceassembly.exe} install

and (as you can most likely guess) to uninstall, you type in:

{serviceassembly.exe} uninstall

It’s as simple as that.

What’s new in Castle ActiveRecord 3 RC?

Ryan Schreiber — Wed, 30 Mar 2011 10:37:46 GMT

Configuration

Version 3 now supports the short-hand configuration options supplied by NHibernate. You choose the DB type, supply a connection string name, and the rest of the defaults are chosen for you.

</configSections>

</connectionStrings>

</activerecord>

SessionScope-less Lazy Loading

This is a great change that’s been implemented. The code example below (very contrived, I know, but demonstrates the point) used to throw an exception, but doesn’t anymore.

[ActiveRecord("Person", Lazy = true)]

public partial class Person : ActiveRecordBase<Person>

{

[PrimaryKey(Generator = PrimaryKeyType.GuidComb, Column = "PersonId")]

public virtual Guid Id { get; set; }

[HasMany(typeof(ContactNumber), Table = "ContactNumbers", ColumnKey = "PersonId", Lazy = true)]

public virtual IList<ContactNumber> PersonIdContactNumbersList { get; set; }

}

[ActiveRecord("ContactNumber")]

public partial class ContactNumber : ActiveRecordBase<ContactNumber>

{

[PrimaryKey(Generator = PrimaryKeyType.GuidComb, Column = "ContactNumberId")]

public virtual Guid Id { get; set; }

[BelongsTo(Type = typeof(Person), Column = "PersonId")]

public virtual Person Person { get; set; }

}

public class Program

{

static void Main(string[] args)

{

ActiveRecordStarter.Initialize(Assembly.GetExecutingAssembly(), ActiveRecordSectionHandler.Instance);

ContactNumber contactNumber;

using (new SessionScope())

{

contactNumber = ContactNumber.FindFirst(Order.Asc("Id"));

}

Debug.WriteLine(contactNumber.Person.Id); //Used to throw an exception

}

Make sure that in your configuration, (if you’re still specifying the entire config) you’re using the Castle.ActiveRecord.ByteCode.ProxyFactoryFactory proxy factory.

Lazy Loading of Blob Properties

You can now use the “Lazy” keyword on blob properties which tells NHibernate not to include this column in the select statement, but only call it when it’s explicitly used. Some notes on this, though:

If you have more than one column marked as lazy, they are ALL fetched when you access the first one.
The property should be an auto-prop
This results in and extra select being fired off when you used this column – it may end up being a problem in large sets of data.

The syntax is straight forward:

[Property (Column ="Data", ColumnType = "BinaryBlob" , Lazy = true)]

public virtual byte[] Data { get; set; }

LINQ

LINQ support is now rolled into the Castle ActiveRecord assembly, and doesn’t require a reference to another file.

SessionScopeWebModule (Breaking Change)

This has been removed from the main Castle ActiveRecord assembly and is now in the assembly Castle.ActiveRecord.Web.dll. You’ll need to update your configuration for the HttpModule as follows:

</httpModules>

SqlDependency Helper Class

Ryan Schreiber — Fri, 11 Feb 2011 09:52:45 GMT

It’s been a while since I used the SqlDependency class and the features it provides, and was then quite disappointed that I hadn’t a copy of the plumbing code anywhere on my web clipboard (a.k.a darkside.co.za). I’ve put together a static helper class that you can attach an event to, and then call the Start(…) method.

Here is the code for the class (UPDATE: or you can download it here):

    1 using System.Data;

    2 using System.Data.SqlClient;

    4 namespace Darkside

5 {

    6     public class SqlNotificationHelper

    7     {

    8         private static SqlConnection m_SqlConnection;

    9         private static SqlCommand m_SqlCommand;

   10         private static DataSet m_DataSet;

   11         private static string m_ConnectionString;

   13         public delegate void DataChanged(DataSet dataSet);

   14         public static event DataChanged DataChangedEvent;

   16         public static void Start(string connectionString, string sql, CommandType commandType)

   17         {

   18             m_ConnectionString = connectionString;

   19             SqlDependency.Stop(m_ConnectionString);

   20             SqlDependency.Start(m_ConnectionString);

   21             if (m_SqlConnection == null)

   22                 m_SqlConnection = new SqlConnection(m_ConnectionString);

   23             if (m_SqlCommand == null)

   24                 m_SqlCommand = new SqlCommand(sql, m_SqlConnection) { CommandType = commandType };

   25             if (m_DataSet == null)

   26                 m_DataSet = new DataSet();

   28             SetupNotification();

   29         }

   31         public static void Stop()

   32         {

   33             SqlDependency.Stop(m_ConnectionString);

   34             if (m_SqlConnection != null)

   35                 m_SqlConnection.Close();

   36         }

   38         private static void SqlDependencyOnChange(object sender, SqlNotificationEventArgs e)

   39         {

   40             var sqlDependency = sender as SqlDependency;

   41             if (sqlDependency != null)

   42                 sqlDependency.OnChange -= SqlDependencyOnChange;

   43             SetupNotification();

   44             if (DataChangedEvent != null)

   45                 DataChangedEvent(m_DataSet);

   46         }

   48         private static void SetupNotification()

   49         {

   50             m_DataSet.Clear();

   52             m_SqlCommand.Notification = null;

   53             var sqlDependency = new SqlDependency(m_SqlCommand);

   54             sqlDependency.OnChange += SqlDependencyOnChange;

   55             using (var adapter = new SqlDataAdapter(m_SqlCommand))

   56             {

   57                 adapter.Fill(m_DataSet, "DataSet");

   58             }

   59         }

   60     }

   61 }

And you can use it as follows:

protected static void Main()

    SqlNotificationHelper.DataChangedEvent += new SqlNotificationHelper.DataChanged(SqlNotificationHelper_DataChangedEvent);

    SqlNotificationHelper.Start("Server=(local); Database=Test; Integrated Security=SSPI", "SELECT Id, FirstName, Surname FROM dbo.People", CommandType.Text);

    Console.ReadLine();

private static void SqlNotificationHelper_DataChangedEvent(System.Data.DataSet dataSet)

    Console.WriteLine("Event – Data Updated." + dataSet.Tables[0].Rows.Count);

I should point out that you need to be quite specific in the type of query that you use. The list contained here on MSDN is quite comprehensive. The most common pitfalls I can imagine will befall people is using a * in the SELECT statement, and not specifying the table name in two-part format. The change event still fires even if the query isn’t correct, however, it fires repeatedly and can be quite a pain to debug.

A C# Regular Expression for a GUID

Ryan Schreiber — Fri, 03 Sep 2010 09:53:17 GMT

I’ve been searching for a good regular expression to validate a string representation of a GUID, and even though there are 17 results on RegExLib.com and 73000+ on Google, I’ve not found one that matches the start and end braces correctly. Every single one I’ve found (without exaggerating, I read over 60 posts while looking)either matches a GUID without the braces, or those that match on a string including the braces allow for either only the first or last to be present.

^(?<-BRACE>\{)?[a-fA-F\d]{8}-(?:[a-fA-F\d]{4}-){3}[a-fA-F\d]{12}(?<-BRACE>\})?(?(BRACE)^.)$

On a side note: The project I’m doing maintenance on is VS2008/.Net 3.5. If you’re using .Net Framework 4, you can use the Guid.Parse and Guid.TryParse methods to validate a Guid.

UPDATE: I’ve submitted it to RegExLib.com.

T4 Text Template for Castle ActiveRecord

Ryan Schreiber — Wed, 18 Aug 2010 09:32:35 GMT

I was busy with a(nother) comparison of Castle ActiveRecord and the Microsoft offerings that have shipped with VS2010 just to make sure that I wasn’t missing out on anything. I ended up fiddling with EDMX files, and then custom generation, which then led me to downloading the ADO.Net POCO T4 generation templates and checking out what was in the files.

I have to admit: when I saw what was in it, I got quite giddy with excitement, followed shortly by feeling like a tool. I can’t believe I’ve missed out on this excellent piece of functionality that has been around for ages.

I decided to tackle making a template that generated output that matched what is generated by Generator Studio, which is an open source project I started with FryHard a few years back, primarily to generate my ActiveRecord classes from my database model. I based my template on the ADO.Net POCO template from Microsoft and used it as my guideline.

Explaining the code in the TT file is a little out of the scope of this article, but it is available here for download

You can paste the zip file in

%userprofile%\Documents\Visual Studio 2010\Templates\ItemTemplates\Visual C#\

and then open the Visual Studio Command Prompt (as Administrator) and run:

devenv /installvstemplates

The command above installs the new templates for Visual Studio.

The quickest way to use it in much the same way as a generator is as follows:

Create a new class library or windows app project.
Add a reference to Castle.ActiveRecord.
Add an ADO.NET Entity Data Model to your project.
Choose the “Generate from Database” option in the wizard
Run through the rest of the wizard adding the tables you’d like to generate ActiveRecord classes from.
Open the entity model in the IDE, and change the “Code Generation Strategy” property in the properties tab to “None”. This remove all code from the designer class attached to the EDMX file.
Add a new “Castle ActiveRecord Basic Template” item to your project. This is the template contained in the download above.
Once the template has been added, you can look at the files generated by it, and there should be 1 each for each table in your database, as well as an additional file that has the same name as the template (except with a .CS extension), that has no functionality in it. This is created by the template (as it was in the original from MS), and I’ve left it there because I’ll most likely use for custom features/base classes as I build on the template.

You should now be able to use the ActiveRecord classes generated as you normally would.

If you make changes to your model in the EDMX designer, you can simply right-click on the template file in the solution and select the “Run Custom Tool” to regenerate your classes.

Initialising Castle ActiveRecord in a WAS-hosted WCF service

Ryan Schreiber — Fri, 16 Jul 2010 09:25:53 GMT

I stumbled upon an interesting problem this morning where Castle ActiveRecord was being initialised correctly in the development environment, but as soon as everything was rolled out to the lab environment, the application would throw errors about AR not being initialised. The error message was along the lines of:

An ActiveRecord class (Darkside.Domain.Person) was used but the framework seems not properly initialized. Did you forget about ActiveRecordStarter.Initialize() ?

A bit of background info: As is custom in our web projects, we use an HttpModule to do the AR initialisation. In this case, the web project is actually a WAS host for our WCF services. After doing a bit of research, I found out that HttpModules are not executed when running WCF services. The reason we had the illusion it was working in dev is because of a default page that was started when the project was run. This caused the HttpModule to run, which in turn initialised AR for that session.

Our solution to this problem was to make use of a custom service host factory. I’ve touched on the custom service host factory subject here before, and this solution is just another use of it.

public class CustomServiceHostFactory : ServiceHostFactory

    private static readonly object m_InitActiveRecordLock = new object();

    public override System.ServiceModel.ServiceHostBase CreateServiceHost(string constructorString, Uri[] baseAddresses)

        //Initialise ActiveRecord...

        if (!ActiveRecordStarter.IsInitialized)

            lock (m_InitActiveRecordLock)

                if (!ActiveRecordStarter.IsInitialized)

                    ActiveRecordStarter.Initialize(Assembly.Load("Darkside.Domain"), ActiveRecordSectionHandler.Instance);

        //Hand off the real host creation to the base class..

        return (base.CreateServiceHost(constructorString, baseAddresses));

You then need to add the Factory attribute into your .SVC file

<%@ ServiceHost Language="C#" Debug="false" Service="Darkside.Services.CRUDService, Darkside.Services" Factory="Darkside.WAS.CustomServiceHostFactory" %>

Now, if a new service host is created in your app, AR will be initialised first, if needed.

Configuring and using the SQLite database in Castle ActiveRecord

Ryan Schreiber — Wed, 07 Jul 2010 17:36:16 GMT

There are a few solutions out on the web for this – here’s my implementation for you to use (and for me to safe-keep). I use this primarily for testing my ActiveRecord objects, as I haven’t really found any use for this mechanism in any production environment

Firstly, the configuration. Notice that I specify my own connection provider (make sure you correctly swap out the relevant portions with your own namespaces). Also, there’s a slight twist in the connection string that you may want to take note of. The rest is straight forward.

  <activerecord isDebug="true" isWeb="false">

    <config>

      <add key="connection.provider"

           value="Darkside.ARLibrary.SqLiteConnectionProvider, Darkside.ARLibrary"/>

      <add key="dialect" value="NHibernate.Dialect.SQLiteDialect"/>

      <add key="connection.driver_class" value="NHibernate.Driver.SQLite20Driver"/>

      <add key="connection.connection_string" value="Data Source=:memory:;Version=3;New=True;"/>

      <add key="proxyfactory.factory_class"

           value="NHibernate.ByteCode.Castle.ProxyFactoryFactory, NHibernate.ByteCode.Castle" />

      <add key="show_sql" value="true"/>

    </config>

  </activerecord>

Next, you’ll need to implement your own connection provider. The reason this needs to be done is because when you close a connection on a SQLite database which you’ve configured to be in-memory, the entire contents (tables and data) is lost.

You simply inherit from NHibernate.Connection.DriverConnectionProvider and override the GetConnection() and CloseConnection() methods. In your implementation of GetConnection(), you cache an instance of the connection and always return the same one. In CloseConnection(), you do nothing – you don’t need or want to close the connection.

    public class SqLiteConnectionProvider : NHibernate.Connection.DriverConnectionProvider

        private static System.Data.IDbConnection m_Connection;

        public override System.Data.IDbConnection GetConnection()

            if (m_Connection == null)

                m_Connection = base.GetConnection();

            return m_Connection;

        public override void CloseConnection(System.Data.IDbConnection conn)

            //Do nothing

Compress and decompress a byte array

Ryan Schreiber — Tue, 11 May 2010 18:23:43 GMT

A colleague asked me this morning if I already had a code snippet that compressed and decompressed byte arrays that he could make use of. He needed it to compress a variable before passing it as an argument to a WCF call, and decompress in the service itself. I’ve never made use of the System.IO.Compression namespace (I’d always used SharpZipLib), so I thought this would be a quick and useful experiment.

After referencing the local MSDN and then the customary 30 second google, I decided I’d make my own, better, wheel :) I’m still convinced it’s less verbose than the first ten results I looked at, by the way.

The compress part was easy enough (and follows the same logic as just about every example I found). What I couldn’t understand was why everyone implemented long-winded decompress routines. The answer to that question (found in MSDN) is that the Length property of the DeflateStream is not implemented and always throws an exception, meaning that you can’t determine the length of the byte array you’ll need.

Here’s my quick-and-easy solution to the problem:

    public static class CompressionUtils

        const int BUFFERSIZE = 1024;

        public static byte[] Compress(byte[] data)

            var memoryStream = new MemoryStream();

            var deflateStream = new DeflateStream(memoryStream, CompressionMode.Compress);

            deflateStream.Write(data, 0, data.Length);

            deflateStream.Flush();

            deflateStream.Close();

            return memoryStream.ToArray();

        public static byte[] Decompress(byte[] data)

            var buffer = new byte[BUFFERSIZE];

            var returnVal = new List<byte>();

            var deflateStream = new DeflateStream(new MemoryStream(data), CompressionMode.Decompress);

            int count;

            while ((count = deflateStream.Read(buffer, 0, BUFFERSIZE)) > 0)

                if (count != BUFFERSIZE)

                    var tmpBuffer = new byte[count];

                    Array.Copy(buffer, tmpBuffer, count);

                    returnVal.AddRange(tmpBuffer);

                else

                    returnVal.AddRange(buffer);

            return returnVal.ToArray();

An example of speculative execution

Ryan Schreiber — Thu, 19 Nov 2009 17:53:39 GMT

Speculative execution is a term applied to the execution of code that you may not need the results of. With the abundance of spare processing power on servers these days (and workstations for that matter), you can easily make an application be far more responsive to the user or make processing tasks on a server application quicker.

A contrived example that I've come up: Consider a process that runs periodically on a server that:

Finds a list of all your customers from the SQL Server-based accounting system that have purchased an item from your online store in the past 24 hours (quick DB call) (1 sec in total)
For each customer, sum up the values of all their transactions for the past 6 months - it's a longer process because you have to fetch the data from data warehouse tables on a different SQL Server (2 sec per call)
For customers who have purchased more than ZAR100*, check if they have received a cheesy gift from the online loyalty app that you outsource to. (2 sec per call).
If they haven't received the gift yet, make another call to the online loyalty app to request that a gift be delivered (2 sec)

Most likely you have these running sequentially; looking at the tasks that need to be performed, they all seem to be dependant on the previous step. A quick tally based on a made of set of results returned in each step:

5 customers are returned. Total running time elapsed: 1 sec
Sum up the values of each customer @ 2 seconds/call. Total running time elapsed: 11 sec
Let's say only 2 make it to this step that need to be checked. Total running time elapsed: 15 sec
One has already received a gift, so it's only 1 call left. Total running time elapsed: 16 sec

Here's an example of what the code may look like:

IList<Customer> customers = GetListOfCustomers();

foreach (var customer in customers)

    if (GetPurchaseTotalForSixMonths(customer) > 100)

        if (!HasCustomerReceivedGift(customer))

            RequestGiftForCustomer(customer);

Considering that in every step from the process your server application is waiting for a response from another server, it's most likely idling away. So let's run some of the tasks in parallel. We can run each call made in (2) at the same time as the call that may or may not have been made initially in (3). We can make the call to the online loyalty app, and if the result from the call in two requires the data from the call in (3), you use it. If not, too bad - you just discard the results. Your code may look something like this:

        private static void Speculative()

            IList<Customer> customers = GetListOfCustomers();

            foreach (var customer in customers)

                var c = customer;   //**

                bool meetsPurchaseLimit=false;

                bool hasReceivedGift=false;

                Fork.Begin()

                    .Call(() => meetsPurchaseLimit = (GetPurchaseTotalForSixMonths(c) > 100))

                    .Call(() => hasReceivedGift = HasCustomerReceivedGift(c))

                    .End();

                if (meetsPurchaseLimit && !hasReceivedGift)

                    RequestGiftForCustomer(customer);

The Fork code that you see here is the same as what I've described in the article "An easy to use asynchronous fork".

Re-doing the calculation on the elapsed time, but now using speculative execution on the call made in (3), we get:

5 customers are returned. Total running time elapsed: 1 sec
Sum up the values of each customer @ 2 seconds/call, but at the same time check if the customer received a gift. Total running time elapsed: 11 sec
Marrying up the results from the parallel calls, make the single call for the gift. Total running time elapsed: 12 sec

Back to the example: As you can see, you have a 25% saving in time. Yes, this is a contrived example with naive timing, but the general idea is what matters most. Don't feel bad about using your CPU's idle time to get work done, even if you're going to throw it away later.

* ZAR100 is equivalent to about USD500 or GBP300. Ok, it isn't so. Check here if you really want to.

** You may or may not be wondering why I have the line:

                var c = customer;

It's to remove the warning I get from ReSharper - it complains about a possible "access to a modified closure". Have a look at this article from Eric Lippert explaining it.

C++ Compile Error - C2664

Ryan Schreiber — Mon, 16 Nov 2009 12:19:13 GMT

If you find you’re getting compile errors something along the lines of

error C2664: 'CreateFileW' : cannot convert parameter 1 from 'char [261]' to 'LPCWSTR'

error C2664: 'CreateProcessW' : cannot convert parameter 2 from 'char *' to 'LPWSTR'

I got plenty of these when compiling code which I C&P’d, which was working perfectly in one project, to a new project I had just created; All the errors were related to converting char/char arrays to LPWSTR. There are plenty of programmatic ways of converting this data, and keep in mind you may still want to check these out, rather than my “simple” fix, which is change the “Character Set” property in the project configuration settings to “Multi-Byte”