public class Surface : Rectangle
{
	public static string OrientationBack = "Back";
	public static string OrientationFront = "Front";
	public static string OrientationLeft = "Left";
	public static string OrientationRight = "Right";
	public static string OrientationUp = "Up";
	public static string OrientationDown = "Down";
 
	public string Orientation { get; set; }
}

public class Orientation
{
	public static string Back = "Back";
	public static string Front = "Front";
	public static string Left = "Left";
	public static string Right = "Right";
	public static string Up = "Up";
	public static string Down = "Down";	
}
 
public class Surface : Rectangle
{
	public string Orientation { get; set; }
}

public enum Orientation
{
	Back,
	Front,
	Left,
	Right,
	Up,
	Down	
}
 
public class Surface : Rectangle
{
	public Orientation Orientation { get; set; }
}

/// <summary>
/// The depth of this plane on the Axis it is aligned to 
/// </summary>
public decimal Z { get; private set; }
 
/// <summary>
/// Top of this surface on the axis it is aligned to
/// </summary>
public decimal Top { get; private set; }
 
/// <summary>
/// Bottom of this surface on the axis it is aligned to
/// </summary>
public decimal Bottom { get; private set; }
 
/// <summary>
/// Left side of this surface on the axis it is aligned to
/// </summary>
public decimal Left { get; private set; }
 
/// <summary>
/// Right side of this surface on the axis it is aligned to
/// </summary>
public decimal Right { get; private set; }

private void TranslatePoint(Point point)
{
	switch(Orientation)
	{
		case Orientation.Back:
			Z = point.Y;
			Left = point.X;
			Top = point.Z;
			Right = Left - Width;
			Bottom = Top - Height;
			break;
		case Orientation.Front:
			Z = point.Y;
			Left = point.X;
			Top = point.Z;
			Right = Left + Width;
			Bottom = Top - Height;
			break;
		case Orientation.Left:
			Z = point.X;
			Left = point.Y;
			Top = point.Z;
			Right = Left + Width;
			Bottom = Top - Height;
			break;
		case Orientation.Right:
			Z = point.X;
			Left = point.Y;
			Top = point.Z;
			Right = Left - Width;
			Bottom = Top - Height;
			break;
		case Orientation.Up:
			Z = point.Z;
			Left = point.X;
			Top = point.Y;
			Right = Left + Width;
			Bottom = Top + Height;
			break;
		case Orientation.Down:
			Z = point.Z;
			Left = point.X;
			Top = point.Y;
			Right = Left + Width;
			Bottom = Top - Height;
			break;		
	}
}

public class Orientation
{
	private readonly Func<Point, Point> _translator;
	private readonly MathOp _increaseX;
	private readonly MathOp _increaseY;
	private readonly MathOp _increaseZ;
	private readonly Func<Orientation> _flipside;
 
	/// <summary>
	/// Creates a new orientation
	/// </summary>
	/// <param name="translator">Method to translate a global point into a local point</param>
	/// <param name="increaseX">Math operation necessary increase X values</param>
	/// <param name="increaseY">Math operation necessary increase X values</param>
	/// <param name="increaseZ">Math operation necessary increase X values</param>
	/// <param name="flipside">The flipside of this orientation</param>
	private Orientation(Func<Point, Point> translator, 
		MathOp increaseX, 
		MathOp increaseY, 
		MathOp increaseZ,
		Func<Orientation> flipside)
	{
		if (translator == null) throw new ArgumentNullException("translator");
		if (increaseX == null) throw new ArgumentNullException("increaseX");
		if (increaseY == null) throw new ArgumentNullException("increaseY");
		if (increaseZ == null) throw new ArgumentNullException("increaseZ");
		if (flipside == null) throw new ArgumentNullException("flipside");
		_translator = translator;
		_increaseX = increaseX;
		_increaseY = increaseY;
		_increaseZ = increaseZ;
		_flipside = flipside;
	}
 
	/// <summary>
	/// The flipside of this orientation
	/// </summary>
	public Orientation FlipSide
	{
		get { return _flipside(); }
	}
 
	/// <summary>
	/// Translates a global point to this orientation
	/// </summary>
	/// <param name="point"></param>
	/// <returns></returns>
	public Point Translate(Point point)
	{
		return _translator(point);
	}
 
