ActiveRecord

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

Configuration in Castle ActiveRecord 2

Ryan Schreiber — Mon, 25 May 2009 06:29:52 GMT

If you’ve decided to download the Castle ActiveRecord 2 Alpha version and see how it affects your existing projects, you’ll most likely get an error like this: “The ProxyFactoryFactory was not configured.Initialize 'proxyfactory.factory_class' property of the session-factory configuration section with one of the available NHibernate.ByteCode providers.”. This release of ActiveRecord makes use of NHibernate version 2.1.0.1003, which requires an additional entry in the configuration section to work correctly. The updated configuration section for your config file looks like this (line 13 in the example is what you’ll need to add):

    1   <activerecord

    2     isWeb="false"

    3     isDebug="true"

    4     threadinfotype=""

    5     sessionfactoryholdertype=""

    6     namingstrategytype="">

    7     <config>

    8       <add key="connection.provider" value="NHibernate.Connection.DriverConnectionProvider"/>

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

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

   11       <add key="connection.connection_string" value="Server=(local);initial catalog=AppTest; Integrated Security=SSPI"/>

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

   13       <add key="proxyfactory.factory_class" value="NHibernate.ByteCode.Castle.ProxyFactoryFactory, NHibernate.ByteCode.Castle" />

   14     </config>

   15   </activerecord>

Using Castle ActiveRecord and a class hierarchy

Ryan Schreiber — Wed, 11 Mar 2009 22:00:00 GMT

Very often, one of the requirements that an application I'm working on has is that it needs an audit trail. In this post I'm going to go through a technique that will build the foundation which will allow you to add record-based audit trails to your application.

We'll look at adding application user information and time stamps to the data using inheritance, as well as overriding some methods in the ActiveRecord base classes to automatically populate these values.

Download - Darkside.AuditTrail.Part1.zip

First off, let's define a mini-spec on what our "system" should do with respect to the auditing:

All records added and updated should be recorded, including who edited the record and when
Records in the database should never be deleted, only flagged for deletion

Based on the requirements above, I can immediately see that our domain classes are going to have common fields; This makes class inheritance a prime candidate for solving this problem. Our common fields are:

IsDeleted (bool) - This will be our flag for deleted records
EditedById (Guid) - A FK to our user table, indicating the person that edited this record
EditedDateTime (DateTime) - The date and time the record was last edited

Its worth noting that if your decide to do record locking in your application, you should consider adding an additional field that has the [Version] attribute to this base class as well

I've outlined the beginning of base class in the code below. Something worth pointing out is the fact that I've decided to add the property Id to the class and make it abstract; This is a personal preference only - I like to have the primary key of my objects called Id.

public abstract partial class ObjectBase<T> : ActiveRecordBase <T> where T: ObjectBase<T>

    #region Field Name Constants

    public const string IsDeletedFieldName = "IsDeleted";

    public const string EditedByIdFieldName = "EditedById";

    public const string EditedDateTimeFieldName = "EditedDateTime";

    #endregion

    public abstract Guid Id { get; set; }

    [Property(Column = EditedByIdFieldName)]

    public bool IsDeleted { get; set; }

    [Property(Column = EditedByIdFieldName)]

    public Guid EditedById { get; set; }

    [Property(Column=EditedDateTimeFieldName, ColumnType = "TimeStamp")]

    public DateTime EditedDateTime { get; set; }

Now, we can continue defining our domain objects, but inherit from our own base class.

For this sample project, I'm going to have 3 domain objects. They will be:

ApplicationUser - The user that will log on to the application and that we need to keep track of to allow the EditedId field to be updated.
Customer - A customer detail class
Address - An address class, of which will have a many-to-one relationship to Customer

Lets start with the AcitveRecord attribute on the ApplicationUser class.

[ActiveRecord(Table = "ApplicationUser", Where="IsDeleted=0")]

