Mike Nichols - Son Of Nun Technology : NHibernate

NHibernate CurrentSessionContext tip

Michael Nichols — Sun, 25 Oct 2009 04:32:16 GMT

I recently implemented a reporting model in my app (a windows service) and so now have two session factories to manage within a unit of work. Originally, I was using this setting:

<property name="current_session_context_class">thread_static</property>

This was causing the wrong session to get injected into my entities since only one session factory is supported with this setting. So I changed it to this:

<property name="current_session_context_class">call</property>

Now things work as expected. You don’t want to use this on ASP.NET.

Resources

NH docs on Contextual sessions

Using Interceptors To Enforce Aggregate Boundaries

Michael Nichols — Thu, 07 Feb 2008 07:16:05 GMT

An AGGREGATE is a cluster of associated objects that we treat as a unit for the purpose of data changes. Each AGGREGATE has a root and a boundary. The boundary defines what is inside the AGGREGATE. Domain-Driven Design, Eric Evans

This pattern is at the root of decision making while breathing life into the abstraction of business concerns, yet how to apply these principles in the corners of an application can throw me into a quandary.

Aggregates referencing other aggregates is one such quandary, especially when it comes time to employ the repository(s) associated with each aggregate root.

Using NHibernate can seduce you away from abiding by the aggregate rule with its cascading benefits. I am okay with that, perhaps requiring lazy-loading across aggregate boundaries, since the benefits are great and I am not sure it muddies the aggregate water too much.

But I have a situation where I have the following AGGREGATES:

public class MaterialsTest

    public Sample Sample {get;set;}

public class Sample

    public string SampleNumber{get;set;}

Note that MaterialsTest references Sample. It turns out that MaterialsTest will have several implementations, creating an n...1 relationship to Sample.

As I mentioned, both are aggregates with their respective repositories and NHibernate could let me just cascade my persistence to Sample via mapping. However, there is another rule that popped up that requires the 'SampleNumber' to be set/updated for EACH sample that is saved. That is a Sample specification, though, not a MaterialsTest specification so I want to be sure to keep it in the right camp without munging up my MaterialsTestRepository with references to SampleRepository...I agree it could be argued that the reference is okay but I wanted to keep the rule separate from the repository concerns.

Currently, I am only doing In Memory representations of my persistence, so while I could leap in to NHibernate and employ an IInterceptor.OnFlushDirty call to sniff changes on the properties that determine the value for 'SampleNumber', I thought I'd see if Castle Project's IInterceptor could hep' a brutha out and it turns out I have a cleaner division between my aggregate roots by using interceptors on my repositories.

First my test...I had to learn how to test interceptors along the way. Note that 'SandCone' and 'NuclearDensity' is my MaterialsTest implementations here:

[TestFixture]

[TestsOn(typeof (SampleRepositoryInterceptor))]

public class SampleRepositoryInterceptorTest

    private IFieldDensityRepository mockRepos;

    private MockRepository mocks;

    private ProxyGenerator proxyGenerator;

    private ISampleRepository sampleRepository;

    private SampleRepositoryInterceptor sut;

    private IFieldDensityRepository target;

    [SetUp]

    public void BeforeTest()

        mocks = new MockRepository();

        proxyGenerator = new ProxyGenerator();

        sampleRepository = mocks.CreateMock<ISampleRepository>();

        mockRepos = mocks.DynamicMock<IFieldDensityRepository>();

        sut = CreateSUT();

        target =

            proxyGenerator.CreateInterfaceProxyWithTarget<IFieldDensityRepository>(mockRepos, sut);

    [TearDown]

    public void AfterTest()

        mocks.ReplayAll();

        mocks.VerifyAll();

    public SampleRepositoryInterceptor CreateSUT()

        return new SampleRepositoryInterceptor(sampleRepository);

    [Test]

    public void INterceptSaveMethod_ShouldSaveEnumerableSamples()

        SandCone sc1 = new SandConeTestDataBuilder().AsNew().Build();

        SandCone sc2 = new SandConeTestDataBuilder().AsNew().Build();

        Sample[] samplesToSave = new Sample[] {sc1.Sample, sc2.Sample};

        using (mocks.Record())

            Expect.Call(sampleRepository.Save(samplesToSave)).Return(samplesToSave);

        mocks.ReplayAll();

        target.Save(new FieldDensity.FieldDensity[] {sc1, sc2});

    [Test]

    public void INterceptSaveMethod_ShouldSaveSingleSample()

        SandCone sc1 = new SandConeTestDataBuilder().AsNew().Build();

        using (mocks.Record())

            Expect.Call(sampleRepository.Save(sc1.Sample)).Return(sc1.Sample);

        mocks.ReplayAll();

        target.Save(sc1);

Now the code that makes it pass:

public class SampleRepositoryInterceptor : IInterceptor

    private readonly ISampleRepository sampleRepository;

    public bool Intercepted;

    public SampleRepositoryInterceptor(ISampleRepository sampleRepository)

        this.sampleRepository = sampleRepository;

    #region IInterceptor Members

    public void Intercept(IInvocation invocation)

        if (Equals(invocation.Method.Name, "Save"))

            if (invocation.Arguments[0] is IEnumerable)

                List<Sample> samples = new List<Sample>();

                IEnumerator enumerator = ((IEnumerable) invocation.Arguments[0]).GetEnumerator();

                while (enumerator.MoveNext())

                    if(enumerator.Current is IReferenceSample)

                    samples.Add(((IReferenceSample) enumerator.Current).Sample);

                sampleRepository.Save(samples.ToArray());

            else

                if(invocation.Arguments[0] is IReferenceSample)

                    sampleRepository.Save(((IReferenceSample)invocation.Arguments[0]).Sample);

        invocation.Proceed();

    #endregion

Finally, I can decorate my InMemoryFieldDensityRepository with [Interceptor(typeof(SampleRepositoryInterceptor))] and register the interceptor in my container (using Binsor)

Component("sample_repository_interceptor",SampleRepositoryInterceptor,SampleRepositoryInterceptor,LifestyleType.Transient)

Now my client code can just call the repository method for the MaterialsTestRepository implementation (InMemoryFieldDensityRepository above) and my interceptor will enforce my aggregate boundary rule.

fieldDensityRepository.Save(myMaterialsTest);

This gives me freedom to slip in the appropriate SampleNumber rule I mentioned above just before items are delivered to my SampleRepository.

So I learned how to test interceptors, implement them to help me enforce DDD constraints, and simplify my management in the meantime...not bad!

When I implement my NHibernate repositories, I'll be getting even more granular in generating this SampleNumber using NHibernate's built in interception to avoid unnecessary Updates on Samples. Here is another benefit of this interception technique...I get to avoid changing client code to deal with an implementation change.

NHibernate MSBuild Hbm2Ddl Task

Michael Nichols — Thu, 25 Oct 2007 23:15:00 GMT

I revisited porting the builtin Hbm2Ddl task from Nant to MSBuild. It's passing tests on my end and I'll take on a test drive tonight. Nothing real interesting. It is forced to copy the target assemblies into the runtime bin and then cleanup on Dispose(). NHibernate couldn't find the assemblies otherwise. Nant didn't require this but not sure what the difference is.

Here it is:

using System;using System.Collections;using System.Collections.Generic;using System.IO;using System.Reflection;using System.Text;using Microsoft.Build.Framework;using Microsoft.Build.Utilities;using NHibernate.Cfg;using NHibernate.Tool.hbm2ddl; namespace MSBuild.Community.Tasks.NHibernate{    public class Hbm2Ddl : Task, IDisposable    {        private string _connectionProvider = "NHibernate.Connection.DriverConnectionProvider";        private string _dialect ="NHibernate.Dialect.MsSql2005Dialect";        private string _connectionDriverClass = "NHibernate.Driver.SqlClientDriver";        private string _connectionString;        private string _delimiter = " GO ";        private bool _outputToConsole;        private bool _exportOnly;        private bool _dropOnly;        private bool _formatNice;        private ITaskItem[] _assemblies;        private ITaskItem _outputFilename = new TaskItem("schema.sql");        private IList<string> _assembliesToDelete = new List<string>();        ///<summary>        ///When overridden in a derived class, executes the task.        ///</summary>        ///        ///<returns>        ///true if the task successfully executed; otherwise, false.        ///</returns>        ///        public override bool Execute()        {            Configuration config = new Configuration();            IDictionary properties = new Hashtable();                         properties["connection.provider"] = ConnectionProvider;            properties["dialect"] = Dialect;            properties["connection.driver_class"] = ConnectionDriverClass;            properties["connection.connection_string"] = ConnectionString;             config.AddProperties(properties);             foreach (ITaskItem item in Assemblies)            {                string filePath = item.ItemSpec;                Log.LogMessageFromText(string.Format("Adding assembly file {0}", filePath), MessageImportance.Normal);                try                {                    string fileName = Path.GetFileName(filePath);                    string target = Path.Combine(AssemblyDirectory, fileName);                    Log.LogMessageFromText(string.Format("Copying {0} to {1}", filePath, target),MessageImportance.High);                    File.Copy(filePath, target, true);                    AssemblyName an = AssemblyName.GetAssemblyName(target);                    Assembly asm = Assembly.Load(an);                    config.AddAssembly(asm);                    _assembliesToDelete.Add(target);                                    }                catch (Exception e)                {                    Log.LogMessageFromText(string.Format("Error loading assembly {0}. Be sure the target assembly is in the \bin with NHibernate (if the copy failed).", filePath),                        MessageImportance.High);                                        return false;                }            }            string outputFilename = OutputFilename.ItemSpec;            SchemaExport se = new SchemaExport(config);            if (!IsStringNullOrEmpty(outputFilename))            {                se.SetOutputFile(outputFilename);            }            se.SetDelimiter(Delimiter);            Log.LogMessageFromText( "Exporting ddl schema.", MessageImportance.Normal);             se.Execute(OutputToConsole, ExportOnly, DropOnly, FormatNice);             if (!IsStringNullOrEmpty(outputFilename))            {                Log.LogMessageFromText(string.Format("Successful DDL schema output: {0}", OutputFilename), MessageImportance.High);            }            return true;        }        private void CleanUp()        {                        foreach (string asmToDelete in _assembliesToDelete)            {                Log.LogMessageFromText(string.Format("Deleting {0}", asmToDelete), MessageImportance.High);                File.Delete(asmToDelete);            }        }        private static bool IsStringNullOrEmpty(string input)        {            return (input == null || input.Length == 0);        }        /// <summary>        /// Gets or sets the connection provider.  NHibernate.Connection.DriverConnectionProvider is the default        /// </summary>        /// <value>The connection provider.</value>        public string ConnectionProvider        {            get { return this._connectionProvider; }            set { this._connectionProvider = value; }        }        public string AssemblyCodeBase        {            get { return Assembly.GetExecutingAssembly().CodeBase; }        }         public string AssemblyDirectory        {            get { return new Uri(Path.GetDirectoryName(AssemblyCodeBase)).AbsolutePath; }        }                 /// <summary>        /// Gets or sets the dialect.  NHibernate.Dialect.MsSql2005Dialect is the default        /// </summary>        public string Dialect        {            get { return this._dialect; }            set { this._dialect = value; }        }         /// <summary>        /// Gets or sets the connection driver class. NHibernate.Driver.SqlClientDriver is the default.        /// </summary>        /// <value>The connection driver class.</value>        public string ConnectionDriverClass        {            get { return this._connectionDriverClass; }            set { this._connectionDriverClass = value; }        }         /// <summary>        /// Gets or sets the connection string used to access the ddl.        /// </summary>        /// <value>The connection string.</value>        [Required]        public string ConnectionString        {            get { return this._connectionString; }            set { this._connectionString = value; }        }         /// <summary>        /// Gets or sets the delimiter.  GO is the default.        /// </summary>        public string Delimiter        {            get { return this._delimiter; }            set { this._delimiter = value; }        }         /// <summary>        /// Gets or sets a value indicating whether the schema should be outputted to the console        /// </summary>        /// <value><see langword="true" /> to output to the console; otherwise, <see langword="false" />.</value>        public bool OutputToConsole        {            get { return this._outputToConsole; }            set { this._outputToConsole = value; }        }         /// <summary>        /// Gets or sets a value indicating whether the schema ddl script should only be exported        /// or if it should be executed on the database server.        /// </summary>        /// <value><see langword="true" /> if only output the script; otherwise, <see langword="false" /> - Execute the script on the db server.</value>        public bool ExportOnly        {            get { return this._exportOnly; }            set { this._exportOnly = value; }        }         /// <summary>        /// Gets or sets a value indicating whether only the drop script should be executed        /// </summary>        /// <value><see langword="true" /> if only drop objects; otherwise, <see langword="false" /> - Drop and Create objects.</value>        public bool DropOnly        {            get { return this._dropOnly; }            set { this._dropOnly = value; }        }         /// <summary>        /// Gets or sets a value indicating whether the ddl script should be formatted nicely        /// </summary>        /// <value><see langword="true" /> for nice format; otherwise, <see langword="false" /> - One statement per line.</value>        public bool FormatNice        {            get { return this._formatNice; }            set { this._formatNice = value; }        }         /// <summary>        /// Gets or sets the filename to write the ddl schema script to. Default is 'schema.sql'.        /// </summary>        /// <value>The output filename.</value>        public ITaskItem OutputFilename        {            get { return this._outputFilename; }            set { this._outputFilename = value; }        }         /// <summary>        /// Gets or sets the assemblies load with embedded *.hbm.xml resources.        /// </summary>        /// <value>The assemblies.</value>        [Required]        public ITaskItem[] Assemblies        {            get { return _assemblies; }            set { _assemblies = value; }        }         #region IDisposable Members         #endregion         ///<summary>        ///Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.        ///</summary>        ///<filterpriority>2</filterpriority>        public void Dispose()        {            CleanUp();        }    }}

And here is the MSBuild usage:

<PropertyGroup>  <ConnectionString>Server=localhost;Integrated Security=True</ConnectionString>  <OutputFilename>$(testdir)\schema.sql</OutputFilename>  <ExportOnly>true</ExportOnly>    </PropertyGroup> <ItemGroup>  <inputAssemblies Include="$(testdir)\A.dll"/>    </ItemGroup> <Target Name="Hbm2Ddl">  <Message Text="Firing Hbm2Ddl" />  <Hbm2ddl ConnectionString="Server=localhost;Integrated Security=True"           OutputFilename="$(testdir)/schema.sql" Assemblies="@(inputAssemblies)"/></Target>

I'm not sure if this should be submitted to the Community Tasks or not. I included it in my copy of their source for testing.