	public MathOp IncreaseX
	{
		get { return _increaseX; }
	}
 
	public MathOp IncreaseY
	{
		get { return _increaseY; }
	}
 
	public MathOp IncreaseZ
	{
		get { return _increaseZ; }
	}
}

public class Orientation
{
	public static Orientation Back = new Orientation(
		p => new Point(p.X, p.Z, p.Y), 
		MathOp.Subtract, 
		MathOp.Subtract, 
		MathOp.Subtract, 
		() => Front);
	public static Orientation Front = new Orientation(
		p => new Point(p.X, p.Z, p.Y), 
		MathOp.Add, 
		MathOp.Subtract, 
		MathOp.Add, 
		() => Back);
	public static Orientation Left = new Orientation(
		p => new Point(p.Y, p.Z, p.X), 
		MathOp.Add, 
		MathOp.Subtract, 
		MathOp.Subtract, 
		() => Right);
	public static Orientation Right = new Orientation(
		p => new Point(p.Y, p.Z, p.X), 
		MathOp.Subtract, 
		MathOp.Subtract, 
		MathOp.Add, 
		() => Left);
	public static Orientation Up = new Orientation(
		p => new Point(p.X, p.Y, p.Z), 
		MathOp.Add, 
		MathOp.Add, 
		MathOp.Add, 
		() => Down);
	public static Orientation Down = new Orientation(
		p => new Point(p.X, p.Y, p.Z), 
		MathOp.Add, 
		MathOp.Subtract, 
		MathOp.Subtract, 
		() => Up);

surface.Orientation = Orientation.Up;

if(Orientation == Orientation.Up)
	//do something

private void TranslatePoint(Point point)
{
	Point translated = Orientation.Translate(point);
	Z = translated.Z;
	Left = translated.X;
	Top = translated.Y;
	Right = Orientation.IncreaseX.Calculate(Left, Width);
	Bottom = Orientation.IncreaseY.Calculate(Top, Height);
}

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="MemX.Data.Entities" namespace="MemX.Data.Entities.RMS">
  <class name="Item" table="$RmsDB.dbo.Item" lazy="false">
    <id name="ID" column="ID" type="Int32">
      <generator class="native" />
    </id>
    <property name="Description" column="Description"/>
  </class>
</hibernate-mapping>

/// <summary>
/// Helps to map table symbols in the NH mappings to actual table/database names
/// </summary>
public class NHTableMappings
{
    /// <summary>
    /// Maps from the placeholder string to the real table/database name
    /// </summary>
    public IDictionary<string, string> Mappings { get; protected set; }
 
    /// <summary>
    /// Creates a set of table/database mappings
    /// </summary>
    public NHTableMappings()
    {
        Mappings = new Dictionary<string, string>();
    }
}

/// <summary>
/// maps table symbols to actual table/database names
/// </summary>
/// <param name="configuration"></param>
/// <returns></returns>
public void MapTables(Configuration configuration)
{
    if (configuration == null) throw new ArgumentNullException("configuration");
 
    //get the tables using reflection
    FieldInfo tablesField = typeof (Configuration).GetField("tables", BindingFlags.Instance | BindingFlags.NonPublic);
    IDictionary<string, Table> tables = tablesField.GetValue(configuration) as IDictionary<string, Table>;
 
    if(tables == null)
        throw new InvalidOperationException("Couldn't retrieve table information from NHibernate configuration.");
 
    //look through NHTableMappings
    foreach (KeyValuePair<string, string> key_tableName in Mappings)
    {
        string tableKey = key_tableName.Key;
        string tableName = key_tableName.Value;
 
        IEnumerable<Table> tablesToChange = tables.Where(p => p.Key.Contains(tableKey)).Select(p => p.Value);
        foreach (Table table in tablesToChange)
        {
            table.Name = table.Name.Replace(tableKey, tableName);
        }
    }
}

//Build the NH configuration
Configuration nhConfiguration = new Configuration().Configure();
 
//add your mappings
NHTableMappings tableMappings = new NHTableMappings();
tableMappings.Mappings.Add("$RmsDB", "MyRmsDatabaseName");
 
//modify the NH configuration
tableMappings.MapTables(nhConfiguration);
 
//build your session factory
ISessionFactory sessionFactory = nhConfiguration.BuildSessionFactory();

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Reflection;
using System.Xml;
using log4net;
using NHibernate.Mapping;
using Configuration=NHibernate.Cfg.Configuration;
 
namespace MemX.Data
{
    /// <summary>
    /// Helps to map table symbols in the NH mappings to actual table/database names
    /// </summary>
    public class NHTableMappings
    {
        private static readonly ILog log = LogManager.GetLogger(typeof(NHTableMappings));
        public static readonly string ConfigSection = "nh-table-mappings";
        public static readonly string ConfigKey = "mapping";
        public static readonly string KeyAttribute = "table-key";
        public static readonly string NameAttribute = "table-name";
 