Notice that I've include a value for the property Where, which allows you to add a SQL condition which is applied when you fetch objects. This helps our classes conform to the "Records in the database should never be deleted..." requirement. This will ensure that records returned always have the IsDeleted property equal to 0.

In addition to the mapping in this class, I've added another file (partial class) for ApplicationUser that implements IPrincipal and IIdentity.

public partial class ApplicationUser :IPrincipal  , IIdentity

    #region IPrincipal Members

    public IIdentity Identity

        get { return (this); }

    public bool IsInRole(string role)

        return (true);

    #endregion

    #region IIdentity Members

    public string AuthenticationType

        get { return ("ApplicationAuthentication"); }

    public bool IsAuthenticated { get; set; }

    public string Name

        get { return (UserName); }

    #endregion

I prefer using a class that implements these two interfaces for logging in. I digress slightly from the point of this post, but a simple implementation of an Authenticate method could look something like this:

public static void AuthenticateUser(string userName, string password)

    var userNameCriterion = Restrictions.Eq("UserName", userName);

    var passwordCriterion = Restrictions.Eq("Password", password);

    var user = FindOne(userNameCriterion, passwordCriterion);

    if (user != null)

        user.IsAuthenticated = true;

    else

        user =new ApplicationUser();

    Thread.CurrentPrincipal = user;

This way, you have access to the currently logged in user throughout your application, and is accessible from Thread.CurrentPrincipal. And it fits in well with how I would like to automatically update certain fields in our base class :)

Now that we have that out of the way, lets revisit some additional code in the base class. The code below overrides some ActiveRecord base methods, making sure the necessary fields we require are updated, as well as making sure we don't allow for data to be deleted.

public abstract partial class ObjectBase<T>: ActiveRecordBase<T> where T : ObjectBase<T>

    //Update the EditedById to the currently logged on user, and the EditedDateTime field to DateTime.Now

    protected override bool BeforeSave(IDictionary state)

        base.BeforeSave(state);

        UpdateDetails(state);

        return (true);

    protected override bool OnFlushDirty(object id, IDictionary previousState, IDictionary currentState, NHibernate.Type.IType[] types)

        base.OnFlushDirty(id, previousState, currentState, types);

        UpdateDetails(currentState);

        return (true);

    //Update the EditedById to the currently logged on user, and the EditedDateTime field to DateTime.Now

    private static bool UpdateDetails(IDictionary state)

        state[EditedDateTimeFieldName] = DateTime.Now;

        if (Thread.CurrentPrincipal is ApplicationUser)

            state[EditedByIdFieldName] = (Thread.CurrentPrincipal as ApplicationUser).Id;

        else

            state[EditedByIdFieldName] = Guid.Empty;

        return (true);

    //Make sure that we actually do a Save()

    public override void Delete()

        IsDeleted = true;

        Save();

    //Make sure that we actually do a SaveAndFlush()

    public override void DeleteAndFlush()

        IsDeleted = true;

        SaveAndFlush();

Having a quick look at our customer class, you'll notice that you no longer inherit from ActiveRecordBase or ActiveRecordBase<T>, but our new ObjectBase<T> class. You'll also notice the [HasMany] attribute also has a Where property set. This behaves the same way as mentioned above - it adds a SQL condition when data is fetched.

[ActiveRecord(Table = "Customer", Where="IsDeleted=0")]

public partial class Customer : ObjectBase<Customer>

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

    public override Guid Id { get; set; }

    [Property(Column = "FirstName", Length = 100, NotNull = true)]

    public string FirstName { get; set; }

    [Property(Column = "LastName", Length = 100, NotNull = true)]

    public string LastName { get; set; }

    [Property(Column = "Age", NotNull = true)]

    public int Age { get; set; }

    [HasMany(MapType = typeof(Address), Where = "IsDeleted=0")]

    public IList<Address> Addresses { get; set; }

The sample project includes a console app that you can run. You'll need to modify the connection string as well as create yourself an empty database. The schema is created by the demo.

You'll notice that you can use the classes without having to manually set the EditedBy and EditedDateTime properties whenver you Save/Update/Flush.

