ActiveRecord

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.

Castle ActiveRecord - Lazy Loading and session scopes in the web

Ryan Schreiber — Thu, 09 Oct 2008 22:00:00 GMT

This is the third post I'm doing related to a Castle ActiveRecord/NHibernate/lazy loading/sessionscope error that occurs. The first two are here and here.

I received a mail the other day about an ActiveRecord/NHibernate error begin thrown in an application (web application, actually), which subsequently turned out to be another instance of the "failed to lazily initialize a collection, no session or session was closed" error. While browsing through the ActiveRecord source code when trying to solve the previous sessionscope problems I'd had, I came across an HttpModule called "SessionScopeWebModule" in the Castle.ActiveRecord.Framework namespace, and so the lightbulb switched on. I did a quick search for more info on this module at castleproject.org and found this article.

You simply add the module in as you'd do for any HttpModule, as follows:

<httpModules>

  <add name="ar.sessionscope" type="Castle.ActiveRecord.Framework.SessionScopeWebModule, Castle.ActiveRecord" />

</httpModules>

When you initialise the ActiveRecord framework, however, you still get an error related to the fact that you don't have the "isWeb" attribute set to true. That's simply remedied by modifying the configuration section for ActiveRecord as follows:

<activerecord isWeb="true">

  <config>

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

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

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

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

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

  </config>

</activerecord>

Castle ActiveRecord - more on Lazy Loading and session scopes

Darksider — Tue, 09 Sep 2008 08:11:09 GMT

This is a follow-up post on an article from a few months back located here and hopefully expands on how to overcome the error "failed to lazily initialize a collection, no session or session was closed" which I get very often in WinForms development. This error generally gets thrown when the object you are trying to lazily fetch a list for has become disconnected. The example and workaround I discussed previously was around instantiating a SessionScope object in the windows form, which stayed in scope for the duration of the form. While trying to improve on the UI design, I moved the lazy fetching, etc, to run asynchronously. All of a sudden, the lazy load errors were back and quite a stack of debugging ensued.

Initially, I borrowed a test WinForms application that loaded a master-detail set of data asynchronously from FryHard (his POC for Castle/AR/Asynchronous UI) to test my lazy loading trial-and-error solutions. I then tracked down the area of the code that I thought was the culprit (in the ActiveRecord source, file ThreadScopeInfo.cs):

[ThreadStatic] static Stack stack;

The above line was the internal stack variable that held instances of the SessionScope class and, more importantly, the [ThreadStatic] attribute indicated to me that this was on a per-thread basis, meaning that the "static-ness" of the variable was confined to the thread it was on. This was easy enough for me to change, but I certainly didn't want to have my own modified copy of ActiveRecord to maintain. Castle ActiveRecord has many places to add your own hooks into, so the search for where to implement my own ThreadScopeInfo class was pretty short. I added a handler to the "SessionFactorHolderCreated" event on the ActiveRecordStarter class and in the handler, hook up my new ThreadScopeInfo class.

private static void Main()

    ActiveRecordStarter.SessionFactoryHolderCreated += ActiveRecordStarter_SessionFactoryHolderCreated;

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

static void ActiveRecordStarter_SessionFactoryHolderCreated(Castle.ActiveRecord.Framework.ISessionFactoryHolder holder)

    holder.ThreadScopeInfo = new ThreadScopeInfo();

It's important to note that the event needs to be hooked up before initialize is called. My first-try implementation of the new ThreadScopeInfo was pretty simple: Implement the new stack, and make sure the initialisation is thread-safe.

public sealed class ThreadScopeInfo : AbstractThreadScopeInfo

    private static Stack stack;

    private static object _SyncLock = new object();

    /// <summary>

    /// Gets the current stack.

    /// </summary>

    /// <value>The current stack.</value>

    public override Stack CurrentStack

get

            if (stack == null)

                lock (_SyncLock)

                    if (stack == null)

                        stack = new Stack();

            return stack;

This solution worked well on the test project, and all the test cases I had added passed and the dreaded lazy-load error had dissapeared. However, when I moved it over into the project it was originally intended for, it was back again. For me, this meant going back to the drawing board. The reason I've posted this initial solution, albeit that it doesn't work properly in all cases, is that it is a suitable solution for light-weight WinForm applications.

Back to the problem: what was happening in the application was that many async operations were running at once (aside: Yes, my load testing in the test app was lacking. Or shocking. Or Both ;) ) Delving into the ActiveRecord code again, it was clear that the problem was happening in the AbstractThreadScopeInfo class, in the GetRegisteredScope() method. When this method is called by the mechanism doing the lazy load, it returns a null value, which in turn maps back to the "no session" part of the message.

I then decided to craft my own ThreadScopeInfo from scratch, implementing the IThreadScopeInfo interface rather than inheriting the AbstractThreadScopeInfo class as before. In actual fact, very little ended up being from scratch; I used the innards from the AbstractThreadScopeInfo, modifying the portions I deemed necessary. The resultant class looks like this:

public class ThreadScopeInfo : IThreadScopeInfo

    private readonly object _SyncLock;

    private readonly Stack _CurrentStack;

    public ThreadScopeInfo()

        _CurrentStack = new Stack();

        _SyncLock = new object();

    public Stack CurrentStack {get { return (_CurrentStack); }}

    public void RegisterScope(ISessionScope scope)

        CurrentStack.Push(scope);

    public ISessionScope GetRegisteredScope()

        if (CurrentStack.Count == 0)

            //Instead of returning a "null" stack as is in the original ActiveRecord code,

            //instantiate a new one which adds itself to the stack immediately

            lock (_SyncLock)

                if (CurrentStack.Count == 0)

                    new SessionScope();

        return CurrentStack.Peek() as ISessionScope;

    public void UnRegisterScope(ISessionScope scope)

        if (GetRegisteredScope() != scope)

            throw new ScopeMachineryException("Tried to unregister a scope that is not the active one");

        CurrentStack.Pop();

    public bool HasInitializedScope

        get { return GetRegisteredScope() != null; }

The crux of the change is the modification to the GetRegisteredScope() method, which, if in the event of the stack being empty, instantiates a new SessionScope object; This object automatically registers itself, which in turn causes it to be pushed onto the stack.

This is a hack, and I have no doubt about it. It does, however, cause all issues surrounding lazy loading to dissapear, with no side-efects that I've noticed at all.