        /// <summary>
        /// Maps from the placeholder string to the real table/database name
        /// </summary>
        public IDictionary<string, string> Mappings { get; protected set; }
 
        /// <summary>
        /// Creates a set of table/database mappings
        /// </summary>
        public NHTableMappings()
        {
            Mappings = new Dictionary<string, string>();
        }
 
        /// <summary>
        /// Adds a mapping from a key to an actual name
        /// <para>Can be used for table names or DB names</para>
        /// </summary>
        /// <param name="tableKey"></param>
        /// <param name="tableName"></param>
        /// <param name="overwrite">Do we want to overwrite an existing value</param>
        public void AddMapping(string tableKey, string tableName, bool overwrite)
        {
            if (String.IsNullOrEmpty(tableKey)) throw new ArgumentNullException("tableKey");
            if (String.IsNullOrEmpty(tableName)) throw new ArgumentNullException("tableName");
 
            if (!Mappings.ContainsKey(tableKey))
                Mappings.Add(tableKey, tableName);
            else if(overwrite)
                Mappings[tableKey] = tableName;
        }
 
        /// <summary>
        /// maps table symbols to actual table/database names
        /// </summary>
        /// <param name="configuration"></param>
        /// <returns></returns>
        public void MapTables(Configuration configuration)
        {
            if (configuration == null) throw new ArgumentNullException("configuration");
 
            //get the tables using reflection
            FieldInfo tablesField = typeof (Configuration).GetField("tables", BindingFlags.Instance | BindingFlags.NonPublic);
            IDictionary<string, Table> tables = tablesField.GetValue(configuration) as IDictionary<string, Table>;
 
            if(tables == null)
                throw new InvalidOperationException("Couldn't retrieve table information from NHibernate configuration.");
 
            //look through NHTableMappings
            foreach (KeyValuePair<string, string> key_tableName in Mappings)
            {
                string tableKey = key_tableName.Key;
                string tableName = key_tableName.Value;
 
                IEnumerable<Table> tablesToChange = tables.Where(p => p.Key.Contains(tableKey)).Select(p => p.Value);
                foreach (Table table in tablesToChange)
                {
                    table.Name = table.Name.Replace(tableKey, tableName);
                }
            }
        }
 
        /// <summary>
        /// Reads the configuration from xml
        /// </summary>
        /// <param name="section"></param>
        /// <param name="overwrite">Do we want to overwrite existing configuration</param>
        public void ReadFromXml(XmlNode section, bool overwrite)
        {
            log.Debug("Reading table mappings from xml");
            if (section == null) throw new ArgumentNullException("section");
 
            if(section.LocalName != ConfigSection)
                throw new ConfigurationErrorsException(String.Format("Invalid section {0} in NHTableMappings configuration", section.LocalName));
 
            foreach (XmlNode node in section.ChildNodes)
            {
                if(node.LocalName != ConfigKey)
                    throw new ConfigurationErrorsException(String.Format("Invalid section {0} in NHTableMappings configuration", node.LocalName));
 
                string tableKey = node.Attributes[KeyAttribute].Value;
                string tableName = node.Attributes[NameAttribute].Value;
 
                AddMapping(tableKey, tableName, overwrite);
            }
        }
 
        /// <summary>
        /// Creates the mappings from an xml section
        /// </summary>
        /// <param name="section"></param>
        /// <param name="overwrite">Do we want to overwrite existing configuration</param>
        /// <returns></returns>
        public static NHTableMappings CreateFromXml(XmlNode section, bool overwrite)
        {
            NHTableMappings tableMappings = new NHTableMappings();
            tableMappings.ReadFromXml(section, overwrite);
 
            return tableMappings;
        }
 