The only code in the sample app that I think may require more explanation is the TestDelete() method.

private static void TestDelete()

    Console.WriteLine("Testing delete on a fetched object...");

    Customer customer1 = ActiveRecordBase<Customer>.FindFirst(Restrictions.Eq("FirstName", "Marge"));

    customer1.Delete();

    Customer customer2 = ActiveRecordBase<Customer>.TryFind(customer1.Id);

    if (customer2 == null)  //Successfully deleted, Find will only bring back entries where IsDeleted=0

        Console.WriteLine("Object succesfully \"deleted\".");

    else

        Console.WriteLine("Delete failed.");

You'll need to dive into the database and check the table directly to see that the IsDeleted field is set to 1 to confirm that it wasn't deleted if you're not keen on believing the test :).

In the next post, I'll demonstrate using SQL triggers to take advantage of the information we've added to the new base class, allow you to implement a really effective row-based audit trail.

GeneratorStudio and project/file layouts

Ryan Schreiber — Sun, 15 Feb 2009 17:28:42 GMT

This is just a tip for anyone using GeneratorStudio or any other code generator for their ActiveRecord classes (or any other classes, for that matter).

I generally have my templates set up to generate my files with the name "<TABLENAME>.Generated.cs" or something similar. In addition to this naming convention, I also make sure that my generated classes are marked as partial classes, and then I do all custom code, like additional "Find" methods methods, etc, in files named "<TABLENAME>.cs".

This way, when you need to regenerate anything, you can be comfortable with overwriting all the classes that are "<TABLENAME>.Generated.cs" without worrying about overwriting code that you don't want to lose.

You can go one step further and drop the generated files in their own folder - I name my "Generated", and I change the property named "Namespace Provider" on the folder to false.

Using Castle ActiveRecord and MySQL

Ryan Schreiber — Tue, 20 Jan 2009 22:00:00 GMT

I’ve started some new development on the Generator Studio tool, and one of our big features that we felt is a real necessity is the ability to point to different database engines. With that in mind, I started off trying to get Castle ActiveRecord connecting to MySQL as part of the learning curve. Here are some pointers on getting it to work smoothly.

Firstly, what' you’ll need (in addition to Castle ActiveRecord):

MySQL Connector/Net – Version 5.2 is the latest version – I’ve can confirm that it successfully connects to MySQL server 6.0 as well.

MySQL GUI tools – These are nice to have to confirm your data/table structures, especially if you’re used to using SQL Enterprise manager.

Configuring Castle ActiveRecord to use MySQL is relatively straightforward. I’ve included an example below as a quick reference.

<activerecord>

  <config>

    <add key="connection.provider" value="NHibernate.Connection.DriverConnectionProvider"/>

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

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

    <add key="connection.connection_string" value="Server=Server; Database=ActiveRecordTest; User Id=root; Password=password"/>

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

  </config>

</activerecord>

What you may get when calling any of the ActiveRecord methods is the following exception:

NHibernate.HibernateException: Could not create the driver from NHibernate.Driver.MySqlDataDriver. ---> System.Reflection.TargetInvocationException: Exception has been thrown by the target of an invocation. ---> NHibernate.HibernateException: The IDbCommand and IDbConnection implementation in the assembly MySql.Data could not be found. Ensure that the assembly MySql.Data is located in the application directory or in the Global Assembly Cache. If the assembly is in the GAC, use <qualifyAssembly/> element in the application configuration file to specify the full name of the assembly.

There are two ways of fixing this, as is implied in the exception:

Copy the file locally (to your bin folder)
Use <qualifyAssembly/> in your config file

The actual section that needs to be added to your config file looks like this:

<runtime>

  <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">

    <qualifyAssembly partialName="MySql.Data" fullName="MySql.Data, Version=5.2.5.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d"/>

  </assemblyBinding>

</runtime>

If you’re not sure of the values for Version and PublicKeyToken, you can browse to “C:\WINDOWS\assembly”, find the “MySQL.Data” entry, and it will have both the values there.

That’s it – you should be connecting to MySQL using NHibernate/ActiveRecord by now :)

Castle ActiveRecord and Linq

Ryan Schreiber — Fri, 16 Jan 2009 22:00:00 GMT

Introduction

I've been having a look at the NHibernate contributions project on SourceForge and decided to give the NHibernate.Linq project a whirl. After some initial tests, I have to say I'm very impressed. There are some limitations that are actually the result of NHibernate, not the Linq project, but nothing serious enough for me not to use it.

My next logical progression was to find out how to make use of NHiberntate.Linq in Castle ActiveRecord. Some very quick searching revealed this article from Matt (http://trycatchfail.com/blog/post/2008/08/19/Using-LINQ-with-ActiveRecord.aspx) on how to build all the relevant projects, their dependencies and finally how to use it.

I followed all the steps, which are relatively straight forward once you have castle building, and managed to get a working set of binaries to start my ActiveRecord.Linq work :) I've done the build using the following revisions/versions:

NHiberntate - 2.1.0.1001 GA
NHibernate.Linq - Rev 695 (source code)
Castle Project - Rev 5496 (source code)

Download

I've made this set of binaries available for download here for those who'd like to just get going rather.

Code

One of the additions you'll need to make to your project if you're going to use Castle ActiveRecord with NHibernate.Linq is a class that gives you access to the underlying NHIbernat.Linq context. I've modified the original example provided by Matt to better suite what I had planned for it.

/// <summary>

/// Idea originally from http://trycatchfail.com/blog/post/2008/08/19/Using-LINQ-with-ActiveRecord.aspx

/// </summary>

public sealed class ActiveRecordLinqContext : NHibernateContext

    private ActiveRecordLinqContext() : base(GetSession()){}

    ///<summary>

    ///</summary>

    ///<typeparam name="T"></typeparam>

    ///<returns></returns>

    public static INHibernateQueryable<T> Linq<T>() where T: ActiveRecordBase

        return (SingletonCreator.Instance.Session.Linq<T>());

    private static class SingletonCreator

        internal static readonly ActiveRecordLinqContext Instance = new ActiveRecordLinqContext();

    private static ISession GetSession()

        if (SessionScope.Current == null)

            throw new InvalidOperationException("No active SessionScope found.");

        return ActiveRecordMediator.GetSessionFactoryHolder().CreateSession(typeof(ActiveRecordBase));