        /// <summary>
        /// Creates the mappings from a config section
        /// </summary>
        /// <returns></returns>
        public static NHTableMappings CreateFromConfig()
        {
            NHTableMappings tableMappings = ConfigurationManager.GetSection(ConfigSection) as NHTableMappings;
            if(tableMappings == null)
                throw new ConfigurationErrorsException("Could not load table mappings confugration from app/web.config");
 
            return tableMappings;
        }
 
        /// <summary>
        /// Creates the mappings from a config section if it exists, or defaults to an empty mappings file
        /// </summary>
        /// <returns></returns>
        public static NHTableMappings CreateFromConfigOrDefault()
        {
            NHTableMappings mappings;
 
            try
            {
                mappings = CreateFromConfig();
            }
            catch (ConfigurationErrorsException)
            {
                mappings = new NHTableMappings();
            }
 
            return mappings;
        }
    }
}

using System.Configuration;
using System.Xml;
 
namespace MemX.Data
{
    public class NHTableMappingsConfigurationSectionHandler : IConfigurationSectionHandler
    {
        #region IConfigurationSectionHandler Members
 
        public object Create(object parent, object configContext, XmlNode section)
        {
            return NHTableMappings.CreateFromXml(section, true);
        }
 
        #endregion
    }
}

<configuration>
  <configSections>
    <section name="nh-table-mappings" type="MemX.Data.NHTableMappingsConfigurationSectionHandler, MemX.Data"/>
  </configSections>
  <nh-table-mappings>
    <mapping table-key="$RmsDB" table-name="RMSCal3"/>
  </nh-table-mappings>
</configruation>

    public static class NHTableMappingsExtension
    {
        public static Configuration MapTables(this Configuration configuration)
        {
            NHTableMappings tableMappings = NHTableMappings.CreateFromConfig();
 
            tableMappings.MapTables(configuration);
 
            return configuration;
        }
    }

            ISessionFactory sessionFactory = new Configuration()
                .Configure()
                .MapTables()
                .BuildSessionFactory();

//Think of this as a data session
public class Session
{
}
 
public class Model1
{
    public Session Session { get; set; }
 
    public Model1(Session session)
    {
        Session = session;
    }
}
 
public class Model2
{
    public Session Session { get; set; }
 
    public Model2(Session session)
    {
        Session = session;
    }
}
 
//this is my shell, it needs some models
public class Shell
{
    public Model1 Model1 { get; set; }
    public Model2 Model2 { get; set; }
 
    public Shell(Model1 model1, Model2 model2)
    {
        Model1 = model1;
        Model2 = model2;
    }
}

ObjectFactory.Initialize(
    x => {
             x.BuildInstancesOf()
                 .TheDefaultIsConcreteType();
             x.BuildInstancesOf()
                 .TheDefaultIsConcreteType();
             x.BuildInstancesOf()
                 .TheDefaultIsConcreteType();
             x.BuildInstancesOf()
                 .TheDefaultIsConcreteType();
    });

Shell shell = ObjectFactory.GetInstance();
 
Assert.AreNotEqual(shell.Model1.Session, shell.Model2.Session);

Assert.AreNotEqual(ObjectFactory.GetInstance(), ObjectFactory.GetInstance());

WindsorContainer container = new WindsorContainer();
 
container.AddComponentWithLifestyle("Session", typeof(Session), LifestyleType.Transient);
container.AddComponentWithLifestyle("Model1", typeof(Model1), LifestyleType.Transient);
container.AddComponentWithLifestyle("Model2", typeof(Model2), LifestyleType.Transient);
container.AddComponentWithLifestyle("Shell", typeof(Shell), LifestyleType.Transient);
 
Shell shell = container.Resolve();
 
Assert.AreNotEqual(shell.Model1.Session, shell.Model2.Session);

var builder = new ContainerBuilder();
 
builder.Register().FactoryScoped();
builder.Register().FactoryScoped();
builder.Register().FactoryScoped();
builder.Register().FactoryScoped();
 
var container = builder.Build();
 
Shell shell = container.Resolve();
 
Assert.AreNotEqual(shell.Model1.Session, shell.Model2.Session);

x.BuildInstancesOf()
    .TheDefault.Is.OfConcreteType().CtorDependency().Is( x.OfConcreteType() );