And you can then make use of this code like this (I've included an ActiveRecord class as well):

public class TestItem: ActiveRecordBase<TestItem>

    [PrimaryKey (Generator = PrimaryKeyType.Identity)]

    public int Id { get; set; }

    [Property]

    public string ItemName { get; set; }

    [Property]

    public string ItemDescription {get; set;}

    public TestItem[] GetTestItemsNamedBob ()

        var testItems = (from ti in ActiveRecordLinqContext.Linq<TestItem>() where ti.ItemName == "Bob" select ti).ToArray();

        return (testItems);

    public string[] GetNamesOfAllTestItems()

        var testItemNames = (from ti in ActiveRecordLinqContext.Linq<TestItem>() select ti.ItemName).ToArray();

        return (testItemNames);

In the code above, I've have two calls; The first (GetTestItemsNamedBob()) returns an array of ItemTest classes. The linq query in that method is functionally quivalent to the following code:

public TestItem[] GetTestItemsNamedBob()

    var testItems = FindAll(new ICriterion[] {Restrictions.Eq("ItemName", "Bob")});

    return (testItems);

What is really cool is in the second method. If you turn on the show_sql in your ActiveRecord configuration, you'll notice that the sql that is actually sent to the server is ONLY for the field "ItemName", and that the data returned is simply a list of names and not all the data for all the fields, which is the case for normal NHibernate/ActiveRecord queries.

Thanks again to Matt (and also to Ken Egozi who started Matt off in the right direction) for the idea and instructions.

Castle ActiveRecord - Using CreateSchema()

Ryan Schreiber — Tue, 09 Dec 2008 05:32:04 GMT

When running unit tests, I often using ActiveRecordStarter.CreateSchema() in my test startups to give me a clean database to work from. Whether or not this should be done by a SQL script or a restore from a backup is for another time.

On one such occasion, I started getting a 'binary or string data would be truncated' error being thrown and on closer inspection, I noticed it was because of a certain column that was originally nvarchar (max) by design, but had been recreated by ActiveRecord as nvarchar (255).

A quick Google found many folks having this problem and the solutions varied from changing the data type to NTEXT or StringClob, to setting the length of the field to Int32.Max,however, none of them were directly solving the issue at hand.

The easiest way to remedy this is to make use of the SqlType parameter in the Property attribute of ActiveRecord when declaring your properties.

[Property("DataField", ColumnType="String", NotNull=true, SqlType = "nvarchar (max)")]

public virtual string Data { get ; set; }

Now, when you call ActiveRecord.CreateSchema(), the column will be created correctly.

Generator Studio released on CodePlex

Ryan Schreiber — Thu, 30 Oct 2008 05:47:39 GMT

Generator Studio is a code generation tool (yes, another one one, but more on that later) that allows you to set up templates using the Velocity Template Language, and then generates files based on your source database structure. It can be found here on CodePlex and the Pre-Beta 0.1 can be downloaded here

WARNING: It's very beta. Its generates well (we think), but we have a host of features/fixes that we'd like to add in the future. At present, it's being contributed to by FryHard (a.k.a. Brendan Fry) and I, and we tackle it in our spare time.Top of our list is to tidy up the UI side, and implement ALL of the sql calls using NHibernate/ActiveRecord. You may notice some inline SQL statements that, at present, I haven't managed to work around (mostly because of time constraints :)).

Why another generator application? I agree fully with the thoughts around the "Reinventing-the-wheel" anti-pattern - developing something that is already out there, but you don't like it because you didn't write it, is stoopid. BUT. I started this many years back in some-or-other form, and in recent times I've struggled to find an open-source project the generates what I want. So here it is.

Use it. Don't use it. Send us templates. Check back here/codeplex to find new templates.

UPDATE: 2008 NOV 03 4 extra templates have been added to the source - 2 for creating audit tables for your database (one style using a GUID as the PK for the audit tables, the other using an identity column) and the other two for generating the corresponding triggers to populate these tables.

Castle ActiveRecord - Using an identity/computed/default column

Ryan Schreiber — Thu, 23 Oct 2008 08:08:12 GMT

To expand on the title a bit: What if I have an identity column in a table, but it isn’t my primary key? Or what if I have a computed column or default value for a column, and need to use the value as soon as I’ve created/saved/updated?

Firstly, you need to make sure that ActiveRecord doesn’t update or insert any values for this column. In my example, I've created an Invoice class/table which has a Guid as the primary, and makes use of a column named Reference which is in fact an identity column in the database table.

[Property(Column = "Reference", Insert = false, Update = false)]

public int Reference { get; set; }

Next, you need to override the "PostFlush" method of your class, in which we check to see if the record needs to be refreshed. Here is the entire working (watered down) class:

[ActiveRecord]

public class Invoice : ActiveRecordBase<Invoice>

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

    public Guid Id { get; set; }

    [Property(Column = "Reference", Insert = false, Update = false)]

    public int Reference { get; set; }

    protected override void PostFlush()

        base.PostFlush();

        if (this.Reference == 0)

            using (new SessionScope(FlushAction.Never))

                Refresh();

You'll notice that I create a new session scope with the flushaction set to never; this is to prevent (a) the PostFlush from being fired twice on your current object and (2) stops a "System.InvalidOperationException: Collection was modified; enumeration operation may not execute" exception from being thrown if your class is in a collection of child objects belonging to another ActiveRecord class.